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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/high-to-mid/split.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/high-to-mid/split.sml

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

revision 2838, Tue Nov 25 03:40:24 2014 UTC revision 3017, Mon Mar 9 15:52:22 2015 UTC
# Line 4  Line 4 
4   * All rights reserved.   * All rights reserved.
5   *)   *)
6    
7     (*
8      During the transition from high-IL to mid-IL, complicated EIN expressions are split into simpler ones in order to better identify methods for code generation and common subexpressions. Combining EIN operators in the optimization phase can lead to large and complicated EIN operators. A general code generator would need to expand every operation to work on scalars, which could miss the opportunity for vectorization and lead to poor code generation. Instead, every EIN operator is split into a set of simple EIN operators.  Each EIN expression then only has one operation working on  constants, tensors, deltas, epsilons, images and kernels.
9    
10     (1) When the outer EIN operator is $ \in {--, +, -, *, /, \sum}$ then for each subexpression analyze to see if they need to be rewritten.
11    
12     (1a.) When a subexpression is a field expression $\circledast,\nabla $ then it becomes 0. When it is another operation $ {@ --, +, -, *, /, \sum}$ then we lift that subexpression and create a new EIN operator. We replace the subexpression with a tensor expression that represent it's size.
13    
14     (1b) Call cleanIndex.sml to clean the indices in the subexpression, and get the shape for the tensor replacement.
15    
16     (1c) Call cleanParams.sml to clean the params in the subexpression.\\
17     *)
18    
19  structure Split = struct  structure Split = struct
20    
21      local      local
22    
23      structure E = Ein      structure E = Ein
     structure mk= mkOperators  
     structure SrcIL = HighIL  
     structure SrcTy = HighILTypes  
     structure SrcOp = HighOps  
     structure SrcSV = SrcIL.StateVar  
     structure VTbl = SrcIL.Var.Tbl  
24      structure DstIL = MidIL      structure DstIL = MidIL
25      structure DstTy = MidILTypes      structure DstTy = MidILTypes
     structure DstOp = MidOps  
26      structure DstV = DstIL.Var      structure DstV = DstIL.Var
     structure SrcV = SrcIL.Var  
27      structure P=Printer      structure P=Printer
     structure F=Filter  
     structure T=TransformEin  
     structure Var = MidIL.Var  
28      structure cleanP=cleanParams      structure cleanP=cleanParams
29      structure cleanI=cleanIndex      structure cleanI=cleanIndex
30        structure handleE=handleEin
31    
     val testing=1  
32      in      in
33    
34        val testing=0
35      fun setEin(params,index,body)=Ein.EIN{params=params, index=index, body=body}      fun setEin(params,index,body)=Ein.EIN{params=params, index=index, body=body}
36      fun assignEinApp(y,params,index,body,args)= (y,DstIL.EINAPP(setEin(params,index,body),args))      fun assignEinApp(y,params,index,body,args)= (y,DstIL.EINAPP(setEin(params,index,body),args))
37      fun setEinZero(y,params,index,args)=  (y,DstIL.EINAPP(setEin(params,index,E.Const 0),args))      val einappzero=DstIL.EINAPP(setEin([],[],E.Const 0),[])
38        fun setEinZero y=  (y,einappzero)
39      fun cleanParams e =cleanP.cleanParams e      fun cleanParams e =cleanP.cleanParams e
40      fun cleanIndex e =cleanI.cleanIndex e      fun cleanIndex e =cleanI.cleanIndex e
41        fun printEINAPP e=MidToString.printEINAPP e
42        fun isZero e=handleE.isZero e
43        fun sweep e=handleE.sweep e
44      fun itos i =Int.toString i      fun itos i =Int.toString i
45        fun filterSca e=Filter.filterSca e
46      fun err str=raise Fail str      fun err str=raise Fail str
47      val cnt = ref 0      val cnt = ref 0
48      fun genName prefix = let      fun genName prefix = let
# Line 53  Line 56 
56          | _ =>(print(String.concat n);1)          | _ =>(print(String.concat n);1)
57          (*end case*))          (*end case*))
58    
     fun printEINAPP(id, DstIL.EINAPP(rator, args))=let  
         val a=String.concatWith " , " (List.map Var.toString args)  
         in  
             String.concat([(DstTy.toString (Var.ty id)),"<",Var.toString id,"> ==",P.printerE rator, a,"\n"])  
         end  
       | printEINAPP(id, DstIL.OP(rator, args))=let  
           val a=String.concatWith " , " (List.map Var.toString args)  
          in  
             String.concat([(DstTy.toString (Var.ty id)),"<",Var.toString id,"> =",DstOp.toString rator,a,"\n"])  
           end  
   
        | printEINAPP(id,_)= String.concat([Var.toString id,"<",(DstTy.toString (Var.ty id)),"> non-einapp\n"])  
   
   
     (* mkreplacement:params*index*index_list*int list* ein_exp-> ein_exp* params*args*code*  
     *creates new param and replacement tensor for the original ein_exp  
     *Then cleans params for suebxpression  
     *)  
     fun mkreplacement(params,args,tshape,sizes,body)=let  
         val id=length(params)  
         val params'=params@[E.TEN(1,sizes)]  
         val e'=E.Tensor(id,tshape)  
         val M  = DstV.new (genName ("TLifted_"^itos id), DstTy.TensorTy sizes)  
         val args'=args@[M]  
         val einapp=cleanParams(M,body,params',sizes,args')  
     in  
             (e',params',args',[einapp])  
     end  
59    
60      (* lift:ein_app*params*index*sum_id*args-> (ein_exp* params*args*code)      (* lift:ein_app*params*index*sum_id*args-> (ein_exp* params*args*code)
61      *lifts expression and returns replacement tensor      *lifts expression and returns replacement tensor
62      * cleans the index and params of subexpression      * cleans the index and params of subexpression
63        *creates new param and replacement tensor for the original ein_exp
64      *)      *)
65      fun lift(e,params,index,sx,args)=let      fun lift(name,e,params,index,sx,args)=let
66    
67          val (tshape,sizes,body)=cleanIndex(e,index,sx)          val (tshape,sizes,body)=cleanIndex(e,index,sx)
68          val (Re,Rparams,Rargs,code)=mkreplacement(params,args,tshape,sizes,body)          val id=length(params)
69      in          val Rparams=params@[E.TEN(1,sizes)]
70          (Re,Rparams,Rargs,code)          val Re=E.Tensor(id,tshape)
71      end          val M  = DstV.new (genName (name^"_l_"^itos id), DstTy.TensorTy sizes)
72            val Rargs=args@[M]
73            val einapp=cleanParams(M,body,Rparams,sizes,Rargs)
74    
     (* simplelift:ein_app*params*index*sum_id*args-> (ein_exp* params*args*code)  
     *lifts expression and returns replacement tensor  
     * cleans params of subexpression  
     *)  
     fun simplelift(e,params,index,args)=(*let  
         val tshape=List.map (fn x => E.V x) index  
         val(Re,Rparams,Rargs,code)=mkreplacement(params,args,tshape,index,e)  
75          in          in
76          (Re,Rparams,Rargs,code)          (Re,Rparams,Rargs,[einapp])
77          end          end
         *)lift(e,params,index,[],args)  
   
   
78    
79      (* isOp: ein->int      (* isOp: ein->int
80       * checks to see if this sub-expression is pulled out or split form original       * checks to see if this sub-expression is pulled out or split form original
# Line 117  Line 86 
86          | E.Apply _   => 0          | E.Apply _   => 0
87          | E.Lift _    => 0          | E.Lift _    => 0
88          | E.Neg _     => 1          | E.Neg _     => 1
89            | E.Sqrt _    => 1
90            | E.PowInt _    => 1
91            | E.PowReal _    => 1
92          | E.Add _     => 1          | E.Add _     => 1
93          | E.Sub _     => 1          | E.Sub _     => 1
94          | E.Prod _    => 1          | E.Prod _    => 1
# Line 130  Line 102 
102          | _           => 2          | _           => 2
103      (*end case*))      (*end case*))
104    
105        (* rewriteOp:ein_exp*params*index*args-> ein_exp*params*args*code
106      (* simpleOp:ein_exp*params*index*args-> ein_exp*params*args*code       * If e1 an op then call lift() to replace it
      * If e1 an op then call simplelift() to replace it  
107       * Otherwise rewrite to 0 or it remains the same       * Otherwise rewrite to 0 or it remains the same
108       *)       *)
109      fun simpleOp(e1,params,index,args)=(case (isOp e1)      fun rewriteOp(name,e1,params,index,sx,args)=(case (isOp e1)
110          of  0   => (E.Const 0,params,args,[])          of  0   => (E.Const 0,params,args,[])
111          | 2     => (e1,params,args,[])          | 2     => (e1,params,args,[])
112          | _     => simplelift(e1,params,index,args)          | _     =>   lift(name,e1,params,index,sx,args)
113          (*end*))          (*end*))
114    
115        (* rewriteOps:ein_exp list*params*index*sum_id list*mid-il vars
116      (* simpleOps:ein_exp list*params*index*args-> ein_exp list*params*args*code             -> ein_exp list*params*args*code
117       * calls simpleOp on ein_exp list       * calls rewriteOp on ein_exp list
118       *)       *)
119      fun simpleOps(list1,params,index,args)=let      fun rewriteOps(name,list1,params,index,sx,args)=let
120          fun m([],rest,params,args,code)=(rest,params,args,code)          fun m([],rest,params,args,code)=(rest,params,args,code)
121          | m(e1::es,rest,params,args,code)=let          | m(e1::es,rest,params,args,code)=let
122              val (e1',params',args',code')= simpleOp(e1,params,index,args)  
123                val (e1',params',args',code')= rewriteOp(name,e1,params,index,sx,args)
124              in              in
125                  m(es,rest@[e1'],params',args',code@code')                  m(es,rest@[e1'],params',args',code@code')
126              end              end
# Line 156  Line 128 
128              m(list1,[],params,args,[])              m(list1,[],params,args,[])
129          end          end
130    
131      (* prodOps:ein_exp list*params*index*sum_id list*args-> ein_exp list*params*args*code      (*rewriteOrig: var* ein_exp* params*index list*mid-il vars
132       * calls lift  on ein_exp list             When the operation is zero then we return a real.
133            -Moved is Zero to before split.
134       *)       *)
135      fun prodOps(list1,params,index,sx,args)=let      fun rewriteOrig(y,body,params,index,sx,args) =(case (isZero body)
136          fun m([],rest,params,args,code)=(rest,params,args,code)          of 1=>  setEinZero y
137          | m(e1::es,rest,params,args,code)=(case (isOp e1)          | _ => cleanParams(y,body,params,index,args)
138              of  0   => m(es,rest@[E.Const 0],params,args,code)          (*end case*))
139              | 2     => m(es,rest@[e1],params,args,code)  
140              | 1     => let      (* handleNeg:var*ein_exp *params*index*args-> (var*einap)*code
141                  val (e1',params',args',code')= lift(e1,params,index,sx,args)      * calls rewriteOp() lift  on ein_exp
142        *)
143        fun handleNeg(y,e1,params,index,args)=let
144            val (e1',params',args',code)=  rewriteOp("neg", e1,params,index,[],args)
145            val body =E.Neg e1'
146            val einapp= rewriteOrig(y,body,params',index,[],args')
147                  in                  in
148                      m(es,rest@[e1'],params',args',code@code')              (einapp,code)
149                  end                  end
150              (*end case*))  
151        (* handleSqrt:var*ein_exp *params*index*args-> (var*einap)*code
152        * calls rewriteOp() lift  on ein_exp
153        *)
154        fun handleSqrt(y,e1,params,index,args)=let
155            val (e1',params',args',code)=  rewriteOp("sqrt", e1,params,index,[],args)
156            val body =E.Sqrt e1'
157            val einapp= rewriteOrig(y,body,params',index,[],args')
158          in          in
159              m(list1,[],params,args,[])          (einapp,code)
160          end          end
161    
162    
163      fun isZero(y,body,params,index,args) =(case (cleanI.isZero body)  (* handlePowInt:var*ein_exp *params*index*args-> (var*einap)*code
164          of 1=>  setEinZero(y,params,[],args)  * calls rewriteOp() lift  on ein_exp
165          | _ =>  cleanParams(y,body,params,index,args)  *)
166      (*end case*))  fun handlePowInt(y,(e1,n1),params,index,args)=let
167    val (e1',params',args',code)=  rewriteOp("powint", e1,params,index,[],args)
168    val body =E.PowInt(e1',n1)
169    val einapp= rewriteOrig(y,body,params',index,[],args')
170    in
171    (einapp,code)
172    end
173    
174      (* handleNeg:var*ein_exp *params*index*args-> (var*einap)*code  
175      * calls simpleOp() lift  on ein_exp      (* handlePowReal:var*ein_exp *params*index*args-> (var*einap)*code
176        * calls rewriteOp() lift  on ein_exp
177      *)      *)
178      fun handleNeg(y,e1,params,index,args)=let      fun handlePowReal(y,(e1,n1),params,index,args)=let
179          val (e1',params',args',code)=  simpleOp(e1,params,index,args)      val (e1',params',args',code)=  rewriteOp("powreal", e1,params,index,[],args)
180          val body =E.Neg e1'      val body =E.PowReal(e1',n1)
181          val einapp= isZero(y,body,params',index,args')      val einapp= rewriteOrig(y,body,params',index,[],args')
182      in      in
183          (einapp,code)          (einapp,code)
184      end      end
185    
186    
187     (* handleSub:var*ein_exp*ein_exp *params*index*args-> (var*einap)*code     (* handleSub:var*ein_exp*ein_exp *params*index*args-> (var*einap)*code
188      * calls simpleOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
189      *)      *)
190      fun handleSub(y,e1,e2,params,index,args)=let      fun handleSub(y,e1,e2,params,index,args)=let
191          val ([e1',e2'],params',args',code)=  simpleOps([e1,e2],params,index,args)          val ([e1',e2'],params',args',code)=  rewriteOps("subt",[e1,e2],params,index,[],args)
192          val body =E.Sub(e1',e2')          val body =E.Sub(e1',e2')
193          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
194      in      in
195          (einapp,code)          (einapp,code)
196      end      end
197    
198      (* handleDiv:var*ein_exp *ein_exp*params*index*args-> (var*einap)*code      (* handleDiv:var*ein_exp *ein_exp*params*index*args-> (var*einap)*code
199      * calls simpleOp() lift  on ein_exp      * calls rewriteOp() lift  on ein_exp
200      *)      *)
201      fun handleDiv(y,e1,e2,params,index,args)=let      fun handleDiv(y,e1,e2,params,index,args)=let
202          val (e1',params1',args1',code1')=simpleOp(e1,params,index,args)          val (e1',params1',args1',code1')=rewriteOp("div-num",e1,params,index,[],args)
203          val (e2',params2',args2',code2')=simpleOp(e2,params1',[],args1')          val (e2',params2',args2',code2')=rewriteOp("div-denom",e2,params1',index,[],args1')
204            (*val (e2',params2',args2',code2')=rewriteOp("div-denom",e2,params1',[],[],args1')*)
205          val body =E.Div(e1',e2')          val body =E.Div(e1',e2')
206          val einapp= isZero(y,body,params2',index,args2')          val einapp= rewriteOrig(y,body,params2',index,[],args2')
207      in      in
208              (einapp,code1'@code2')              (einapp,code1'@code2')
209      end      end
210    
   
211      (* handleAdd:var*ein_exp list *params*index*args-> (var*einap)*code      (* handleAdd:var*ein_exp list *params*index*args-> (var*einap)*code
212      * calls simpleOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
213      *)      *)
214      fun handleAdd(y,e1,params,index,args)=let      fun handleAdd(y,e1,params,index,args)=let
215          val (e1',params',args',code)=  simpleOps(e1,params,index,args)          val (e1',params',args',code)=  rewriteOps("add",e1,params,index,[],args)
216          val body =E.Add e1'          val body =E.Add e1'
217          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
218      in      in
219          (einapp,code)          (einapp,code)
220      end      end
221    
222      (* handleProd:var*ein_exp list*params*index*args-> (var*einap)*code      (* handleProd:var*ein_exp list*params*index*args-> (var*einap)*code
223       * calls prodOps() lift  on ein_exp       * calls rewriteOps() lift  on ein_exp
224       *)       *)
225      fun handleProd(y,e1,params,index,args)=let      fun handleProd(y,e1,params,index,args)=let
226          val (e1',params',args',code)=  prodOps(e1,params,index,[],args)          val (e1',params',args',code)=  rewriteOps("prod",e1,params,index,[],args)
227          val body =E.Prod e1'          val body =E.Prod e1'
228          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
229      in      in
230          (einapp,code)          (einapp,code)
231      end      end
232    
233     (* handleSumProd:var*ein_exp *params*index*args-> (var*einap)*code     (* handleSumProd:var*ein_exp *params*index*args-> (var*einap)*code
234      * calls prodOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
235      *)      *)
236      fun handleSumProd(y,e1,params,index,sx,args)=let      fun handleSumProd(y,e1,params,index,sx,args)=let
237          val _ =List.map (fn (_,_,ub)=> Int.toString ub) sx          val (e1',params',args',code)=  rewriteOps("sumprod",e1,params,index,sx,args)
         val (e1',params',args',code)=  prodOps(e1,params,index,sx,args)  
238          val body= E.Sum(sx,E.Prod e1')          val body= E.Sum(sx,E.Prod e1')
239          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,sx,args')
240      in      in
241          (einapp,code)          (einapp,code)
242      end      end
243    
244      (* split:var*ein_app-> (var*einap)*code      (* split:var*ein_app-> (var*einap)*code
245      * split ein expression into smaller pieces      * split ein expression into smaller pieces
246          note we leave summation around probe exp
247      *)      *)
248      fun split(y,einapp as DstIL.EINAPP(Ein.EIN{params, index, body},args))=let      fun split(y,einapp as DstIL.EINAPP(Ein.EIN{params, index, body},args))=let
249          val zero=   (setEinZero(y,params,[],args),[])          val zero=   (setEinZero y,[])
250          val default=((y,einapp),[])          val default=((y,einapp),[])
251          val sumIndex=ref []          val sumIndex=ref []
252            val str="Poorly formed EIN operator. Argument needs to be applied in High-IL"^(P.printbody body)
253            val _=testp["\n\nStarting split",P.printbody body]
254          fun rewrite b=(case b          fun rewrite b=(case b
255              of E.Probe _              => default              of E.Probe (E.Conv _,_)   => default
256                | E.Probe(E.Field _,_)    => raise Fail str
257                | E.Probe _               => raise Fail str
258              | E.Conv _                => zero              | E.Conv _                => zero
259              | E.Field _               => zero              | E.Field _               => zero
260              | E.Apply _               => zero              | E.Apply _               => zero
261              | E.Lift e                => zero              | E.Lift e                => zero
262              | E.Delta _               => default              | E.Delta _               => default
263              | E.Epsilon _             => default              | E.Epsilon _             => default
264                | E.Eps2 _                => default
265              | E.Tensor _              => default              | E.Tensor _              => default
266              | E.Const _               => default              | E.Const _               => default
267                | E.ConstR _              => default
268              | E.Neg e1                => handleNeg(y,e1,params,index,args)              | E.Neg e1                => handleNeg(y,e1,params,index,args)
269                | E.Sqrt e1               => handleSqrt(y,e1,params,index,args)
270                | E.PowInt e1             => handlePowInt(y,e1,params,index,args)
271                | E.PowReal e1            => handlePowReal(y,e1,params,index,args)
272              | E.Sub (e1,e2)           => handleSub(y,e1,e2,params,index,args)              | E.Sub (e1,e2)           => handleSub(y,e1,e2,params,index,args)
273              | E.Div (e1,e2)           => handleDiv(y,e1,e2,params,index,args)              | E.Div (e1,e2)           => handleDiv(y,e1,e2,params,index,args)
274              | E.Sum(_,E.Probe _)      => default              | E.Sum(sx,E.Tensor(id,[]))=> rewrite (E.Tensor(id,[]))
275              | E.Sum(_,E.Conv _)       => zero              | E.Sum(sx,E.Const c)      =>rewrite ( E.Const c )
276              | E.Sum(sx,E.Prod e1)     => handleSumProd(y,e1,params,index,sx,args)              | E.Sum(sx,E.ConstR r)    => rewrite (E.ConstR r)
277              | E.Sum(sx,E.Neg n)       => rewrite (E.Neg(E.Sum(sx,n)))              | E.Sum(sx,E.Neg n)       => rewrite (E.Neg(E.Sum(sx,n)))
278              | E.Sum(sx,E.Add a)       => rewrite (E.Add(List.map (fn e=> E.Sum(sx,e)) a))              | E.Sum(sx,E.Add a)       => rewrite (E.Add(List.map (fn e=> E.Sum(sx,e)) a))
279              | E.Sum(sx,E.Sub (e1,e2)) => rewrite (E.Sub(E.Sum(sx,e1),E.Sum(sx,e2)))              | E.Sum(sx,E.Sub (e1,e2)) => rewrite (E.Sub(E.Sum(sx,e1),E.Sum(sx,e2)))
280              | E.Sum(sx,E.Div(e1,e2))  => rewrite(E.Div(E.Sum(sx,e1),E.Sum(sx,e2)))              | E.Sum(sx,E.Div(e1,e2))  => rewrite (E.Sum(sx,E.Prod[e1,E.Div(E.Const 1,e2)]))
281                | E.Sum(sx,E.Lift e )     => rewrite (E.Lift(E.Sum(sx,e)))
282                | E.Sum(sx,E.PowReal(e,n1)) => rewrite (E.PowReal(E.Sum(sx,e),n1))
283                | E.Sum(sx,E.Sqrt e)        => rewrite (E.Sqrt(E.Sum(sx,e)))
284              | E.Sum(c1, E.Sum (c2,e)) => rewrite (E.Sum (c1@c2,e))              | E.Sum(c1, E.Sum (c2,e)) => rewrite (E.Sum (c1@c2,e))
285                | E.Sum(_,E.Prod[E.Eps2 _, E.Probe(E.Conv _,_)  ])      => default
286                | E.Sum(_,E.Prod[E.Epsilon _, E.Probe(E.Conv _,_)  ])      => default
287                | E.Sum(_,E.Probe(E.Conv _,_))    => default
288                | E.Sum(_,E.Conv _)       => zero
289                | E.Sum(sx,E.Prod e1)     => handleSumProd(y,e1,params,index,sx,args)
290              | E.Sum(sx,_)             => default              | E.Sum(sx,_)             => default
291              | E.Add e1                => handleAdd(y,e1,params,index,args)              | E.Add e1                => handleAdd(y,e1,params,index,args)
292              | E.Prod e1               => handleProd(y,e1,params,index,args)              | E.Prod e1               => handleProd(y,e1,params,index,args)
# Line 285  Line 295 
295              | E.Value _               => err("Value used before expand")              | E.Value _               => err("Value used before expand")
296              | E.Img _                 => err("Probe used before expand")              | E.Img _                 => err("Probe used before expand")
297              (*end case *))              (*end case *))
   
298          val (einapp2,newbies) =rewrite body          val (einapp2,newbies) =rewrite body
299          in          in
300              (einapp2,newbies)              (einapp2,newbies)
# Line 293  Line 302 
302          |split(y,app) =((y,app),[])          |split(y,app) =((y,app),[])
303    
304    
305        (*Distribute summation if needed*)
306        fun distributeSummation(y,einapp as DstIL.EINAPP(Ein.EIN{params, index, body},args))=let
307            fun rewrite b=(case b
308            of E.Sum(sx,E.Tensor(id,[]))    => E.Tensor(id,[])
309            | E.Sum(sx,E.Const c)           => E.Const c
310            | E.Sum(sx,E.ConstR r)          => E.ConstR r
311            | E.Sum(sx,E.Neg n)             => rewrite(E.Neg(E.Sum(sx,n)))
312            | E.Sum(sx,E.Add a)             => rewrite(E.Add(List.map (fn e=> E.Sum(sx,e)) a))
313            | E.Sum(sx,E.Sub (e1,e2))       => rewrite(E.Sub(E.Sum(sx,e1),E.Sum(sx,e2)))
314           (* | E.Sum(sx,E.Div(e1,e2))        => rewrite( E.Div(E.Sum(sx,e1),E.Sum(sx,e2)))*)
315            | E.Sum(sx,E.Lift e )           => rewrite (E.Lift(E.Sum(sx,e)))
316            | E.Sum(sx,E.PowReal(e,n1))     => rewrite(E.PowReal(E.Sum(sx,e),n1))
317            | E.Sum(sx,E.Sqrt e)            => rewrite(E.Sqrt(E.Sum(sx,e)))
318            | E.Sum(sx,E.Sum (c2,e))        => rewrite (E.Sum (sx@c2,e))
319            | E.Sum(sx,E.Prod p)            => let
320                    val (c,e)=filterSca(sx,p)
321                    in e end
322            | E.Div(e1,e2)                  => E.Div(rewrite e1, rewrite e2)
323            | E.Sub(e1,e2)                  => E.Sub(rewrite e1, rewrite e2)
324            | E.Add es                      => E.Add(List.map rewrite es)
325            | E.Prod es                     => E.Prod(List.map rewrite es)
326            | E.Neg e                       => E.Neg(rewrite e)
327            | E.Sqrt e                      => E.Sqrt(rewrite e)
328            | _                             => b
329        (*end case*))
330        val body =rewrite body
331        val _ =testp["\nAfter distributeSummation \n",P.printbody body]
332        val ein=SummationEin.cleanSummation(Ein.EIN{params=params, index=index, body=body})
333        val einapp2= (y,DstIL.EINAPP(ein,args))
334        in
335            split(einapp2)
336        end
337        |distributeSummation(y,app) =((y,app),[])
338    
339    
340    
341      (* iterMultiple:code*code=> (code*code)      (* iterMultiple:code*code=> (code*code)
342       * recursively split ein expression into smaller pieces       * recursively split ein expression into smaller pieces
343      *)      *)
344      fun iterMultiple(einapp2,newbies2)=let      fun iterMultiple(einapp2,newbies2)=let
345          fun itercode([],rest,code)=(rest,code)          fun itercode([],rest,code,_)=(rest,code)
346          | itercode(e1::newbies,rest,code)=let          | itercode(e1::newbies,rest,code,cnt)=let
347              val (einapp3,code3) =split(e1)              val _ =testp["\n\n******* split term **",Int.toString cnt," *****","\n \n",printEINAPP(e1),"\n=>\n"]
348              val (rest4,code4)=itercode(code3,[],[])              val (einapp3,code3) = distributeSummation e1
349              in itercode(newbies,rest@[einapp3],code4@rest4@code)              val _ =testp["\n\t===>\n",printEINAPP(einapp3),"\nand\n",(String.concatWith",\n\t"(List.map printEINAPP code3))]
350                val (rest4,code4)=itercode(code3,[],[],cnt+1)
351                in itercode(newbies,rest@[einapp3],code4@rest4@code,cnt+2)
352              end              end
353          val(rest,code)= itercode(newbies2,[],[])          val(rest,code)= itercode(newbies2,[],[],1)
354          in          in
355              (einapp2,code@rest)              (einapp2,code@rest)
356          end          end
357    
358        fun iterSplit(y,einapp as DstIL.EINAPP(Ein.EIN{params, index, body},args))=let
359            val bodysweep=handleE.sweep body
360            val _=testp["\nPresweep\n",P.printbody body,"\n\n Sweep\n",P.printbody bodysweep,"\n"]
361            val ein=SummationEin.cleanSummation(Ein.EIN{params=params, index=index, body=bodysweep})
362            val _=testp["\n\n Clean Summation\n",P.printbody(Ein.body ein),"\n"]
363            val einapp2=(y,DstIL.EINAPP(ein, args))
364            val _ =testp["\n\n******* split term **",Int.toString (0)," ***** \n \t==>\n",printEINAPP(einapp2)]
365            val (einapp3,newbies2)=distributeSummation einapp2
366            val _ =testp["\n\t===>\n",printEINAPP(einapp3),"\nand\n",(String.concatWith",\n\t"(List.map printEINAPP newbies2))]
367    
     fun iterSplit(y,einapp)=let  
         val (einapp2,newbies2)=split(y,einapp)  
368      in      in
369          iterMultiple(einapp2,newbies2)          iterMultiple(einapp3,newbies2)
370      end      end
371    
   
   
372      (* gettest:code*code=> (code*code)      (* gettest:code*code=> (code*code)
373      * print results for splitting einapp      * print results for splitting einapp
374      *)      *)
375      fun gettest(einapp)=(case testing      fun gettest einapp=(case testing
376          of 0=>iterSplit(einapp)          of 0=>iterSplit(einapp)
377          | _=>let          | _=>let
378              val star="\n*************\n"              val star="\n************* SPLIT INITIAL********\n"
379              val _ =print(String.concat[star])              val _ =testp[star,"\n","start get test",printEINAPP einapp]
380              val (einapp2,newbies)=iterSplit(einapp)              val (einapp2,newbies)=iterSplit(einapp)
381              val a=printEINAPP einapp2              val _ =testp["\n\n Returning \n\n =>",printEINAPP einapp2,
382              val b=String.concatWith",\n\t"(List.map printEINAPP newbies)                      " newbies\n\t",String.concatWith",\n\t"(List.map printEINAPP newbies), "\n",star]
             val _ =print(String.concat[printEINAPP einapp,"=>",a," newbies\n\t",b, "\n",a,star])  
383              in              in
384                  (einapp2,newbies)                  (einapp2,newbies)
385              end              end
386          (*end case*))          (*end case*))
387    
   
388    end; (* local *)    end; (* local *)
389    
390  end (* local *)  end (* local *)

Legend:
Removed from v.2838  
changed lines
  Added in v.3017

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