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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/mid-to-low/helper-set.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/mid-to-low/helper-set.sml

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

revision 3541, Mon Jan 4 18:03:27 2016 UTC revision 3542, Mon Jan 4 19:47:38 2016 UTC
# Line 1  Line 1 
1  (*Helper functions  (*Helper functions*)
 *)  
2  structure HelperSet = struct  structure HelperSet = struct
3      local      local
4    
# Line 15  Line 14 
14      structure IMap = IntRedBlackMap      structure IMap = IntRedBlackMap
15      in      in
16    
     val testing=0  
17      val valnum=true      val valnum=true
18      val bV= ref 0      val bV= ref 0
19      fun err str=raise Fail(str)      fun err str=raise Fail(str)
# Line 23  Line 21 
21      val intTy=DstTy.intTy      val intTy=DstTy.intTy
22      fun iTos e1=Int.toString e1      fun iTos e1=Int.toString e1
23      fun iToss es=String.concat(List.map iTos es)      fun iToss es=String.concat(List.map iTos es)
24      fun testp n= (case testing      val testing=false
25          of 0 => 0      fun testp n =if (testing) then (print(String.concat n);1) else 1
         | _ =>((print (String.concat n));1)  
         (*end case*))  
   
26      val empty = IMap.empty      val empty = IMap.empty
27      fun lookup k d = IMap.find(d, k)      fun lookup k d = IMap.find(d, k)
28      fun insert (k, v) d = ((String.concat["\n\t",Int.toString(k),"==>",Int.toString(v)]) ;IMap.insert(d, k, v))      fun insert (k, v) d = ((String.concat["\n\t",Int.toString(k),"==>",Int.toString(v)]) ;IMap.insert(d, k, v))
# Line 44  Line 39 
39          of E.V e => find(e,mapp)          of E.V e => find(e,mapp)
40           | E.C c => c           | E.C c => c
41          (*end case*))          (*end case*))
   
42      (*     *************************** DstIL.ASSGN  ****************************  *)      (*     *************************** DstIL.ASSGN  ****************************  *)
         fun noplugin(opset,ty,lhs,rhs)=let  
                    val codeo=DstIL.ASSGN (lhs,rhs)  
                     val (a,code)=(lhs,[codeo])  
             in  
                 (opset,a,code)  
             end  
   
   
43      fun plugin(opset,ty,lhs,rhs)=(case valnum      fun plugin(opset,ty,lhs,rhs)=(case valnum
44          of false => noplugin(opset,ty,lhs,rhs)          of false => (opset,lhs,[DstIL.ASSGN (lhs,rhs)])
45          | _ =>          | _ =>
46              let              let
47                  val (opset,var) = lowSet.filter(opset,(lhs,rhs))                  val (opset,var) = lowSet.filter(opset,(lhs,rhs))
                 val codeo=DstIL.ASSGN (lhs,rhs)  
   
48                  val (a,code)=(case var                  val (a,code)=(case var
49                      of  SOME v=> (testp["\n Found(",DstIL.Var.toString(v),"):",LowToS.toStringAll(ty,codeo)]; (v,[]))                      of  SOME v=> (v,[])
50                      | NONE  => (testp["\n Inserting:",LowToS.toStringAll(ty,codeo)];(lhs,[codeo]))                      | NONE  => (lhs,[DstIL.ASSGN (lhs,rhs)])
   
51                      (*end case*))                      (*end case*))
52              in              in (opset,a,code) end
                 (opset,a,code)  
             end  
53          (*end case *))          (*end case *))
   
54      (*     *************************** DstIL.LIT ****************************  *)      (*     *************************** DstIL.LIT ****************************  *)
   
55      (* mkINt:int->Var*code list*)      (* mkINt:int->Var*code list*)
56      fun mkInt (opset,n)=let      fun mkInt (opset,n)=let
57          val lhs=DstIL.Var.new("Int" ,intTy)          val lhs=DstIL.Var.new("Int" ,intTy)
# Line 80  Line 59 
59      in      in
60          plugin(opset,intTy,lhs,rhs)          plugin(opset,intTy,lhs,rhs)
61      end      end
   
62      fun mkReal (opset,n)=let      fun mkReal (opset,n)=let
63          val lhs=DstIL.Var.new("real" ,realTy)          val lhs=DstIL.Var.new("real" ,realTy)
64          val rhs=DstIL.LIT(Literal.Int(IntInf.fromInt n))          val rhs=DstIL.LIT(Literal.Int(IntInf.fromInt n))
65      in      in
66          plugin(opset,realTy,lhs,rhs)          plugin(opset,realTy,lhs,rhs)
67      end      end
   
68      (*     *************************** DstIL.CONS ****************************  *)      (*     *************************** DstIL.CONS ****************************  *)
69      fun assgnCons(opset,pre,shape, args)=let      fun assgnCons(opset,pre,shape, args)=let
70          val ty=DstTy.TensorTy shape          val ty=DstTy.TensorTy shape
# Line 97  Line 74 
74              plugin(opset,ty,lhs,rhs)              plugin(opset,ty,lhs,rhs)
75          end          end
76    
   
77      (*     ***************************  DstIL.OP  ****************************  *)      (*     ***************************  DstIL.OP  ****************************  *)
78      fun assignOP(opset,opss,args,pre,ty)=let      fun assignOP(opset,opss,args,pre,ty)=let
79          val lhs=DstIL.Var.new(pre ,ty)          val lhs=DstIL.Var.new(pre ,ty)
# Line 105  Line 81 
81      in      in
82          plugin(opset,ty,lhs,rhs)          plugin(opset,ty,lhs,rhs)
83      end      end
   
84      fun mkSingle(opp,name,(opset,nU,code))=let      fun mkSingle(opp,name,(opset,nU,code))=let
85          val (opset,vA,A)=assignOP(opset,opp,[nU],name,realTy)          val (opset,vA,A)=assignOP(opset,opp,[nU],name,realTy)
86          in          in
87              (opset,vA,code@A)              (opset,vA,code@A)
88          end          end
   
89      (*     *************************** DstOp.IndexTensor ****************************  *)      (*     *************************** DstOp.IndexTensor ****************************  *)
90      (*getTensorTy:E.params*E.tensor_id-> LowIL.Ty      (*getTensorTy:E.params*E.tensor_id-> LowIL.Ty
91      * Integer, or Generic Tensor      * Integer, or Generic Tensor
# Line 121  Line 95 
95          | E.TEN(_,shape)=> DstTy.TensorTy shape          | E.TEN(_,shape)=> DstTy.TensorTy shape
96          |_=> err"NONE Tensor Param"          |_=> err"NONE Tensor Param"
97          (*end case*))          (*end case*))
   
98      (* indexTensor:dict*string*E.params*Var list*E.tensor_id*E.alpha      (* indexTensor:dict*string*E.params*Var list*E.tensor_id*E.alpha
99      * ->Var*code list      * ->Var*code list
100      * Index Tensor at specific indices to give a scalar result      * Index Tensor at specific indices to give a scalar result
# Line 138  Line 111 
111          in          in
112              assignOP(opset,opp,[nU],name,ty)              assignOP(opset,opp,[nU],name,ty)
113          end          end
   
   
114      (*     *************************** DstOp._ Shortcuts ****************************  *)      (*     *************************** DstOp._ Shortcuts ****************************  *)
   
     (* Some shortcuts. Arguements are Low-IL variables already indexed/projected  
     * string*Var list ->Var*code list  
     *)  
115      fun mkAddSca(opset,args)= assignOP(opset,DstOp.addSca,args,"addSca",realTy)      fun mkAddSca(opset,args)= assignOP(opset,DstOp.addSca,args,"addSca",realTy)
116      fun mkAddInt(opset,args)= assignOP(opset,DstOp.addSca,args,"addInt",intTy)      fun mkAddInt(opset,args)= assignOP(opset,DstOp.addSca,args,"addInt",intTy)
117      fun mkAddPtr(opset,args,ty)= assignOP(opset,DstOp.addSca,args,"addPtr",ty)      fun mkAddPtr(opset,args,ty)= assignOP(opset,DstOp.addSca,args,"addPtr",ty)
# Line 155  Line 122 
122      fun mkProdVec(opset,vecIX,args)=assignOP(opset,DstOp.prodVec vecIX,args,"prodV",DstTy.TensorTy([vecIX]))      fun mkProdVec(opset,vecIX,args)=assignOP(opset,DstOp.prodVec vecIX,args,"prodV",DstTy.TensorTy([vecIX]))
123      fun mkDivSca(opset,args)= assignOP(opset,DstOp.divSca,args,"divSca",realTy)      fun mkDivSca(opset,args)= assignOP(opset,DstOp.divSca,args,"divSca",realTy)
124      fun mkSumVec(opset,vecIX,args)= assignOP(opset,DstOp.sumVec vecIX,args,"sumVec",realTy)      fun mkSumVec(opset,vecIX,args)= assignOP(opset,DstOp.sumVec vecIX,args,"sumVec",realTy)
   
125      (*     *************************** DstOp. Other ****************************  *)      (*     *************************** DstOp. Other ****************************  *)
126      fun mkDotVec(opset,vecIX,args)=let      fun mkDotVec(opset,vecIX,args)=let
127          val (opsetD,vD, D)=mkProdVec(opset,vecIX,args)          val (opsetD,vD, D)=mkProdVec(opset,vecIX,args)
128          val (opsetE,vE, E)=mkSumVec(opsetD,vecIX,[vD])          val (opsetE,vE, E)=mkSumVec(opsetD,vecIX,[vD])
129          in (opsetE,vE,D@E) end          in (opsetE,vE,D@E) end
   
130      fun intToReal(setA,n)=let      fun intToReal(setA,n)=let
131          val (setC,vC,C)=mkReal(setA,n)          val (setC,vC,C)=mkReal(setA,n)
132          val (setD,vD,D)=assignOP(setC,DstOp.IntToReal,[vC],"cast",realTy)          val (setD,vD,D)=assignOP(setC,DstOp.IntToReal,[vC],"cast",realTy)
133          in (setD,vD,C@D)end          in (setD,vD,C@D)end
   
134      fun mkPowInt((opset,nU,code),nn)= let      fun mkPowInt((opset,nU,code),nn)= let
135          fun pow(1,setA)=(setA,nU,[])          fun pow(1,setA)=(setA,nU,[])
136          | pow(2,setA)=let          | pow(2,setA)=let
# Line 199  Line 163 
163          in          in
164              (setA,vA,code@A)              (setA,vA,code@A)
165          end          end
   
166      fun mkOp1(E.PowInt n,e)     = mkPowInt(e,n)      fun mkOp1(E.PowInt n,e)     = mkPowInt(e,n)
167        | mkOp1(t,e)=let        | mkOp1(t,e)=let
168          val opp=(case t          val opp=(case t
# Line 214  Line 177 
177              | E.PowReal n       => DstOp.powRat(DstTy.R n)              | E.PowReal n       => DstOp.powRat(DstTy.R n)
178              (*end case*))              (*end case*))
179          in  mkSingle(opp,"_op1_",e) end          in  mkSingle(opp,"_op1_",e) end
   
180      (*mkMultiple:string*Var list*LowOps.Op *ListIL.Ty -> Var*code list      (*mkMultiple:string*Var list*LowOps.Op *ListIL.Ty -> Var*code list
181      *apply rator between each items on list1      *apply rator between each items on list1
182      *)      *)
# Line 231  Line 193 
193          in          in
194              add(opsetM,list1,[],List.length list1)              add(opsetM,list1,[],List.length list1)
195          end          end
   
   
196      (*     *************************** DstOp. Greek ****************************  *)      (*     *************************** DstOp. Greek ****************************  *)
197      (* deltaToInt:dict*E.mu*E.mu->int      (* deltaToInt:dict*E.mu*E.mu->int
198      * delta function      * delta function
# Line 241  Line 201 
201          val i=mapIndex(a,mapp)          val i=mapIndex(a,mapp)
202          val j=mapIndex(b,mapp)          val j=mapIndex(b,mapp)
203          in if(i=j) then 1 else  0 end          in if(i=j) then 1 else  0 end
   
204      fun evalDelta(opset,mapp,a,b)= intToReal(opset,deltaToInt(mapp,a,b))      fun evalDelta(opset,mapp,a,b)= intToReal(opset,deltaToInt(mapp,a,b))
   
205      (*eval Epsilon-2d*)      (*eval Epsilon-2d*)
206      fun evalEps2(opset,mapp,a,b)=let      fun evalEps2(opset,mapp,a,b)=let
207          val i=mapIndex(E.V a,mapp)          val i=mapIndex(E.V a,mapp)
# Line 253  Line 211 
211                  if(j>i) then intToReal(opset,1)                  if(j>i) then intToReal(opset,1)
212                  else intToReal(opset, ~1)                  else intToReal(opset, ~1)
213          end          end
   
214      (*eval Epsilon-3d*)      (*eval Epsilon-3d*)
215      fun evalEps3(opset,mapp,a,b,c)=let      fun evalEps3(opset,mapp,a,b,c)=let
216          val i=mapIndex(E.V a,mapp)          val i=mapIndex(E.V a,mapp)

Legend:
Removed from v.3541  
changed lines
  Added in v.3542

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