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

SCM Repository

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

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

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

revision 2485, Mon Oct 21 16:34:57 2013 UTC revision 2494, Wed Oct 23 14:32:58 2013 UTC
# Line 47  Line 47 
47          (* end case *)          (* end case *)
48           end           end
49    
50    (* filter function shifts constant/greeks to outside product*)
51    fun filter([],pre,post)=(pre,post)
52        | filter(E.Const c::es, pre, post)=filter(es, pre@[E.Const c],post)
53        | filter(E.Delta d::es,pre,post)=filter(es,pre@[E.Delta d],post)
54        | filter(E.Value v::es, pre, post)=filter(es, pre@[E.Value v],post)
55        | filter(E.Epsilon e::es, pre, post)=filter(es, pre@[E.Epsilon e],post)
56        | filter(E.Tensor(id,[])::es, pre, post)=filter(es, pre@[E.Tensor(id,[])],post)
57        | filter(E.Prod p::es, pre, post)=filter(p@es,pre,post)
58        | filter(e::es, pre, post)= filter(es, pre, post@[e])
59    
60    
61    
62    fun prodPartial ([e1],p1)= E.Prod[E.Partial p1,e1]
63      | prodPartial((e1::e2),p1)=let
64        val l= prodPartial(e2,p1)
65        val (_,e2')= mkProd[e1,l]
66        val (_,e1')=mkProd(e2@ [E.Partial p1, e1])
67        in
68            E.Add[e1',e2']
69        end
70    
71    fun prodAppPartial ([e1],p1)= E.Apply(E.Partial p1,e1)
72      | prodAppPartial((e1::e2),p1)=let
73        val l= prodAppPartial(e2,p1)
74        val (_,e2')= mkProd[e1,l]
75        val (_,e1')=mkProd(e2@ [E.Apply(E.Partial p1, e1)])
76        in
77            E.Add[e1',e2']
78        end
79    
80    
81    
82    
83    (*remove eps Index*)
84  fun rmEpsIndex(_,_,[])=[]  fun rmEpsIndex(_,_,[])=[]
85  | rmEpsIndex([],[],cs)=cs  | rmEpsIndex([],[],cs)=cs
86  | rmEpsIndex([],m ,e1::cs)=[e1]@rmEpsIndex(m,[],cs)  | rmEpsIndex([],m ,e1::cs)=[e1]@rmEpsIndex(m,[],cs)
# Line 57  Line 88 
88      if(i=c) then rmEpsIndex(rest@ix,[],cs)      if(i=c) then rmEpsIndex(rest@ix,[],cs)
89      else rmEpsIndex(ix,rest@[i],(E.V c)::cs)      else rmEpsIndex(ix,rest@[i],(E.V c)::cs)
90    
91    (*remove index variable from list*)
92    fun rmIndex(_,_,[])=[]
93        | rmIndex([],[],cs)=cs
94        | rmIndex([],m ,e1::cs)=[e1]@rmIndex(m,[],cs)
95        | rmIndex(i::ix,rest ,c::cs)=
96            if(i=c) then rmIndex(rest@ix,[],cs)
97            else rmIndex(ix,rest@[i],c::cs)
98    
99    
100  (* Transform eps to deltas*)  (* Transform eps to deltas*)
101  fun epsToDels(E.Sum(count,E.Prod e))= let  fun epsToDels(E.Sum(count,E.Prod e))= let
# Line 109  Line 148 
148          end          end
149    
150      val (es,rest)=findeps([],e)      val (es,rest)=findeps([],e)
   
151      in      in
152          dist(es,[],rest)          dist(es,[],rest)
153      end      end
154    
155    
 fun rmIndex(_,_,[])=[]  
     | rmIndex([],[],cs)=cs  
     | rmIndex([],m ,e1::cs)=[e1]@rmIndex(m,[],cs)  
     | rmIndex(i::ix,rest ,c::cs)=  
         if(i=c) then rmIndex(rest@ix,[],cs)  
         else rmIndex(ix,rest@[i],c::cs)  
156    
157  (* Apply deltas to tensors/fields*)  (* Apply deltas to tensors/fields*)
158  fun reduceDelta(E.Sum(c,E.Prod p))=let  fun reduceDelta(E.Sum(c,E.Prod p))=let
# Line 129  Line 161 
161      | findDeltas(dels,rest,E.Epsilon eps::es)=findDeltas(dels,rest@[E.Epsilon eps],es)      | findDeltas(dels,rest,E.Epsilon eps::es)=findDeltas(dels,rest@[E.Epsilon eps],es)
162      | findDeltas(dels,rest,es)=  (dels,rest,es)      | findDeltas(dels,rest,es)=  (dels,rest,es)
163    
   
164      fun distribute(change,d,dels,[],done)=(change,dels@d,done)      fun distribute(change,d,dels,[],done)=(change,dels@d,done)
165      | distribute(change,[],[],e,done)=(change,[],done@e)      | distribute(change,[],[],e,done)=(change,[],done@e)
166      | distribute(change,E.Delta(i,j)::ds,dels,E.Tensor(id,[tx])::es,done)=      | distribute(change,E.Delta(i,j)::ds,dels,E.Tensor(id,[tx])::es,done)=
# Line 145  Line 176 
176      val index=rmIndex(change,[],c)      val index=rmIndex(change,[],c)
177    
178    in    in
179         (change, E.Sum(index,E.Prod (eps@dels'@done)))         (length change, E.Sum(index,E.Prod (eps@dels'@done)))
180    end    end
181    
182    
183  fun mkApplySum(E.Apply(E.Partial d,E.Sum(c,e)))=(print "apply sum";case e  (*Apply Sum*)
184    fun mkApplySum(E.Apply(E.Partial d,E.Sum(c,e)))=(case e
185      of E.Tensor(a,[])=>(1,E.Const 0.0)      of E.Tensor(a,[])=>(1,E.Const 0.0)
186      | E.Const _ =>(1,E.Const 0.0)      | E.Const _ =>(1,E.Const 0.0)
187      | E.Add l => (1,E.Add(List.map (fn e => E.Apply(E.Partial d, E.Sum(c,e))) l))      | E.Add l => (1,E.Add(List.map (fn e => E.Apply(E.Partial d, E.Sum(c,e))) l))
188      | E.Sub(e2, e3) =>(1, E.Sub(E.Apply(E.Partial d, E.Sum(c,e2)), E.Apply(E.Partial d, E.Sum(c,e3))))      | E.Sub(e2, e3) =>(1, E.Sub(E.Apply(E.Partial d, E.Sum(c,e2)), E.Apply(E.Partial d, E.Sum(c,e3))))
   
189      | E.Prod [e1]=>(1,E.Apply(E.Partial d,E.Sum(c,e1)))      | E.Prod [e1]=>(1,E.Apply(E.Partial d,E.Sum(c,e1)))
190      | E.Prod(E.Tensor(a,[])::e1::[])=>(1,E.Prod[E.Tensor(a,[]),E.Apply(E.Partial d,E.Sum(c,e1))])      | E.Prod es=> let
191            val (pre, post)= filter(es,[],[])
192      | E.Prod(E.Tensor(a,[])::e2)=>(1,E.Prod[E.Tensor(a,[]),E.Apply(E.Partial d,E.Sum(c,E.Prod e2))])          val x1= prodAppPartial(post,d)
193            in  (case x1
194      | E.Prod es=>(let                  of E.Add a=> (1,E.Add(List.map (fn e =>  E.Sum(c,E.Prod(pre@[e]))) a))
195          fun prod [e1] =E.Apply(E.Partial d,e1)                  | _ => (1,E.Sum(c, E.Prod(pre@[x1])))
196          | prod (E.Epsilon eps1::es) = (E.Apply(E.Partial d, E.Prod (E.Epsilon eps1::es)))              (*end case*))
197          | prod (E.Delta e1::es) = (E.Apply(E.Partial d, E.Prod (E.Delta e1::es)))          end
         | prod (E.Prod e1::es)=prod(e1@es)  
         | prod(e1::e2)=(let  
             val l= prod(e2)  
             val (_, a)= mkProd[e1,l]  
             val lr=e2 @[E.Apply(E.Partial d,e1)]  
             val(_,b) =mkProd lr  
             in  E.Add[b,a]  
             end)  
         val chainrule=prod es  
         in (1,E.Sum(c, chainrule)) end)  
198      |_=>(0,E.Apply(E.Partial d,E.Sum(c,e)))      |_=>(0,E.Apply(E.Partial d,E.Sum(c,e)))
199      (* end case*))      (* end case*))
200    
201  fun mkApply2(E.Apply(E.Partial d,e))=(print "aa";case e  (*Apply*)
202    fun mkApply(E.Apply(E.Partial d,e))=(case e
203      of E.Tensor(a,[])=>(1,E.Const 0.0)      of E.Tensor(a,[])=>(1,E.Const 0.0)
204      | E.Const _ =>(1,E.Const 0.0)      | E.Const _ =>(1,E.Const 0.0)
205      | E.Add l => (1,E.Add(List.map (fn e => E.Apply(E.Partial d, e)) l))      | E.Add l => (1,E.Add(List.map (fn e => E.Apply(E.Partial d, e)) l))
206      | E.Sub(e2, e3) =>(1, E.Sub(E.Apply(E.Partial d, e2), E.Apply(E.Partial d, e3)))      | E.Sub(e2, e3) =>(1, E.Sub(E.Apply(E.Partial d, e2), E.Apply(E.Partial d, e3)))
207      | E.Apply(E.Partial e1,e2)=>(1,E.Apply(E.Partial(d@e1), e2))      | E.Apply(E.Partial d2,e2)=>(1,E.Apply(E.Partial(d@d2), e2))
208      | E.Prod [e1]=>(1,E.Apply(E.Partial d,e1))      | E.Prod [e1]=>(1,E.Apply(E.Partial d,e1))
209      | E.Prod(E.Tensor(a,[])::e1::[])=>(1,E.Prod[E.Tensor(a,[]),E.Apply(E.Partial d,e1)])      | E.Prod es=> let
210      | E.Prod(E.Tensor(a,[])::e2)=>(1,E.Prod[E.Tensor(a,[]),E.Apply(E.Partial d,E.Prod e2)])          val (pre, post)= filter(es,[],[])
211      | E.Prod es=> (let          val (_,x)=mkProd(pre@[prodAppPartial(post,d)])
212          fun prod [e1] =(0,E.Apply(E.Partial d,e1))          in (1,x) end
         | prod (E.Epsilon eps1::es) = (0,E.Apply(E.Partial d, E.Prod (E.Epsilon eps1::es)))  
         | prod (E.Delta e1::es) = (0,E.Apply(E.Partial d, E.Prod (E.Delta e1::es)))  
          | prod (E.Prod e1::es)=prod(e1@es)  
         | prod(E.Tensor t::e2)=(let  
             val (_,l)= prod(e2) val m= E.Prod[E.Tensor t,l]  
             val lr=e2 @[E.Apply(E.Partial d,E.Tensor t)] val(b,a) =mkProd lr  
             in  (1,E.Add[a,m])  
             end)  
         | prod(E.Field f::e2)=(let  
             val (_,l)= prod(e2) val m= E.Prod[E.Field f,l]  
             val lr=e2 @[E.Apply(E.Partial d,E.Field f)] val(b,a) =mkProd lr  
             in  (1,E.Add[a,m])  
             end)  
         | prod e = (0,E.Apply(E.Partial d, E.Prod e))  
   
   
         val (a,b)= prod es  
   
         in (a, b) end)  
213      |_=>(0,E.Apply(E.Partial d,e))      |_=>(0,E.Apply(E.Partial d,e))
214      (* end case*))      (* end case*))
215    
216  fun mkSumApply2(E.Sum(c,E.Apply(E.Partial d,e)))=(print "in here ";case e  (*Sum Apply*)
217    fun mkSumApply(E.Sum(c,E.Apply(E.Partial d,e)))=(case e
218      of E.Const _=>(1,E.Const 0.0)      of E.Const _=>(1,E.Const 0.0)
219      | E.Tensor(_,[])=> (1,E.Const 0.0)      | E.Tensor(_,[])=> (1,E.Const 0.0)
220      | E.Field _=>(0,E.Sum(c,E.Apply(E.Partial d,e)))      | E.Field _=>(0,E.Sum(c,E.Apply(E.Partial d,e)))
221      | E.Apply(E.Partial e1,e2)=>(1,E.Sum(c,E.Apply(E.Partial(d@e1),e2)))      | E.Apply(E.Partial d1,e2)=>(1,E.Sum(c,E.Apply(E.Partial(d@d1),e2)))
   
222      | E.Add l => (1,E.Add(List.map (fn e => E.Sum(c,E.Apply(E.Partial d, e))) l))      | E.Add l => (1,E.Add(List.map (fn e => E.Sum(c,E.Apply(E.Partial d, e))) l))
223      | E.Sub(e2, e3) =>      | E.Sub(e1, e2) => (1, E.Sub(E.Sum(c,E.Apply(E.Partial d, e1)), E.Sum(c,E.Apply(E.Partial d, e2))))
                 (*(0,E.Sub(e2,e3))  
                 *)  
                 (print "sub";(1, E.Sub(E.Sum(c,E.Apply(E.Partial d, e2)), E.Sum(c,E.Apply(E.Partial d, e3)))))  
   
      | E.Prod [e1]=>(print "one";(1,E.Sum(c,E.Apply(E.Partial d,e1))))  
224    
225        | E.Prod [e1]=>(1,E.Sum(c,E.Apply(E.Partial d,e1)))
226    
     | E.Prod(E.Tensor(a,[])::e2::[])=>("in scalar";(1, E.Prod[E.Tensor(a,[]),E.Sum(c,E.Apply(E.Partial d,e2))]))  
227    
228      | E.Prod(E.Tensor(a,[])::e2)=>("in scalar";(1, E.Prod[E.Tensor(a,[]),E.Sum(c,E.Apply(E.Partial d,E.Prod e2))]))      | E.Prod(E.Tensor(a,[])::e2)=>(1, E.Prod[E.Tensor(a,[]),E.Sum(c,E.Apply(E.Partial d,E.Prod e2))])
229    
230      | E.Prod es =>(print "in prod";let      | E.Prod es =>(print "in prod";let
231          fun prod (change,rest, sum,partial,[]) = (change,E.Sum(sum,E.Apply(E.Partial partial,E.Prod rest)))          fun prod (change,rest, sum,partial,[]) = (change,E.Sum(sum,E.Apply(E.Partial partial,E.Prod rest)))
# Line 273  Line 271 
271          | _=>(print "nope";(0,E.Sum(c,E.Apply(E.Partial d,e))))          | _=>(print "nope";(0,E.Sum(c,E.Apply(E.Partial d,e))))
272          (* end case*))          (* end case*))
273    
 (*  
 E.Sum(c,Apply(d,e))  
     try E.Sum(c,e)=> E.Sum(c',e')  
     ==>    E.Sum(c',E.Apply(d,e'))  
         E.Apply(d,e')=> E.Apply(d',e'')  
     ==>E.Sum(c',E.Apply(d',e'')  
 *)  
274    
275  (*Apply normalize to each term in product list  (*Apply normalize to each term in product list
276  or Apply normalize to tail of each list*)  or Apply normalize to tail of each list*)
# Line 295  Line 286 
286                | E.Delta _ => body                | E.Delta _ => body
287                | E.Value _ =>body                | E.Value _ =>body
288                | E.Epsilon _=>body                | E.Epsilon _=>body
289                  | E.Img _ => body
290                | E.Neg e => E.Neg(rewriteBody e)                | E.Neg e => E.Neg(rewriteBody e)
291                | E.Add es => let val (change,body')= mkAdd(List.map rewriteBody es)                | E.Add es => let val (change,body')= mkAdd(List.map rewriteBody es)
292                     in if (change=1) then ( changed:=true;body') else body' end                     in if (change=1) then ( changed:=true;body') else body' end
# Line 304  Line 295 
295                | E.Partial _=>body                | E.Partial _=>body
296                | E.Conv (V, alpha)=> E.Conv(rewriteBody V, alpha)                | E.Conv (V, alpha)=> E.Conv(rewriteBody V, alpha)
297                | E.Probe(u,v)=>  E.Probe(rewriteBody u, rewriteBody v)                | E.Probe(u,v)=>  E.Probe(rewriteBody u, rewriteBody v)
               | E.Img _ => body  
298    
299                  (*Product*)  
300                    (*************Product**************)
301                | E.Prod [e1] => rewriteBody e1                | E.Prod [e1] => rewriteBody e1
302                | E.Prod(e1::(E.Add(e2))::e3)=>                | E.Prod(e1::(E.Add(e2))::e3)=>
303                     (changed := true; E.Add(List.map (fn e=> E.Prod([e1, e]@e3)) e2))                     (changed := true; E.Add(List.map (fn e=> E.Prod([e1, e]@e3)) e2))
304                | E.Prod(e1::(E.Sub(e2,e3))::e4)=>                | E.Prod(e1::(E.Sub(e2,e3))::e4)=>
305                     (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 )))
               | E.Prod [E.Partial r1,E.Conv(f,deltas)]=>  
                    (changed:=true;E.Conv(f,deltas@r1))  
306                | E.Prod (E.Partial r1::E.Conv(f,deltas)::ps)=>                | E.Prod (E.Partial r1::E.Conv(f,deltas)::ps)=>
307                     (changed:=true;                     (changed:=true;
308                      let val (change,e)=mkProd([E.Conv(f,deltas@r1)]@ps)                      let val (change,e)=mkProd([E.Conv(f,deltas@r1)]@ps)
# Line 325  Line 314 
314               | E.Prod(E.Partial r1::E.Partial r2::p)=>               | E.Prod(E.Partial r1::E.Partial r2::p)=>
315                     (changed:=true;E.Prod([E.Partial(r1@r2)]@p))                     (changed:=true;E.Prod([E.Partial(r1@r2)]@p))
316               | E.Prod [E.Partial _, _] =>body               | E.Prod [E.Partial _, _] =>body
   
317               | E.Prod (E.Partial p1::es)=> (let               | E.Prod (E.Partial p1::es)=> (let
318                  fun prod [e1] =E.Apply(E.Partial p1,e1)                      val (pre,post)=filter((List.map rewriteBody es),[],[])
319                  | prod(e1::e2)=(let                      val x=E.Prod(pre@[prodPartial(post,p1)])
320                      val l= prod(e2) val m= E.Prod[e1,l]                  in (changed:=true;x) end)
                     val lr=e2 @[E.Apply(E.Partial p1,e1)] val(b,a) =mkProd lr  
                     in  E.Add[a,m]  
                     end)  
                 in (changed:=true;prod es) end)  
   
321                | E.Prod(E.Sum(c1,E.Prod(E.Epsilon e1::es1))::E.Sum(c2,E.Prod(E.Epsilon e2::es2))::es)=>let                | E.Prod(E.Sum(c1,E.Prod(E.Epsilon e1::es1))::E.Sum(c2,E.Prod(E.Epsilon e2::es2))::es)=>let
322                    val (change,e,rest)=epsToDels(E.Sum(c1@c2, E.Prod([E.Epsilon e1, E.Epsilon e2]@es1@es2@es)))                    val (change,e,rest)=epsToDels(E.Sum(c1@c2, E.Prod([E.Epsilon e1, E.Epsilon e2]@es1@es2@es)))
323                    in(case (change,e, rest)                    in(case (change,e, rest)
324                      of (1,[e1],_)=> e1                      of (1,[e1],_)=> (changed:=true;e1)
325                      | _=>body)                      | _=>body
326                        (*end case*))
327                  end                  end
328                | E.Prod(e::es)=>let                | E.Prod(e::es)=>let
329                      val e'=rewriteBody e                      val e'=rewriteBody e
330                      val e2=rewriteBody(E.Prod es)                      val e2=rewriteBody(E.Prod es)
331                      val(a,b)=(case e2 of E.Prod p'=> mkProd([e']@p')                      val(_,b)=(case e2
332                            of E.Prod p'=> mkProd([e']@p')
333                          |_=>mkProd [e',e2])                          |_=>mkProd [e',e2])
334                      in b                      in b
335                     end                     end
336    
337                (*Apply*)                (**************Apply**************)
338    
339                | E.Apply(E.Partial d,E.Sum(c,e))=>let                (* Apply, Sum*)
340                      val(c,e')=mkApplySum(E.Apply(E.Partial d,E.Sum(c, rewriteBody e)))                | E.Apply(E.Partial d,E.Sum e)=>let
341                        val(c,e')=mkApplySum(E.Apply(E.Partial d,rewriteBody(E.Sum  e)))
342                      val e''=(case e'                      val e''=(case e'
343                          of E.Apply(d,E.Sum s)=>E.Apply(d,rewriteBody(E.Sum s))                          of E.Apply(p,E.Sum s)=>E.Apply(p,rewriteBody(E.Sum s))
344                          |_=> e')                          |_=> e')
345                  in (print "bb";case c of 1=>(changed:=true;e'')                      in (case c
346                      |_=> e'')end                          of 1=>(changed:=true;e'')
347                | E.Apply(E.Partial [],e)=> e                          |_=> e''
348                        (*end case*))
349                        end
350    
351    
352                  | E.Apply(E.Partial [],e)=> e
353                | E.Apply(E.Partial p, e)=>let                | E.Apply(E.Partial p, e)=>let
354                      val body'=E.Apply(E.Partial p, rewriteBody e)                      val body'=E.Apply(E.Partial p, rewriteBody e)
355                      val (c, e')=mkApply2(body')                      val (c, e')=mkApply(body')
356                  in (case c of 1=>(changed:=true;e')                  in (case c of 1=>(changed:=true;e')
357                      | _ =>e') end                      | _ =>e') end
358                | E.Apply(e1,e2)=>E.Apply(rewriteBody e1, rewriteBody e2)                | E.Apply(e1,e2)=>E.Apply(rewriteBody e1, rewriteBody e2)
359    
360    
361    
362                (* Sum *)                (************** Sum *****************)
363                | E.Sum([],e)=> (changed:=true;rewriteBody e)                | E.Sum([],e)=> (changed:=true;rewriteBody e)
364                | E.Sum(_,E.Const c)=>(changed:=true;E.Const c)                | E.Sum(_,E.Const c)=>(changed:=true;E.Const c)
365                | E.Sum(c,(E.Add l))=> (changed:=true;E.Add(List.map (fn e => E.Sum(c,e)) l))                | E.Sum(c,(E.Add l))=> (changed:=true;E.Add(List.map (fn e => E.Sum(c,e)) l))
366                | E.Sum(c,E.Sub(e1,e2))=>(changed:=true; E.Sub(E.Sum(c,e1),E.Sum(c,e2)))                | E.Sum(c,E.Sub(e1,e2))=>(changed:=true; E.Sub(E.Sum(c,e1),E.Sum(c,e2)))
367                | E.Sum(c,E.Prod(E.Epsilon eps1::E.Epsilon eps2::ps))=>                | E.Sum(c,E.Prod(E.Epsilon eps1::E.Epsilon eps2::ps))=>
368                     let val (i,e,rest)=epsToDels(body)                     let val (i,e,rest)=epsToDels(body)
369                  in (print "eps to dels \n ";case (i, e,rest)                  in (case (i, e,rest)
370                  of (1,[e1],r) =>(print "changed\n";changed:=true;e1)                      of (1,[e1],r) =>(changed:=true;e1)
371                  |(0,eps,[])=>(print "non";body)                      |(0,eps,[])=>body
372                          |(0,eps,rest)=>(let                      |(0,eps,rest)=> let
373                              val p'=rewriteBody(E.Prod rest)                              val p'=rewriteBody(E.Prod rest)
374                              val p''= (case p' of E.Prod p=>p |e=>[e])                              val p''= (case p' of E.Prod p=>p |e=>[e])
375                              val(a,b)= mkProd (eps@p'')                          val(_,b)= mkProd (eps@p'')
376                              in E.Sum(c,b) end                              in E.Sum(c,b) end
377                              )                      |_=>body
378                          |_=>body)                      (*end case*))
379                     end                     end
380    
381                | E.Sum(c1,E.Prod(E.Epsilon eps1::E.Sum(c2,E.Prod(E.Epsilon eps2::s2))::ps))=>let                | E.Sum(c1,E.Prod(E.Epsilon eps1::E.Sum(c2,E.Prod(E.Epsilon eps2::s2))::ps))=>let
# Line 398  Line 387 
387                    end                    end
388    
389                | E.Sum(c, E.Prod(E.Delta d::es))=>let                | E.Sum(c, E.Prod(E.Delta d::es))=>let
390                        val x=print "in here"
391                      val (change,a)=reduceDelta(body)                      val (change,a)=reduceDelta(body)
392                      val (change',body')=(case a                      in (case (change,a)
393                          of E.Prod p=> mkProd p                          of (0, _)=> rewriteBody(E.Prod([E.Delta d]@es))
394                          |_=> (0,a))                          | (_, E.Prod p)=>let
395                     in (case change of []=>body'|_=>(changed:=true;body')) end                              val (_, p') = mkProd p
396                                in (changed:=true;p') end
397                            | _ => (changed:=true;a )
398                            (*end case*))
399                        end
400    
401                | E.Sum(c,E.Apply(E.Partial _,e))=>let                | E.Sum(c,E.Apply(E.Partial _,e))=>let
402                      val (change,exp)=mkSumApply2(body)                      val (change,exp)=mkSumApply(body)
403                      val exp'=(case exp                      val exp'=(case exp
404                          of  E.Const c => E.Const c                          of  E.Const c => E.Const c
405                          | E.Sum(c',E.Apply(d',e'))  => (let                          | E.Sum(c',E.Apply(d',e'))  => (let
406                              val s'=rewriteBody(E.Sum(c',e'))                              val s'=rewriteBody(E.Sum(c',e'))
407                             in (case s'                             in (case s'
408                                  of E.Sum([],e'')=> rewriteBody (E.Apply(d',e''))                                  of E.Sum([],e'')=> rewriteBody (E.Apply(d',e''))
409                                  | E.Sum(s'',e'') => E.Sum(s'',rewriteBody(E.Apply(d',e'')))                                  | E.Sum(c'',e'') => E.Sum(c'',rewriteBody(E.Apply(d',e'')))
410                                  | _ => E.Apply(d',s'))                                  | _ => E.Apply(d',s')
411                                    (*end case*))
412                              end)                              end)
   
   
413                          | _ =>exp                          | _ =>exp
414                          (* end case *))                          (* end case *))
   
415                  in (case change of 1=>(changed:=true;exp') |_=>exp')                  in (case change of 1=>(changed:=true;exp') |_=>exp')
416                  end                  end
417    

Legend:
Removed from v.2485  
changed lines
  Added in v.2494

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