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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/ein/order-ein.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/ein/order-ein.sml

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

revision 2447, Sat Sep 28 18:10:51 2013 UTC revision 2448, Tue Oct 1 00:57:08 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
8        structure P= Printer
9    
10    
11    
12    
13      in      in
14    
15    fun create(b)=P.printerE(Ein.EIN{params=[], index=[], body=b})
16    
17    fun match(_,[],s)=0
18        | match([],j1::j2::jx,s)= match(s,j2::jx,s)
19        | match(i::ix, j::jx,s)= if(i=j) then 1  else match(ix, j::jx,s)
20    
21    fun matchEps((a,b,c),(d,e,f))=match([a,b,c],[d,e,f],[a,b,c])
22    
23    
24  (*Orders the expression correctly.*)  (*Orders the expression correctly.*)
25  fun orderfn(Ein.EIN{params, index, body})= let  fun orderfn(Ein.EIN{params, index, body})= let
26     fun order(body)=     val changed =ref false
27      (case body of E.Prod es=> let     fun order(body)=(case body
28          fun pattern(s,[],y,z,(E.Epsilon e1)::es)= pattern(s,[E.Epsilon e1],y,z,es)          of E.Const _ => body
29              |pattern(s,x,y,z,(E.Epsilon e2)::es)=let          | E.Tensor _=> body
30                  fun sorteps(left,[], eps)= pattern(s,left@[eps],y,z, es)          | E.Field _ => body
31                  | sorteps(left, E.Epsilon(i,j,k)::right, E.Epsilon(a,b,c))=          | E.Kernel _ => body
32                      if(i>a) then pattern(s,left@[E.Epsilon(a,b,c)]@E.Epsilon(i,j,k)::right,y,z,es)          | E.Delta _ => body
33                      else sorteps(left@ [E.Epsilon(i,j,k)], right, E.Epsilon(a,b,c))          | E.Value _ => body
34                  in sorteps([],x, E.Epsilon e2) end          | E.Epsilon _=>body
35            | E.Partial _ => body
36              |pattern(s,x,y,z,(E.Delta d1)::es)= pattern(s,x,y@ [E.Delta d1],z,es)          | E.Sum(c1,E.Sum(c2, e))=>(changed:=true;E.Sum(c1@c2,order e))
37              |pattern(s, x, y, z, (E.Sum(1, esum)::es))= pattern(s, x, y, z@[E.Sum(1, order esum)], es)          | E.Sum(c1,
38              |pattern(s, x, y, z, (E.Sum(c, E.Prod p)::es))= pattern(s+c, x,y,z,p@es)              E.Prod(E.Epsilon eps1::E.Sum(c2,E.Prod(E.Epsilon eps2::s2))::ps))=>(case matchEps(eps1,eps2)
39              |pattern(s, x, y, z, (E.Sum(c, esum)::es))=pattern(s+c, x, y, z, [esum]@es)                  of 1=>(changed:=true;E.Sum(c1@c2, E.Prod([E.Epsilon eps1,E.Epsilon eps2]@s2@ps)))
40              |pattern(s,x,y,z,(E.Prod p1)::es)=                  |_=> let
41                  let val(s2,x2,y2,z2,e2)=pattern(0,[],[],[],p1) in                      val a=order(E.Prod s2)
42                  pattern(s+s2,x@x2,y@y2,z@z2@e2,es) end                      val b=order(E.Prod ps)
43              |pattern(s,x,y,z,(e4)::es)=pattern(s,x,y,z@[e4],es)  
44              |pattern(s,x,y,z,[])= (s,x,y,z,[])                      val(a',b')= (case (a,b)
45          val (s,x,y,z,e4)=pattern(0,[],[],[],es)                          of (E.Prod p1, E.Prod p2) =>(p1,p2)
46          in if (s=0) then  E.Prod (x@y@z@e4)                          | (E.Prod p1, _) =>(p1,[b])
47              else E.Sum(s, E.Prod (x@y@z@e4))                          | (_, E.Prod p2) =>([a],p2)
48                            | _=> ([a], [b])
49                            (*end case*))
50                    in E.Sum(c1,E.Prod([E.Epsilon eps1,E.Sum(c2,E.Prod([E.Epsilon eps2] @a'))] @ b'))
51          end          end
52                )
53            | E.Sum(c,e)=>E.Sum(c, order e)
54            | E.Neg e => E.Neg(order e)
55      | E.Add es =>    E.Add(List.map order es)      | E.Add es =>    E.Add(List.map order es)
56      | E.Sub (a,b)=>  E.Sub(order a, order b)          | E.Sub(e1,e2) => E.Sub(order e1, order e2)
57      | E.Div (a,b)=> E.Div(order a, order b)          | E.Div(e1,e2)=> E.Div(order e1, order e2)
58      | E.Sum(c, E.Sum(1,e))=>E.Sum(c, E.Sum(1, order e))          | E.Apply(e1,e2)=> E.Apply(e1, order e2)
59      | E.Sum(c, E.Prod((E.Sum(1, e))::p))=>  E.Sum(c, order(E.Prod((E.Sum(1, order e))::p)))          | E.Conv(e1,mx)=> E.Conv(order e1, mx)
60      | E.Sum(c, E.Sum(c',e))=> E.Sum(c+c', e)          | E.Probe(e1,e2)=> E.Probe(e1,order e2)
61      | E.Sum(c, E.Prod((E.Sum(c', e))::p))=>E.Sum(c+c', order(E.Prod([e]@p)))          | E.Image es => E.Image(List.map order es)
62      | E.Sum (c,es)=>     E.Sum(c, order es)          | E.Prod(E.Sum(c1,esum1)::E.Sum(c2,esum2)::es)=> let
63      | E.Apply(d,e)=> E.Apply(d, order e)              val esum1'=order esum1
64      | _=> body)              val esum2'=order esum2
65      val b=order(body)              val es'=List.map order es
66     in (Ein.EIN{params=params, index=index, body=b}) end              val alt= E.Prod([E.Sum(c1,esum1),E.Sum(c2,esum2)]@es')
67                 in (case (esum1', esum2')
68                    of   (E.Prod(E.Epsilon e1::es1),E.Prod(E.Epsilon e2::es2)) =>(case matchEps(e1,e2)
69                        of 1=> (changed:=true;E.Prod([E.Sum(c1@c2,E.Prod (es1@es2))]@es'))
70                        | _=>  alt)
71                    |_=> alt)
72                end
73            | E.Prod e=>let
74                fun prodMatch(c,eps,dels,p,[])= (c,E.Prod(eps@dels@p))
75                | prodMatch(c,eps,[],[],(E.Epsilon e)::es)=prodMatch(c,eps@[E.Epsilon e],[],[], es)
76                | prodMatch(_,eps,dels,p,(E.Epsilon e)::es)=prodMatch(1,eps@[E.Epsilon e],dels,p, es)
77                | prodMatch(c,eps,dels,[],(E.Delta d)::es)=prodMatch(c,eps,dels@[E.Delta d],[], es)
78                | prodMatch(_,eps,dels,p,(E.Delta d)::es)=prodMatch(1,eps,dels@[E.Delta d],p, es)
79                | prodMatch(c,eps,dels,p, e::es)= prodMatch(c,eps,dels, p@[order e], es)
80                val(change,result)=prodMatch (0,[],[],[],e)
81                in (case change
82                    of 1=> (changed:=true;result)
83                    |_=> result) end
84                )
85    
86        fun loop body = let
87        val body' = order body
88            in
89    if !changed
90    then (changed := false; loop body')
91    else body'
92    end
93    val b = loop body
94    val b'=order b
95       (* val b=order(body)*)
96       in (Ein.EIN{params=params, index=index, body=b'}) end
97    
98  end (* local *)  end (* local *)
99    

Legend:
Removed from v.2447  
changed lines
  Added in v.2448

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