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

branches/charisee/src/compiler/high-to-mid/ProbeEin.sml revision 3092, Tue Mar 17 20:02:38 2015 UTC branches/charisee_dev/src/compiler/high-to-mid/ProbeEin.sml revision 3395, Tue Nov 10 18:23:07 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 39  Line 41 
41    
42      val testing=0      val testing=0
43      val testlift=1      val testlift=1
44      val cnt = ref 0      val detflag =true
45        val fieldliftflag=true
46        val valnumflag=true
47    
48    
49      fun printEINAPP e=MidToString.printEINAPP e      val cnt = ref 0
50      fun transformToIndexSpace e=T.transformToIndexSpace e      fun transformToIndexSpace e=T.transformToIndexSpace e
51      fun transformToImgSpace  e=T.transformToImgSpace  e      fun transformToImgSpace  e=T.transformToImgSpace  e
52        fun toStringBind e=(MidToString.toStringBind e)
53      fun transitionToString(testreplace,a,b)=(case testreplace      fun mkEin e=Ein.mkEin e
         of 0=> 1  
         | _ => (print(String.concat["\n\n\n Replace probe:\n",P.printbody a,"\n=>",P.printbody b]);1)  
         (*end case*))  
     fun mkEin(params,index,body)=E.EIN{params=params, index=index,body=body}  
54      fun mkEinApp(rator,args)=DstIL.EINAPP(rator,args)      fun mkEinApp(rator,args)=DstIL.EINAPP(rator,args)
     fun getBody(_,DstIL.EINAPP(E.EIN{body,...},_))=body  
     fun setBody(body',(y,DstIL.EINAPP(E.EIN{params,index,body},args)))=  
             (y,DstIL.EINAPP(E.EIN{params=params,index=index,body=body'},args))  
55    
56      fun testp n=(case testing      fun testp n=(case testing
57          of 0=> 1          of 0=> 1
58          | _ =>(print(String.concat n);1)          | _ =>((String.concat n);1)
         (*end case*))  
     fun  einapptostring (body,a,b)=(case testlift  
         of 0=>1  
         | _=> (print(String.concat["\n lift probe of ",P.printbody body,"=>\n\t", printEINAPP a,  "&\n\t", printEINAPP b]);1)  
59          (*end case*))          (*end case*))
60    
61    
# Line 133  Line 127 
127              (*end case*))              (*end case*))
128          (*sumIndex creating summaiton Index for body*)          (*sumIndex creating summaiton Index for body*)
129          val slb=1-s          val slb=1-s
130            val _=List.tabulate(dim, (fn dim=> (String.concat[" sx:",Int.toString(sx)," dim:",Int.toString(dim),"esum",Int.toString(sx+dim) ]) ))
131          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)))
132      in      in
133          E.Sum(esum, exp)          E.Sum(esum, exp)
# Line 141  Line 136 
136      (*getsumshift:sum_indexid list* int list-> int      (*getsumshift:sum_indexid list* int list-> int
137      *get fresh/unused index_id, returns int      *get fresh/unused index_id, returns int
138      *)      *)
139      fun getsumshift(sx,index) =let      fun getsumshift(sx,n) =let
140          val nsumshift= (case sx          val nsumshift= (case sx
141              of []=> length(index)              of []=> n
142              | _=>let              | _=>let
143                  val (E.V v,_,_)=List.hd(List.rev sx)                  val (E.V v,_,_)=List.hd(List.rev sx)
144                  in v+1                  in v+1
145                  end                  end
146              (* end case *))              (* end case *))
147    
148          val aa=List.map (fn (E.V v,_,_)=>Int.toString v) sx          val aa=List.map (fn (E.V v,_,_)=>Int.toString v) sx
149          val _ =testp["\n", "SumIndex" ,(String.concatWith"," aa),          val _ =(String.concat["\n", "SumIndex:" ,(String.concatWith"," aa),
150              "\nThink nshift is ", Int.toString nsumshift]          "\n\t Index length:",Int.toString n,
151            "\n\t Freshindex: ", Int.toString nsumshift])
152          in          in
153              nsumshift              nsumshift
154          end          end
# Line 166  Line 163 
163    
164      (* 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*)
165      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, E.Prod([P0,P1,P2,body])))
166        (*
167          | multiPs([P0,P1],sx,body)=formBody(E.Sum(sx, E.Prod([P0,body,P1])))
168          *)
169          | multiPs([P0,P1,P2,P3],sx,body)= formBody(E.Sum(sx, E.Prod([P0,P1,P2,P3,body])))
170        | multiPs(Ps,sx,body)=formBody(E.Sum(sx, E.Prod([body]@Ps)))        | multiPs(Ps,sx,body)=formBody(E.Sum(sx, E.Prod([body]@Ps)))
171    
172    
173        fun multiMergePs([P0,P1],[sx0,sx1],body)=E.Sum([sx0],E.Prod[P0,E.Sum([sx1],E.Prod[P1,body])])
174          | multiMergePs e=multiPs e
175    
176    
177      (* replaceProbe:ein_exp* params *midIL.var list * int list* sum_id list      (* replaceProbe:ein_exp* params *midIL.var list * int list* sum_id list
178              -> ein_exp* *code              -> ein_exp* *code
179      * Transforms position to world space      * Transforms position to world space
# Line 182  Line 188 
188          val originalb=Ein.body e          val originalb=Ein.body e
189          val params=Ein.params e          val params=Ein.params e
190          val index=Ein.index e          val index=Ein.index e
191            val _ = testp["\n***************** \n Replace ************ \n"]
192            val _=  toStringBind (y, DstIL.EINAPP(e,args))
193    
194          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
195          val fid=length(params)          val fid=length(params)
# Line 190  Line 197 
197          val Pid=nid+1          val Pid=nid+1
198          val nshift=length(dx)          val nshift=length(dx)
199          val (dim,argsA,code,s,PArg) = handleArgs(Vid,hid,tid,args)          val (dim,argsA,code,s,PArg) = handleArgs(Vid,hid,tid,args)
200          val freshIndex=getsumshift(sx,index)          val freshIndex=getsumshift(sx,length(index))
201          val (dx,newsx1,Ps)=transformToIndexSpace(freshIndex,dim,dx,Pid)          val (dx,newsx1,Ps)=transformToIndexSpace(freshIndex,dim,dx,Pid)
202          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])]
203          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 201  Line 208 
208              | E.Sum(sx,E.Prod[eps0,E.Probe _ ])  => E.Sum(sx,E.Prod[eps0,body'])              | E.Sum(sx,E.Prod[eps0,E.Probe _ ])  => E.Sum(sx,E.Prod[eps0,body'])
209              | _                                  => body'              | _                                  => body'
210              (*end case*))              (*end case*))
211          val _=transitionToString(testN,originalb,body')  
212    
213          val args'=argsA@[PArg]          val args'=argsA@[PArg]
214          val einapp=(y,mkEinApp(mkEin(params',index,body'),args'))          val einapp=(y,mkEinApp(mkEin(params',index,body'),args'))
# Line 209  Line 216 
216              code@[einapp]              code@[einapp]
217          end          end
218    
219        val tsplitvar=true
220      fun createEinApp(originalb,alpha,index,freshIndex,dim,dx,sx)= let      fun createEinApp(originalb,alpha,index,freshIndex,dim,dx,sx)= let
221          val Pid=0          val Pid=0
222          val tid=1          val tid=1
223    
224            (*Assumes body is already clean*)
225          val (newdx,newsx,Ps)=transformToIndexSpace(freshIndex,dim,dx,Pid)          val (newdx,newsx,Ps)=transformToIndexSpace(freshIndex,dim,dx,Pid)
226    
227          (*need to rewrite dx*)          (*need to rewrite dx*)
228          val (_,sizes,E.Conv(_,_,_,dx))=(case sx@newsx          val (_,sizes,e as E.Conv(_,alpha',_,dx))=(case sx@newsx
229              of []=> ([],index,E.Conv(9,alpha,7,newdx))              of []=> ([],index,E.Conv(9,alpha,7,newdx))
230              | _ =>cleanIndex.cleanIndex(E.Conv(9,alpha,7,newdx),index,sx@newsx)              | _ =>cleanIndex.cleanIndex(E.Conv(9,alpha,7,newdx),index,sx@newsx)
231              (*end case*))              (*end case*))
232    
233          val params=[E.TEN(1,[dim,dim]),E.TEN(1,sizes)]          val params=[E.TEN(1,[dim,dim]),E.TEN(1,sizes)]
234          val tshape=alpha@newdx          fun filterAlpha []=[]
235              | filterAlpha(E.C _::es)= filterAlpha es
236              | filterAlpha(e1::es)=[e1]@(filterAlpha es)
237    
238            val tshape=filterAlpha(alpha')@newdx
239          val t=E.Tensor(tid,tshape)          val t=E.Tensor(tid,tshape)
240          val exp = multiPs(Ps,newsx,t)          val (splitvar,body)=(case originalb
241          val body=(case originalb              of E.Sum(sx, E.Probe _)              => (*(false,E.Sum(sx,multiPs(Ps,newsx,t)))*) (true,multiPs(Ps,sx@newsx,t))
242              of E.Sum(sx, E.Probe _)              => E.Sum(sx,exp)              | E.Sum(sx,E.Prod[eps0,E.Probe _ ])  => (false,E.Sum(sx,E.Prod[eps0,multiPs(Ps,newsx,t)]))
243              | E.Sum(sx,E.Prod[eps0,E.Probe _ ])  => E.Sum(sx,E.Prod[eps0,exp])              | _                                  => (case tsplitvar
244              | _                                  => exp                  of(* true =>   (true,multiMergePs(Ps,newsx,t))  (*pushes summations in place*)
245                    | false*) _ =>   (true,multiPs(Ps,newsx,t))
246                    (*end case*))
247                (*end case*))
248    
249            val _ =(case splitvar
250            of true=> (String.concat["splitvar is true", P.printbody body])
251            | _ => (String.concat["splitvar is false",P.printbody body])
252              (*end case*))              (*end case*))
253    
254    
255          val ein0=mkEin(params,index,body)          val ein0=mkEin(params,index,body)
256          in          in
257              (ein0,sizes,dx)              (splitvar,ein0,sizes,dx,alpha')
258          end          end
259    
260      fun liftProbe(testN,(y, DstIL.EINAPP(e,args)),p ,sx)=let      fun liftProbe(printStrings,(y, DstIL.EINAPP(e,args)),p ,sx)=let
261            val _=(String.concat["\n******* Lift Geneirc Probe ***\n"])
262          val originalb=Ein.body e          val originalb=Ein.body e
263          val params=Ein.params e          val params=Ein.params e
264          val index=Ein.index e          val index=Ein.index e
265            val _ =  (toStringBind (y, DstIL.EINAPP(e,args)))
266    
267          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
268          val fid=length(params)          val fid=length(params)
269          val nid=fid+1          val nid=fid+1
270          val nshift=length(dx)          val nshift=length(dx)
271          val (dim,args',code,s,PArg) = handleArgs(Vid,hid,tid,args)          val (dim,args',code,s,PArg) = handleArgs(Vid,hid,tid,args)
272          val freshIndex=getsumshift(sx,index)          val freshIndex=getsumshift(sx,length(index))
   
273    
274          (*transform T*P*P..Ps*)          (*transform T*P*P..Ps*)
275          val (ein0,sizes,dx)= createEinApp(originalb,alpha,index,freshIndex,dim,dx,sx)          val (splitvar,ein0,sizes,dx,alpha')= createEinApp(originalb,alpha,index,freshIndex,dim,dx,sx)
276          val FArg  = DstV.new ("F", DstTy.TensorTy(sizes))          val FArg  = DstV.new ("F", DstTy.TensorTy(sizes))
277          val einApp0=mkEinApp(ein0,[PArg,FArg])          val einApp0=mkEinApp(ein0,[PArg,FArg])
278          val rtn0=(y,einApp0)          val rtn0=(case splitvar
279                of false => [(y,mkEinApp(ein0,[PArg,FArg]))]
280                | _      => let
281                     val bind3 = (y,DstIL.EINAPP(SummationEin.main ein0,[PArg,FArg]))
282                     in Split.splitEinApp(bind3,0)
283                     end
284                (*end case*))
285    
286          (*lifted probe*)          (*lifted probe*)
287          val params'=params@[E.TEN(3,[dim]),E.TEN(1,[dim])]          val params'=params@[E.TEN(3,[dim]),E.TEN(1,[dim])]
288          val body' = createBody(dim, s,freshIndex+nshift,alpha,dx,Vid, hid, nid, fid)          val freshIndex'= length(sizes)
289    
290            val body' = createBody(dim, s,freshIndex',alpha',dx,Vid, hid, nid, fid)
291          val ein1=mkEin(params',sizes,body')          val ein1=mkEin(params',sizes,body')
292          val einApp1=mkEinApp(ein1,args')          val einApp1=mkEinApp(ein1,args')
293          val rtn1=(FArg,einApp1)          val rtn1=(FArg,einApp1)
294          val rtn=code@[rtn1,rtn0]          val rtn=code@[rtn1]@rtn0
295          val _= einapptostring (p,rtn1,rtn0)          val _= List.map toStringBind ([rtn1]@rtn0)
296             val _=(String.concat["\n* end  Lift Geneirc Probe  ******** \n"])
297          in          in
298              rtn              rtn
299          end          end
300    
301        fun searchFullField (fieldset,code1,body1,dx)=let
302            val (lhs,_)=code1
303            fun continueReconstruction ()=let
304                val _=print"Tash:don't replaced"
305                in (case dx
306                    of []=> (lhs,replaceProbe(1,code1,body1,[]))
307                    | _ =>(lhs,liftProbe(1,code1,body1,[]))
308                    (*end case*))
309                 end
310            in  (case valnumflag
311                of false => (fieldset,continueReconstruction())
312                | true => (case  (einSet.rtnVarN(fieldset,code1))
313                    of (fieldset,NONE)     => (fieldset,continueReconstruction())
314                     | (fieldset,SOME m)   =>(print"TASH:replaced"; (fieldset,(m,[])))
315                    (*end case*))
316                (*end case*))
317            end
318    
319        fun liftFieldMat(newvx,e)=
320            let
321                val _=print "\n ***************************** start FieldMat\n"
322                val (y, DstIL.EINAPP(ein,args))=e
323                val E.Probe(E.Conv(V,[c1,v0],h,dx),pos)=Ein.body ein
324                val index0=Ein.index ein
325                val index1 = index0@[3]
326                val body1_unshifted = E.Probe(E.Conv(V,[E.V newvx, v0],h,dx),pos)
327                (* clean to get body indices in order *)
328                val ( _ , _, body1)= cleanIndex.cleanIndex(body1_unshifted,index1,[])
329                val _ = testp ["\n Shifted ",P.printbody body1_unshifted,"=>",P.printbody body1]
330    
331                val lhs1=DstV.new ("L", DstTy.TensorTy(index1))
332                val ein1 = mkEin(Ein.params ein,index1,body1)
333                val code1= (lhs1,mkEinApp(ein1,args))
334                val codeAll= (case dx
335                of []=> replaceProbe(1,code1,body1,[])
336                | _ =>liftProbe(1,code1,body1,[])
337                (*end case*))
338    
339                (*Probe that tensor at a constant position  c1*)
340                val param0 = [E.TEN(1,index1)]
341                val nx=List.tabulate(length(dx)+1,fn n=>E.V n)
342                val body0 =  E.Tensor(0,[c1]@nx)
343                val ein0 = mkEin(param0,index0,body0)
344                val einApp0 = mkEinApp(ein0,[lhs1])
345                val code0 = (y,einApp0)
346                val _= toStringBind code0
347                        val _=print "\n end FieldMat *****************************\n "
348            in
349                codeAll@[code0]
350        end
351    
352        fun liftFieldVec(newvx,e,fieldset)=
353        let
354            val _=print "\n ***************************** start FieldVec\n"
355            val (y, DstIL.EINAPP(ein,args))=e
356            val E.Probe(E.Conv(V,[c1],h,dx),pos)=Ein.body ein
357            val index0=Ein.index ein
358            val index1 = index0@[3]
359            val body1_unshifted = E.Probe(E.Conv(V,[E.V newvx],h,dx),pos)
360            (* clean to get body indices in order *)
361            val ( _ , _, body1)= cleanIndex.cleanIndex(body1_unshifted,index1,[])
362    
363    
364            val lhs1=DstV.new ("L", DstTy.TensorTy(index1))
365            val ein1 = mkEin(Ein.params ein,index1,body1)
366            val code1= (lhs1,mkEinApp(ein1,args))
367            val (fieldset,(lhs0,codeAll))=searchFullField (fieldset,code1,body1,dx)
368    
369            (*Probe that tensor at a constant position  c1*)
370            val param0 = [E.TEN(1,index1)]
371            val nx=List.tabulate(length(dx),fn n=>E.V n)
372            val body0 =  E.Tensor(0,[c1]@nx)
373            val ein0 = mkEin(param0,index0,body0)
374            val einApp0 = mkEinApp(ein0,[lhs0])
375            val code0 = (y,einApp0)
376    
377            val _ = (String.concat ["\n Shifted ",P.printbody body1_unshifted,"=>",P.printbody body1])
378            val _=  (toStringBind code0)
379            val _=print "\n end FieldVec *****************************\n "
380            in
381                codeAll@[code0]
382        end
383    
384    
385    
386        fun liftFieldSum e =
387        let
388            val _=print "\n************************************* Start Lift Field Sum\n"
389            val (y, DstIL.EINAPP(ein,args))=e
390            val E.Sum([(vsum,0,n)],E.Probe(E.Conv(V,[c1,v0],h,dx),pos))=Ein.body ein
391            val index0=Ein.index ein
392            val index1 = index0@[3]@[3]
393            val shiftdx=List.tabulate(length(dx),fn n=>E.V (n+2))
394            val body1 = E.Probe(E.Conv(V,[E.V 0,E.V 1],h,shiftdx),pos)
395    
396    
397            val lhs1=DstV.new ("L", DstTy.TensorTy(index1))
398            val ein1 = mkEin(Ein.params ein,index1,body1)
399            val code1= (lhs1,mkEinApp(ein1,args))
400            val codeAll= (case dx
401                of []=> replaceProbe(1,code1,body1,[])
402                | _ =>liftProbe(1,code1,body1,[])
403                (*end case*))
404    
405            (*Probe that tensor at a constant position  c1*)
406            val param0 = [E.TEN(1,index1)]
407            val nx=List.tabulate(length(dx),fn n=>E.V n)
408            val body0 =  E.Sum([(vsum,0,n)],E.Tensor(0,[vsum,vsum]@nx))
409            val ein0 = mkEin(param0,index0,body0)
410            val einApp0 = mkEinApp(ein0,[lhs1])
411            val code0 = (y,einApp0)
412            val _ = toStringBind  e
413            val _ = toStringBind code0
414            val _  = (String.concat  ["\norig",P.printbody(Ein.body ein),"\n replace i  ",P.printbody body1,"\nfreshtensor",P.printbody body0])
415            val _  =((List.map toStringBind (codeAll@[code0])))
416            val _ = print "\n*** end Field Sum*************************************\n"
417            in
418            codeAll@[code0]
419        end
420    
421    
422      (* expandEinOp: code->  code list      (* expandEinOp: code->  code list
423      *A this point we only have simple ein ops      *A this point we only have simple ein ops
424      *Looks to see if the expression has a probe. If so, replaces it.      *Looks to see if the expression has a probe. If so, replaces it.
425      * Note how we keeps eps expressions so only generate pieces that are used      * Note how we keeps eps expressions so only generate pieces that are used
426      *)      *)
427      fun expandEinOp( e as (y, DstIL.EINAPP(ein,args))) = let     fun expandEinOp( e as (y, DstIL.EINAPP(ein,args)),fieldset)=let
428          fun checkConst ([],a) = liftProbe a  
429            fun (*checkConst ([],a) =
430                (case fieldliftflag
431                    of true => liftProbe a
432                    | _ => replaceProbe a
433                (*end case*))
434          | checkConst ((E.C _::_),a) =replaceProbe a          | checkConst ((E.C _::_),a) =replaceProbe a
435          | checkConst ((_ ::es),a)=checkConst(es,a)          | checkConst ((_ ::es),a)=checkConst(es,a)
436          fun rewriteBody b=(case b          *)
437              of E.Probe(E.Conv(_,_,_,[]),_)          checkConst (_,a) = liftProbe a
438                  => replaceProbe(1,e,b, [])          fun rewriteBody b=(case (detflag,b)
439              | E.Probe(E.Conv (_,alpha,_,dx),_)              of (true,E.Probe(E.Conv(_,[E.C _ ,E.V 0],_,[]),pos))
440                  => checkConst(alpha@dx,(0,e,b,[]))                  => liftFieldMat (1,e)
441              | E.Sum(sx,p as E.Probe(E.Conv(_,_,_,[]),_))              | (true,E.Probe(E.Conv(_,[E.C _ ,E.V 0],_,[E.V 1]),pos))
442                  => replaceProbe(1,e,p, sx)                  => liftFieldMat (2,e)
443              | E.Sum(sx,p as E.Probe(E.Conv(_,[],_,dx),_))              | (true,E.Probe(E.Conv(_,[E.C _ ,E.V 0],_,[E.V 1,E.V 2] ),pos))
444                  => checkConst(dx,(0,e,p,sx))                  => liftFieldMat (3,e)
445              | E.Sum(sx,E.Probe p)              | (true, E.Sum([(E.V 0,0,_)],E.Probe(E.Conv(_,[E.V 0 ,E.V 0],_,[]),pos)))
446                  => replaceProbe(1,e,E.Probe p, sx)                  => liftFieldSum e
447              | E.Sum(sx,E.Prod[eps,E.Probe p])              | (true, E.Sum([(E.V 1,0,_)],E.Probe(E.Conv(_,[E.V 1 ,E.V 1],_,[E.V 0]),pos)))
448                  => replaceProbe(1,e,E.Probe p,sx)                  => liftFieldSum e
449              | _ => [e]              | (true, E.Sum([(E.V 2,0,_)],E.Probe(E.Conv(_,[E.V 2 ,E.V 2],_,[E.V 0,E.V 1]),pos)))
450                    => liftFieldSum e
451                | (true,E.Probe(E.Conv(_,[E.C _ ],_,[]),pos))
452                    => liftFieldVec (0,e,fieldset)
453                | (true,E.Probe(E.Conv(_,[E.C _],_,[E.V 0]),pos))
454                    => liftFieldVec (1,e,fieldset)
455                | (true,E.Probe(E.Conv(_,[E.C _],_,[E.V 0,E.V 1] ),pos))
456                    => liftFieldVec (2,e,fieldset)
457                | (true,E.Probe(E.Conv(_,[E.C _],_,[E.V 0,E.V 1,E.V 2] ),pos))
458                    => liftFieldVec (3,e,fieldset)
459                | (_,E.Probe(E.Conv(_,_,_,[]),_))
460                    => replaceProbe(0,e,b,[])
461                | (_,E.Probe(E.Conv (_,alpha,_,dx),_))
462                    => checkConst(dx,(0,e,b,[])) (*scans dx for contant*)
463                | (_,E.Sum(sx,p as E.Probe(E.Conv(_,_,_,[]),_)))
464                    => replaceProbe(0,e,p, sx)  (*no dx*)
465                | (_,E.Sum(sx,p as E.Probe(E.Conv(_,[],_,dx),_)))
466                    => checkConst(dx,(0,e,p,sx)) (*scalar field*)
467                | (_,E.Sum(sx,E.Probe p))
468                    => replaceProbe(0,e,E.Probe p, sx)
469                | (_,E.Sum(sx,E.Prod[eps,E.Probe p]))
470                    => replaceProbe(0,e,E.Probe p,sx)
471                | (_,_) => [e]
472                (* end case *))
473    
474            val (fieldset,var) = (case valnumflag
475                of true => einSet.rtnVar(fieldset,y,DstIL.EINAPP(ein,args))
476                | _     => (fieldset,NONE)
477            (*end case*))
478    
479            fun matchField b=(case b
480                of E.Probe _ => 1
481                | E.Sum (_, E.Probe _)=>1
482                | E.Sum(_, E.Prod[ _ ,E.Probe _])=>1
483                | _ =>0
484                (*end case*))
485            fun toStrField b=(case b
486                of E.Probe _ => print("\n"^(P.printbody b))
487                | E.Sum (_, E.Probe _)=>print("\n"^ (P.printbody b))
488                | E.Sum(_, E.Prod[ _ ,E.Probe _])=>print("\n"^ (P.printbody b))
489                | _ => print""
490                (*end case*))
491                val b=Ein.body ein
492            (*
493            val _=  toStrField b*)
494    
495            in  (case var
496            of NONE=> (toStrField b;(rewriteBody(Ein.body ein),fieldset,matchField(Ein.body ein),0))
497                | SOME v=> (("\n mapp_replacing"^(P.printerE ein)^":");( [(y,DstIL.VAR v)],fieldset, matchField(Ein.body ein),1))
498              (* end case *))              (* end case *))
         in  
             rewriteBody (Ein.body ein)  
499          end          end
500    
501    end; (* local *)    end; (* local *)

Legend:
Removed from v.3092  
changed lines
  Added in v.3395

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