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-to-mid/ProbeEin.sml
ViewVC logotype

Diff of /branches/charisee_dev/src/compiler/high-to-mid/ProbeEin.sml

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

revision 3325, Tue Oct 20 17:04:54 2015 UTC revision 3460, Mon Nov 23 20:27:35 2015 UTC
# Line 1  Line 1 
1  (* Expands probe ein  (* Expands probe ein
2   *   *
3   * COPYRIGHT (c) 2012 The Diderot Project (http://diderot-language.cs.uchicago.edu)   * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
4     *
5     * COPYRIGHT (c) 2015 The University of Chicago
6   * All rights reserved.   * All rights reserved.
7   *)   *)
8    
# Line 38  Line 40 
40      *)      *)
41    
42      val testing=0      val testing=0
43      val testlift=1  
44      val detflag =true  
45      val fieldliftflag=true  
46      val valnumflag=true      val valnumflag=true
47        val tsplitvar=true
48        val fieldliftflag=true
49        val constflag=true
50        val detflag =true
51        val detsumflag=true
52    
53    
54      val cnt = ref 0      val cnt = ref 0
# Line 50  Line 57 
57      fun toStringBind e=(MidToString.toStringBind e)      fun toStringBind e=(MidToString.toStringBind e)
58      fun mkEin e=Ein.mkEin e      fun mkEin e=Ein.mkEin e
59      fun mkEinApp(rator,args)=DstIL.EINAPP(rator,args)      fun mkEinApp(rator,args)=DstIL.EINAPP(rator,args)
60        fun setConst e = E.setConst e
61        fun setNeg e  =  E.setNeg e
62        fun setExp e  =  E.setExp e
63        fun setDiv e= E.setDiv e
64        fun setSub e= E.setSub e
65        fun setProd e= E.setProd e
66        fun setAdd e= E.setAdd e
67    
68      fun testp n=(case testing      fun testp n=(case testing
69          of 0=> 1          of 0=> 1
70          | _ =>(print(String.concat n);1)          | _ =>((String.concat n);1)
71          (*end case*))          (*end case*))
72    
73    
# Line 74  Line 88 
88              in              in
89                ((Kernel.support h) ,img,ImageInfo.dim img)                ((Kernel.support h) ,img,ImageInfo.dim img)
90              end              end
91          |  _ => raise Fail "Expected Image and kernel arguments"              |  ((k,_),(i,_)) => raise Fail (String.concat["Expected kernel:", (DstOp.toString k ),"Expected Image:", (DstOp.toString i)])
92          (*end case*))          (*end case*))
93    
94    
# Line 103  Line 117 
117          fun createKRND1 ()=let          fun createKRND1 ()=let
118              val sum=sx              val sum=sx
119              val dels=List.map (fn e=>(E.C 0,e)) deltas              val dels=List.map (fn e=>(E.C 0,e)) deltas
120              val pos=[E.Add[E.Tensor(fid,[]),E.Value(sum)]]              val pos=[setAdd[E.Tensor(fid,[]),E.Value(sum)]]
121              val rest= E.Krn(hid,dels,E.Sub(E.Tensor(nid,[]),E.Value(sum)))              val rest= E.Krn(hid,dels,setSub(E.Tensor(nid,[]),E.Value(sum)))
122              in              in
123                  E.Prod [E.Img(Vid,alpha,pos),rest]                 setProd[E.Img(Vid,alpha,pos),rest]
124              end              end
125          (*createKRN Image field and kernels *)          (*createKRN Image field and kernels *)
126          fun createKRN(0,imgpos,rest)=E.Prod ([E.Img(Vid,alpha,imgpos)] @rest)          fun createKRN(0,imgpos,rest)=setProd ([E.Img(Vid,alpha,imgpos)] @rest)
127          | createKRN(dim,imgpos,rest)=let          | createKRN(dim,imgpos,rest)=let
128              val dim'=dim-1              val dim'=dim-1
129              val sum=sx+dim'              val sum=sx+dim'
130              val dels=List.map (fn e=>(E.C dim',e)) deltas              val dels=List.map (fn e=>(E.C dim',e)) deltas
131              val pos=[E.Add[E.Tensor(fid,[E.C dim']),E.Value(sum)]]              val pos=[setAdd[E.Tensor(fid,[E.C dim']),E.Value(sum)]]
132              val rest'= E.Krn(hid,dels,E.Sub(E.Tensor(nid,[E.C dim']),E.Value(sum)))              val rest'= E.Krn(hid,dels,setSub(E.Tensor(nid,[E.C dim']),E.Value(sum)))
133              in              in
134                  createKRN(dim',pos@imgpos,[rest']@rest)                  createKRN(dim',pos@imgpos,[rest']@rest)
135              end              end
# Line 125  Line 139 
139              (*end case*))              (*end case*))
140          (*sumIndex creating summaiton Index for body*)          (*sumIndex creating summaiton Index for body*)
141          val slb=1-s          val slb=1-s
142            val _=List.tabulate(dim, (fn dim=> (String.concat[" sx:",Int.toString(sx)," dim:",Int.toString(dim),"esum",Int.toString(sx+dim) ]) ))
143          val esum=List.tabulate(dim, (fn dim=>(E.V (dim+sx),slb,s)))          val esum=List.tabulate(dim, (fn dim=>(E.V (dim+sx),slb,s)))
144      in      in
145          E.Sum(esum, exp)          E.Sum(esum, exp)
# Line 133  Line 148 
148      (*getsumshift:sum_indexid list* int list-> int      (*getsumshift:sum_indexid list* int list-> int
149      *get fresh/unused index_id, returns int      *get fresh/unused index_id, returns int
150      *)      *)
151      fun getsumshift(sx,index) =let      fun getsumshift(sx,n) =let
152          val nsumshift= (case sx          val nsumshift= (case sx
153              of []=> length(index)              of []=> n
154              | _=>let              | _=>let
155                  val (E.V v,_,_)=List.hd(List.rev sx)                  val (E.V v,_,_)=List.hd(List.rev sx)
156                  in v+1                  in v+1
157                  end                  end
158              (* end case *))              (* end case *))
159    
160          val aa=List.map (fn (E.V v,_,_)=>Int.toString v) sx          val aa=List.map (fn (E.V v,_,_)=>Int.toString v) sx
161          val _ =testp["\n", "SumIndex" ,(String.concatWith"," aa),          val _ =(String.concat["\n", "SumIndex:" ,(String.concatWith"," aa),
162              "\nThink nshift is ", Int.toString nsumshift]          "\n\t Index length:",Int.toString n,
163            "\n\t Freshindex: ", Int.toString nsumshift])
164          in          in
165              nsumshift              nsumshift
166          end          end
# Line 153  Line 170 
170      *)      *)
171      fun formBody(E.Sum([],e))=formBody e      fun formBody(E.Sum([],e))=formBody e
172      | formBody(E.Sum(sx,e))= E.Sum(sx,formBody e)      | formBody(E.Sum(sx,e))= E.Sum(sx,formBody e)
173      | formBody(E.Prod [e])=e      | formBody(E.Opn(E.Prod, [e]))=e
174      | formBody e=e      | formBody e=e
175    
176      (* silly change in order of the product to match vis branch WorldtoSpace functions*)      (* silly change in order of the product to match vis branch WorldtoSpace functions*)
177      fun multiPs([P0,P1,P2],sx,body)= formBody(E.Sum(sx, E.Prod([P0,P1,P2,body])))      fun multiPs([P0,P1,P2],sx,body)= formBody(E.Sum(sx, setProd[P0,P1,P2,body]))
178        | multiPs([P0,P1],sx,body)=formBody(E.Sum(sx, E.Prod([P0,body,P1])))      (*
179        | multiPs(Ps,sx,body)=formBody(E.Sum(sx, E.Prod([body]@Ps)))        | multiPs([P0,P1],sx,body)=formBody(E.Sum(sx, setProd([P0,body,P1])))
180          *)
181          | multiPs([P0,P1,P2,P3],sx,body)= formBody(E.Sum(sx, setProd[P0,P1,P2,P3,body]))
182          | multiPs(Ps,sx,body)=formBody(E.Sum(sx,setProd([body]@Ps)))
183    
184    
185      fun multiMergePs([P0,P1],[sx0,sx1],body)=E.Sum([sx0],E.Prod[P0,E.Sum([sx1],E.Prod[P1,body])])      fun multiMergePs([P0,P1],[sx0,sx1],body)=E.Sum([sx0],setProd[P0,E.Sum([sx1],setProd[P1,body])])
186        | multiMergePs e=multiPs e        | multiMergePs e=multiPs e
187    
188    
# Line 189  Line 209 
209          val Pid=nid+1          val Pid=nid+1
210          val nshift=length(dx)          val nshift=length(dx)
211          val (dim,argsA,code,s,PArg) = handleArgs(Vid,hid,tid,args)          val (dim,argsA,code,s,PArg) = handleArgs(Vid,hid,tid,args)
212          val freshIndex=getsumshift(sx,index)          val freshIndex=getsumshift(sx,length(index))
213          val (dx,newsx1,Ps)=transformToIndexSpace(freshIndex,dim,dx,Pid)          val (dx,newsx1,Ps)=transformToIndexSpace(freshIndex,dim,dx,Pid)
214          val params'=params@[E.TEN(3,[dim]),E.TEN(1,[dim]),E.TEN(1,[dim,dim])]          val params'=params@[E.TEN(3,[dim]),E.TEN(1,[dim]),E.TEN(1,[dim,dim])]
215          val body' = createBody(dim, s,freshIndex+nshift,alpha,dx,Vid, hid, nid, fid)          val body' = createBody(dim, s,freshIndex+nshift,alpha,dx,Vid, hid, nid, fid)
# Line 197  Line 217 
217    
218          val body'=(case originalb          val body'=(case originalb
219              of E.Sum(sx, E.Probe _)              => E.Sum(sx,body')              of E.Sum(sx, E.Probe _)              => E.Sum(sx,body')
220              | E.Sum(sx,E.Prod[eps0,E.Probe _ ])  => E.Sum(sx,E.Prod[eps0,body'])              | E.Sum(sx,E.Opn(E.Prod,[eps0,E.Probe _ ]))  => E.Sum(sx,setProd[eps0,body'])
221              | _                                  => body'              | _                                  => body'
222              (*end case*))              (*end case*))
223    
# Line 208  Line 228 
228              code@[einapp]              code@[einapp]
229          end          end
230    
231      val tsplitvar=true  
232      fun createEinApp(originalb,alpha,index,freshIndex,dim,dx,sx)= let      fun createEinApp(originalb,alpha,index,freshIndex,dim,dx,sx)= let
233          val Pid=0          val Pid=0
234          val tid=1          val tid=1
# Line 229  Line 249 
249    
250          val tshape=filterAlpha(alpha')@newdx          val tshape=filterAlpha(alpha')@newdx
251          val t=E.Tensor(tid,tshape)          val t=E.Tensor(tid,tshape)
252    
253          val (splitvar,body)=(case originalb          val (splitvar,body)=(case originalb
254              of E.Sum(sx, E.Probe _)              => (false,E.Sum(sx,multiPs(Ps,newsx,t)))              of E.Sum(sx, E.Probe _)              => (true,multiPs(Ps,sx@newsx,t))
255              | E.Sum(sx,E.Prod[eps0,E.Probe _ ])  => (false,E.Sum(sx,E.Prod[eps0,multiPs(Ps,newsx,t)]))              | E.Sum(sx,E.Opn(E.Prod,[eps0,E.Probe _ ]))  => (false,E.Sum(sx,setProd[eps0,multiPs(Ps,newsx,t)]))
256              | _                                  => (case tsplitvar              | _                                  => (case tsplitvar
257                  of(* true =>   (true,multiMergePs(Ps,newsx,t))  (*pushes summations in place*)                  of(* true =>   (true,multiMergePs(Ps,newsx,t))  (*pushes summations in place*)
258                  | false*) _ =>   (true,multiPs(Ps,newsx,t))                  | false*) _ =>   (true,multiPs(Ps,newsx,t))
# Line 250  Line 271 
271          end          end
272    
273      fun liftProbe(printStrings,(y, DstIL.EINAPP(e,args)),p ,sx)=let      fun liftProbe(printStrings,(y, DstIL.EINAPP(e,args)),p ,sx)=let
274          val _=testp["\n******* Lift ******** \n"]          val _=testp["\n******* Lift Geneirc Probe ***\n"]
275          val originalb=Ein.body e          val originalb=Ein.body e
276          val params=Ein.params e          val params=Ein.params e
277          val index=Ein.index e          val index=Ein.index e
278          val _=  toStringBind (y, DstIL.EINAPP(e,args))          val _ =  (toStringBind (y, DstIL.EINAPP(e,args)))
279    
280          val E.Probe(E.Conv(Vid,alpha,hid,dx),E.Tensor(tid,_))=p          val E.Probe(E.Conv(Vid,alpha,hid,dx),E.Tensor(tid,_))=p
281          val fid=length(params)          val fid=length(params)
282          val nid=fid+1          val nid=fid+1
283          val nshift=length(dx)          val nshift=length(dx)
284          val (dim,args',code,s,PArg) = handleArgs(Vid,hid,tid,args)          val (dim,args',code,s,PArg) = handleArgs(Vid,hid,tid,args)
285          val freshIndex=getsumshift(sx,index)          val freshIndex=getsumshift(sx,length(index))
286    
287          (*transform T*P*P..Ps*)          (*transform T*P*P..Ps*)
288          val (splitvar,ein0,sizes,dx,alpha')= createEinApp(originalb,alpha,index,freshIndex,dim,dx,sx)          val (splitvar,ein0,sizes,dx,alpha')= createEinApp(originalb,alpha,index,freshIndex,dim,dx,sx)
289    
290          val FArg  = DstV.new ("F", DstTy.TensorTy(sizes))          val FArg  = DstV.new ("F", DstTy.TensorTy(sizes))
291          val einApp0=mkEinApp(ein0,[PArg,FArg])          val einApp0=mkEinApp(ein0,[PArg,FArg])
292          val rtn0=(case splitvar          val rtn0=(case splitvar
# Line 277  Line 299 
299    
300          (*lifted probe*)          (*lifted probe*)
301          val params'=params@[E.TEN(3,[dim]),E.TEN(1,[dim])]          val params'=params@[E.TEN(3,[dim]),E.TEN(1,[dim])]
302          val body' = createBody(dim, s,freshIndex+nshift,alpha',dx,Vid, hid, nid, fid)          val freshIndex'= length(sizes)
303    
304            val body' = createBody(dim, s,freshIndex',alpha',dx,Vid, hid, nid, fid)
305          val ein1=mkEin(params',sizes,body')          val ein1=mkEin(params',sizes,body')
306          val einApp1=mkEinApp(ein1,args')          val einApp1=mkEinApp(ein1,args')
307          val rtn1=(FArg,einApp1)          val rtn1=(FArg,einApp1)
308          val rtn=code@[rtn1]@rtn0          val rtn=code@[rtn1]@rtn0
309          val _= List.map toStringBind ([rtn1]@rtn0)          val _= List.map toStringBind ([rtn1]@rtn0)
310             val _=(String.concat["\n* end  Lift Geneirc Probe  ******** \n"])
311          in          in
312              rtn              rtn
313          end          end
314    
315        fun searchFullField (fieldset,code1,body1,dx)=let
316            val (lhs,_)=code1
317            fun continueReconstruction ()=let
318                val _=print"Tash:don't replaced"
319                in (case dx
320                    of []=> (lhs,replaceProbe(1,code1,body1,[]))
321                    | _ =>(lhs,liftProbe(1,code1,body1,[]))
322                    (*end case*))
323                 end
324            in  (case valnumflag
325                of false    => (fieldset,continueReconstruction())
326                | true      => (case  (einSet.rtnVarN(fieldset,code1))
327                    of (fieldset,NONE)     => (fieldset,continueReconstruction())
328                     | (fieldset,SOME m)   =>(print"TASH:replaced"; (fieldset,(m,[])))
329                    (*end case*))
330                (*end case*))
331            end
332    
333      fun liftFieldMat(newvx,e)=      fun liftFieldMat(newvx,e)=
334          let          let
335                val _=testp[ "\n ***************************** start FieldMat\n"]
336              val (y, DstIL.EINAPP(ein,args))=e              val (y, DstIL.EINAPP(ein,args))=e
337              val E.Probe(E.Conv(V,[c1,v0],h,dx),pos)=Ein.body ein              val E.Probe(E.Conv(V,[c1,v0],h,dx),pos)=Ein.body ein
338              val index0=Ein.index ein              val index0=Ein.index ein
# Line 316  Line 358 
358              val einApp0 = mkEinApp(ein0,[lhs1])              val einApp0 = mkEinApp(ein0,[lhs1])
359              val code0 = (y,einApp0)              val code0 = (y,einApp0)
360              val _= toStringBind code0              val _= toStringBind code0
361                val _=testp["\n end FieldMat *****************************\n "]
362          in          in
363              codeAll@[code0]              codeAll@[code0]
364      end      end
365    
366        fun liftFieldVec(newvx,e,fieldset)=
367        let
368            val _=testp[ "\n ***************************** start FieldVec\n"]
369            val (y, DstIL.EINAPP(ein,args))=e
370            val E.Probe(E.Conv(V,[c1],h,dx),pos)=Ein.body ein
371            val index0=Ein.index ein
372            val index1 = index0@[3]
373            val body1_unshifted = E.Probe(E.Conv(V,[E.V newvx],h,dx),pos)
374            (* clean to get body indices in order *)
375            val ( _ , _, body1)= cleanIndex.cleanIndex(body1_unshifted,index1,[])
376    
377    
378            val lhs1=DstV.new ("L", DstTy.TensorTy(index1))
379            val ein1 = mkEin(Ein.params ein,index1,body1)
380            val code1= (lhs1,mkEinApp(ein1,args))
381            val (fieldset,(lhs0,codeAll))=searchFullField (fieldset,code1,body1,dx)
382    
383            (*Probe that tensor at a constant position  c1*)
384            val param0 = [E.TEN(1,index1)]
385            val nx=List.tabulate(length(dx),fn n=>E.V n)
386            val body0 =  E.Tensor(0,[c1]@nx)
387            val ein0 = mkEin(param0,index0,body0)
388            val einApp0 = mkEinApp(ein0,[lhs0])
389            val code0 = (y,einApp0)
390    
391            val _ = testp ["\n Shifted ",P.printbody body1_unshifted,"=>",P.printbody body1]
392            val _ = (toStringBind code0)
393            val _ = testp[ "\n end FieldVec *****************************\n "]
394            in
395                codeAll@[code0]
396        end
397    
398    
399    
400      fun liftFieldSum e =      fun liftFieldSum e =
401      let      let
402          val _=print"\n*************************************\n"          val _=testp[ "\n************************************* Start Lift Field Sum\n"]
403          val (y, DstIL.EINAPP(ein,args))=e          val (y, DstIL.EINAPP(ein,args))=e
404          val E.Sum([(vsum,0,n)],E.Probe(E.Conv(V,[c1,v0],h,dx),pos))=Ein.body ein          val E.Sum([(vsum,0,n)],E.Probe(E.Conv(V,[c1,v0],h,dx),pos))=Ein.body ein
405          val index0=Ein.index ein          val index0=Ein.index ein
# Line 349  Line 426 
426          val _= toStringBind  e          val _= toStringBind  e
427          val _ =toStringBind code0          val _ =toStringBind code0
428         val _ = (String.concat  ["\norig",P.printbody(Ein.body ein),"\n replace i  ",P.printbody body1,"\nfreshtensor",P.printbody body0])         val _ = (String.concat  ["\norig",P.printbody(Ein.body ein),"\n replace i  ",P.printbody body1,"\nfreshtensor",P.printbody body0])
429         val _ =(String.concat(List.map toStringBind (codeAll@[code0])))          val _  =((List.map toStringBind (codeAll@[code0])))
430                 val _=print"\n*************************************\n"          val _ = testp["\n*** end Field Sum*************************************\n"]
431          in          in
432          codeAll@[code0]          codeAll@[code0]
433      end      end
# Line 363  Line 440 
440      *)      *)
441     fun expandEinOp( e as (y, DstIL.EINAPP(ein,args)),fieldset)=let     fun expandEinOp( e as (y, DstIL.EINAPP(ein,args)),fieldset)=let
442    
443          fun checkConst ([],a) =      fun checkConst(es,a)=(case constflag
444            of true => liftProbe a
445            | _ => let
446                fun fConst ([],a) =
447              (case fieldliftflag              (case fieldliftflag
448                  of true => liftProbe a                  of true => liftProbe a
449                  | _ => replaceProbe a                  | _ => replaceProbe a
450              (*end case*))              (*end case*))
451          | checkConst ((E.C _::_),a) = replaceProbe a                  | fConst ((E.C _::_),a) = replaceProbe a
452          | checkConst ((_ ::es),a)= checkConst(es,a)                      (*raise Fail (String.concat["\nFound it:",P.printerE(ein)])*)
453                | fConst ((_ ::es),a)= checkConst(es,a)
454                in fConst(es,a) end
455          (* end case*))
456    
457    
458    
459        fun rewriteBodyB b=(case b
460            of  (E.Probe(E.Conv(_,_,_,[]),_))
461                => replaceProbe(0,e,b,[])
462            | (E.Probe(E.Conv (_,alpha,_,dx),_))
463                => checkConst(dx,(0,e,b,[])) (*scans dx for contant*)
464            | (E.Sum(sx,p as E.Probe(E.Conv(_,_,_,[]),_)))
465                => replaceProbe(0,e,p, sx)  (*no dx*)
466            | (E.Sum(sx,p as E.Probe(E.Conv(_,[],_,dx),_)))
467                => checkConst(dx,(0,e,p,sx)) (*scalar field*)
468            | (E.Sum(sx,E.Probe p))
469                => replaceProbe(0,e,E.Probe p, sx)
470            | (E.Sum(sx,E.Opn(E.Prod,[eps,E.Probe p])))
471                => replaceProbe(0,e,E.Probe p,sx)
472            | _ => [e]
473            (* end case *))
474    
475          fun rewriteBody b=(case (detflag,b)  
476              of (true,E.Probe(E.Conv(_,[E.C _ ,E.V 0],_,[]),pos))          fun rewriteBody b=(case detflag
477                of true => (case (detsumflag,b)
478                    of (_,E.Probe(E.Conv(_,[E.C _ ,E.V 0],_,[]),pos))
479                  => liftFieldMat (1,e)                  => liftFieldMat (1,e)
480              | (true,E.Probe(E.Conv(_,[E.C _ ,E.V 0],_,[E.V 1]),pos))                  | (_,E.Probe(E.Conv(_,[E.C _ ,E.V 0],_,[E.V 1]),pos))
481                  => liftFieldMat (2,e)                  => liftFieldMat (2,e)
482              | (true,E.Probe(E.Conv(_,[E.C _ ,E.V 0],_,[E.V 1,E.V 2] ),pos))                  | (_,E.Probe(E.Conv(_,[E.C _ ,E.V 0],_,[E.V 1,E.V 2] ),pos))
483                  => liftFieldMat (3,e)                  => liftFieldMat (3,e)
484              | (true, E.Sum([(E.V 0,0,_)],E.Probe(E.Conv(_,[E.V 0 ,E.V 0],_,[]),pos)))              | (true, E.Sum([(E.V 0,0,_)],E.Probe(E.Conv(_,[E.V 0 ,E.V 0],_,[]),pos)))
485                  => liftFieldSum e                  => liftFieldSum e
# Line 384  Line 487 
487                  => liftFieldSum e                  => liftFieldSum e
488              | (true, E.Sum([(E.V 2,0,_)],E.Probe(E.Conv(_,[E.V 2 ,E.V 2],_,[E.V 0,E.V 1]),pos)))              | (true, E.Sum([(E.V 2,0,_)],E.Probe(E.Conv(_,[E.V 2 ,E.V 2],_,[E.V 0,E.V 1]),pos)))
489                  => liftFieldSum e                  => liftFieldSum e
490                    | (true,E.Probe(E.Conv(_,[E.C _ ],_,[]),pos))
491                        => liftFieldVec (0,e,fieldset)
492              | (_,E.Probe(E.Conv(_,_,_,[]),_))                  | (true,E.Probe(E.Conv(_,[E.C _],_,[E.V 0]),pos))
493                  => replaceProbe(0,e,b,[])                      => liftFieldVec (1,e,fieldset)
494              | (_,E.Probe(E.Conv (_,alpha,_,dx),_))                  | (true,E.Probe(E.Conv(_,[E.C _],_,[E.V 0,E.V 1] ),pos))
495                  => checkConst(dx,(0,e,b,[])) (*scans dx for contant*)                      => liftFieldVec (2,e,fieldset)
496              | (_,E.Sum(sx,p as E.Probe(E.Conv(_,_,_,[]),_)))                  | (true,E.Probe(E.Conv(_,[E.C _],_,[E.V 0,E.V 1,E.V 2] ),pos))
497                  => replaceProbe(0,e,p, sx)  (*no dx*)                          => liftFieldVec (3,e,fieldset)
498              | (_,E.Sum(sx,p as E.Probe(E.Conv(_,[],_,dx),_)))                  | _   => rewriteBodyB b
499                  => checkConst(dx,(0,e,p,sx)) (*scalar field*)                  (* end case *))
500              | (_,E.Sum(sx,E.Probe p))              | _   => rewriteBodyB b
                 => replaceProbe(0,e,E.Probe p, sx)  
             | (_,E.Sum(sx,E.Prod[eps,E.Probe p]))  
                 => replaceProbe(0,e,E.Probe p,sx)  
             | (_,_) => [e]  
501              (* end case *))              (* end case *))
502    
503          val (fieldset,var) = (case valnumflag          val (fieldset,var) = (case valnumflag
# Line 409  Line 508 
508          fun matchField b=(case b          fun matchField b=(case b
509              of E.Probe _ => 1              of E.Probe _ => 1
510              | E.Sum (_, E.Probe _)=>1              | E.Sum (_, E.Probe _)=>1
511              | E.Sum(_, E.Prod[ _ ,E.Probe _])=>1              | E.Sum(_, E.Opn(E.Prod,[ _ ,E.Probe _]))=>1
512              | _ =>0              | _ =>0
513              (*end case*))              (*end case*))
514            fun toStrField b=(case b
515                of E.Probe _ => print("\n"^(P.printbody b))
516                | E.Sum (_, E.Probe _)=>print("\n"^ (P.printbody b))
517                | E.Sum(_, E.Opn(E.Prod,[ _ ,E.Probe _]))=>print("\n"^ (P.printbody b))
518                | _ => print""
519                (*end case*))
520            val b=Ein.body ein
521    
522          in  (case var          in  (case var
523              of NONE=> (("\n \n mapp_not_replacing:"^(P.printerE ein)^":");(rewriteBody(Ein.body ein),fieldset,matchField(Ein.body ein),0))          of NONE=> (toStrField(b);(rewriteBody(Ein.body ein),fieldset,matchField(Ein.body ein),0))
524              | SOME v=> (("\n mapp_replacing"^(P.printerE ein)^":");( [(y,DstIL.VAR v)],fieldset, matchField(Ein.body ein),1))              | SOME v=> (("\n mapp_replacing"^(P.printerE ein)^":");( [(y,DstIL.VAR v)],fieldset, matchField(Ein.body ein),1))
525              (*end case*))              (*end case*))
526          end          end

Legend:
Removed from v.3325  
changed lines
  Added in v.3460

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