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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/translate/translate-basis.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/translate/translate-basis.sml

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

revision 2485, Mon Oct 21 16:34:57 2013 UTC revision 2922, Tue Mar 3 03:55:09 2015 UTC
# Line 12  Line 12 
12     * to the instantiated meta variables mvs) to a list of SSA assignments in     * to the instantiated meta variables mvs) to a list of SSA assignments in
13     * reverse order.     * reverse order.
14     *)     *)
15      val translate : (HighIL.var * Var.var * Types.meta_var list * HighIL.var list)      val translate : (HighIL.var * Var.var * SimpleTypes.meta_arg list * HighIL.var list)
16            -> HighIL.assignment list            -> HighIL.assignment list
17    
18    end = struct    end = struct
# Line 21  Line 21 
21      structure IL = HighIL      structure IL = HighIL
22      structure DstTy = HighILTypes      structure DstTy = HighILTypes
23      structure Op = HighOps      structure Op = HighOps
24      structure Ty = Types      structure Ty = SimpleTypes
     structure TU = TypeUtil  
     structure MV = MetaVar  
25      structure VTbl = Var.Tbl      structure VTbl = Var.Tbl
26      structure EinOp= Operators      structure mk= mkOperators
     structure S=Specialize  
27    
28      fun pruneTy tv = (case TU.prune(MV.toType tv)      fun trType (Ty.TY ty) = TranslateTy.tr ty
29             of (ty as Ty.T_Var _) => raise Fail("unresolved type " ^ TU.toString ty)        | trType _ = raise Fail "expected type"
30              | ty => TranslateTy.tr ty      fun dimVarToInt (Ty.DIM d) = d
31            (* end case *))        | dimVarToInt _ = raise Fail "expected dim"
   
     fun pruneDim d = (case TU.pruneDim d  
            of (Ty.DimConst n) => n  
             | d => raise Fail("unresolved dimension " ^ TU.dimToString d)  
           (* end case *))  
   
   
   
     fun pruneShape sv = (case TU.pruneShape(MV.toShape sv)  
         of Ty.Shape dd => DstTy.tensorTy(List.map pruneDim dd)  
             | shp => raise Fail("unresolved shape " ^ TU.shapeToString shp)  
         (* end case *))  
   
   
     fun dimVarToInt dv = pruneDim(MV.toDim dv)  
32      fun dimVarToTensor dv = DstTy.tensorTy[dimVarToInt dv]      fun dimVarToTensor dv = DstTy.tensorTy[dimVarToInt dv]
33      fun dimVarToMatrix dv = let      fun dimVarToMatrix dv = let
34            val d = dimVarToInt dv            val d = dimVarToInt dv
35            in            in
36              DstTy.tensorTy[d, d]        (* square matrix type *)              DstTy.tensorTy[d, d]        (* square matrix type *)
37            end            end
38        fun shapeVarToTensor (Ty.SHAPE shp) = DstTy.tensorTy shp
39          | shapeVarToTensor _ = raise Fail "expected shape"
40    
41      fun assign (y, rator, xs) = [IL.ASSGN(y, IL.OP(rator, xs))]      fun assign (y, rator, xs) = [IL.ASSGN(y, IL.OP(rator, xs))]
42    
43      fun basisFn name (y, [], xs) = [IL.ASSGN(y, IL.APPLY(name, xs))]      fun basisFn name (y, [], xs) = [IL.ASSGN(y, IL.APPLY(name, xs))]
44    
45      fun simpleOp rator (y, [], xs) = assign (y, rator, xs)      fun simpleOp rator (y, [], xs) = assign (y, rator, xs)
         fun shapeVarToTensor sv = pruneShape sv  
   
46    
47      fun tensorOp rator (y, [sv], xs) = assign (y, rator(shapeVarToTensor sv), xs)      fun tensorOp rator (y, [sv], xs) = assign (y, rator(shapeVarToTensor sv), xs)
48    
# Line 69  Line 50 
50    
51      fun kernel h (y, [], []) = assign(y, Op.Kernel(h, 0), [])      fun kernel h (y, [], []) = assign(y, Op.Kernel(h, 0), [])
52    
53        val cnt = ref 0
54        fun genName prefix = let
55            val n = !cnt
56            in
57                cnt := n+1;
58                String.concat[prefix, "_", Int.toString n]
59            end
60    (* utility functions for synthesizing eigenvector/eigenvalue code *)    (* utility functions for synthesizing eigenvector/eigenvalue code *)
61      fun eigenVec (rator, dim) = let      fun eigenVec (rator, dim) = let
62            val ty = DstTy.SeqTy(DstTy.realTy, dim)            val ty = DstTy.SeqTy(DstTy.realTy, dim)
# Line 89  Line 77 
77                  end                  end
78            end            end
79    
80        fun assignEin (y, rator, xs) = IL.ASSGN(y, IL.EINAPP(rator, xs))
81    
82        fun  simpleEOp rator (y, _,xs) = [assignEin(y, rator, xs)]
   
   
     fun assignEin (y, rator, xs) = [IL.ASSGN(y, IL.EINAPP(rator, xs))]  
   
     fun assignEin2 (y, rator, xs) = IL.ASSGN(y, IL.EINAPP(rator, xs))  
   
     fun simpleEinOp rator (y, _,xs) = assignEin(y, rator, xs)  
   
     fun peelFieldSK SK=[2]  (*(case TU.pruneShape(MV.toShape SK)  
             of Ty.Shape dd =>  List.map pruneDim dd  
             | shp => raise Fail("unresolved shape " ^ TU.shapeToString shp)  
             (* end case *))*)  
   
   
   
     fun tensorEinOp einop (y, [SK], xs) =  
         let val ty1 as DstTy.TensorTy dd1 = pruneShape SK  
             val rator =S.transform(einop,[dd1],[])  
         in  
                 assignEin(y, rator,xs)  
         end  
   
   
   
   
   
     fun scalarField(einop,paramarg,y,xs)=  
             let val paramarg'=List.map dimVarToInt  paramarg(*[2]*)  
                 val rator=S.transform(einop, [[]],paramarg')  
   
             in  
                 assignEin(y, rator, xs)  
             end  
   
     fun singleField(SK,einop,paramarg, y, xs)=  
         let  
             val s=peelFieldSK SK  
             val paramarg'= List.map dimVarToInt paramarg (*[2]*)  
             val rator= S.transform(einop, [s],paramarg')  
         in assignEin(y, rator, xs)  
         end  
   
   
   
   
 (****MV.toDim returns int, and DstTy.TensorTy returns intlist *)  
   
 (*DK- SK-shape,NK-dim *)  
83    
84  (* shape is an int list, DIM is in int|variable, k-level of differntiation *)  (* shape is an int list, DIM is in int|variable, k-level of differntiation *)
85    
86   (* build a table that maps Basis variables to their translation functions *)   (* build a table that maps Basis variables to their translation functions *)
87      val tbl : ((IL.var * Ty.meta_var list * IL.var list) -> IL.assignment list) VTbl.hash_table = let      val tbl : ((IL.var * Ty.meta_arg list * IL.var list) -> IL.assignment list) VTbl.hash_table = let
88            val tbl = VTbl.mkTable (128, Fail "Translate table")            val tbl = VTbl.mkTable (128, Fail "Translate table")
89            val insert = VTbl.insert tbl            val insert = VTbl.insert tbl
90            in            in
# Line 165  Line 106 
106                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),
107                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),
108                  (BV.add_ii,             simpleOp Op.IAdd ),                  (BV.add_ii,             simpleOp Op.IAdd ),
109                  (BV.add_tt,             tensorEinOp EinOp.addTensor),                  (BV.add_tt,             fn (y, [shp], xs) => let
110                  (BV.add_ff,             fn (y, [_,NK,SK], xs)=> singleField(SK,EinOp.addField, [NK,NK], y, xs)),                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
111                  (BV.add_fr,             fn (y, [_,NK], xs)=>    scalarField(EinOp.addTenField,[NK],y, xs)),                                          val rator =mk.addTT(dd1)
                 (BV.add_rf,             fn (y, [_,NK], [s, f])=>scalarField(EinOp.addTenField,[NK],y,[f,s])),  
                 (BV.sub_ii,              simpleOp Op.ISub ),  
                 (BV.sub_tt,             tensorEinOp EinOp.subTensor),  
                 (BV.sub_ff,             fn (y, [_,NK,SK], xs)=>singleField(SK,EinOp.subField, [NK,NK],y,xs)),  
                 (BV.sub_fr,             fn (y, [_,NK], xs) =>     scalarField(EinOp.subField,[NK], y,xs)),  
                 (BV.sub_rf,             fn (y, [_,NK], [s, f]) => scalarField(EinOp.subField,[NK], y,[f, s])),  
   
                 (* CHANGE create negative subtraction*)  
                 (BV.mul_ii,             simpleOp Op.IMul),  
                 (BV.mul_rr,             fn (y,_,args)=>  
                             assignEin(y, EinOp.prodScalar,args)),  
   
                 (BV.mul_rt,             tensorEinOp EinOp.scaleTensor),  
                 (BV.mul_tr,             fn (y, [SK], [t, r])=>let  
                                          val ty1 as DstTy.TensorTy dd1 = pruneShape SK  
                                             val rator =S.transform(EinOp.scaleTensor,[dd1],[])  
112                                          in                                          in
113                                              assignEin(y, rator,[r,t])                                              [assignEin(y, rator,xs)]
114                                          end),                                          end),
115                    (BV.add_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
116                                                [assignEin(y, mk.addFF(d, dd),xs)]),
117    
118                    (BV.add_ft,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f,s]) =>
119                                                [assignEin(y, mk.addTF(d,dd),[s,f])]),
120    
121                    (BV.add_tf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
122                (BV.mul_rf,             fn (y,[_,NK,SK], xs)=> singleField(SK,EinOp.scaleField,[NK],y, xs)),                                              [assignEin(y, mk.addTF(d,dd),xs)]),
123                    (BV.sub_ii,             simpleOp Op.ISub),
124                    (BV.sub_tt,             fn (y, [shp], xs) => let
125                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
126                  (BV.mul_fr,             fn (y, [_,NK,SK], [f, s])=> singleField(SK,EinOp.scaleField, [NK],y,[s,f])),                                          val rator =mk.subTT dd1
127                                            in
128                                                [assignEin(y, rator,xs)]
129                                            end),
130                    (BV.sub_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
131                                                  [assignEin(y, mk.subFF(d, dd),xs)]),
132                    (BV.sub_ft,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [x1,x2]) =>
133                                                [assignEin(y, mk.subFT(d,dd),[x2,x1])]),
134                    (BV.sub_tf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
135                                                    [assignEin(y, mk.subTF(d,dd),xs)]),
136                    (BV.mul_ii,             simpleOp Op.IMul),
137                    (BV.mul_rr,             fn (y,_,args) => [assignEin(y, mk.mulRR,args)]),
138                    (BV.mul_rt,             fn (y, [shp], xs) => let
139                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
140                                            val rator =mk.mulRT(dd1)
141                                            in
142                                                [assignEin(y, rator,xs)]
143                                            end),
144                    (BV.mul_tr,             fn (y, [shp], [t, r]) => let
145                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
146                                              val rator = mk.mulRT dd1
147                                              in
148                                                [assignEin(y, rator,[r,t])]
149                                              end),
150                    (BV.mul_rf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
151                                                [assignEin(y, mk.mulRF(d, dd),xs)]),
152                    (BV.mul_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f, s]) =>
153                                                [assignEin(y, mk.mulRF(d, dd),[s,f])]),
154                    (BV.mul_ss,             fn (y, [_,Ty.DIM d], xs) =>
155                                            [assignEin(y, mk.mulSS d,xs)]),
156                    (BV.mul_sf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
157                                                [assignEin(y, mk.mulSF(d,dd),xs)]),
158                    (BV.mul_fs,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [s,f]) =>
159                                            [assignEin(y, mk.mulSF(d,dd),[f,s])]),
160                  (BV.div_ii,             simpleOp Op.IDiv),                  (BV.div_ii,             simpleOp Op.IDiv),
161                  (BV.div_rr,              fn (y,_,args)=>                  (BV.div_rr,             fn (y,_,args) => [assignEin(y, mk.divRR,args)]),
162                              assignEin(y, EinOp.divScalar,args)),                  (BV.div_tr,             fn (y, [shp], xs) => let
163                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
164                 (BV.div_tr,             tensorEinOp EinOp.divideTensor),                                          val rator =mk.divTR dd1
165                                            in
166                  (BV.div_fr,             fn (y, [_,NK,SK], xs) =>singleField(SK,EinOp.divideField, [NK],y, xs)),                                              [assignEin(y, rator,xs)]
167                                            end),
168                    (BV.div_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
169                                                [assignEin(y, mk.divFR(d, dd),xs)]),
170                    (BV.div_fs,             fn (y, [_,_,Ty.DIM d, Ty.SHAPE dd], xs) =>
171                                            [assignEin(y, mk.divFS(d, dd),xs)]),
172                    (BV.div_ss,             fn (y, [_,Ty.DIM d], xs) =>
173                                                [assignEin(y, mk.divSS d,xs)]),
174                  (BV.exp_ri,             simpleOp(Op.Power)),                  (BV.exp_ri,             simpleOp(Op.Power)),
175                  (BV.exp_rr,             basisFn MathFuns.pow),                  (BV.exp_rr,             basisFn MathFuns.pow),
176                  (BV.curl2D,             simpleEinOp EinOp.Curl2d),                  (BV.curl2D,              simpleEOp mk.curl2d),
177                  (BV.curl3D,             simpleEinOp EinOp.Curl3d),                  (BV.curl3D,              simpleEOp mk.curl3d),
178                  (BV.convolve_vk,        fn (y, [_, NK, SK], xs) => singleField(SK,EinOp.conv, [NK],y,xs)),                  (BV.convolve_vk,        fn (y, [_, Ty.DIM d,  Ty.SHAPE dd], xs) =>
179                  (BV.convolve_kv,        fn (y, [_, NK, SK], [k, v]) =>singleField(SK,EinOp.conv, [NK],y,[v,k])),                                             [assignEin(y, mk.conv(d, dd),xs)]),
180                    (BV.convolve_kv,        fn (y, [_, Ty.DIM d,  Ty.SHAPE dd], [k, v]) =>
181                                                 [assignEin(y, mk.conv(d, dd),[v,k])]),
182                  (BV.neg_i,              simpleOp Op.INeg),                  (BV.neg_i,              simpleOp Op.INeg),
183                  (BV.neg_t,              tensorEinOp EinOp.negTensor),                  (BV.neg_t,              fn (y, [shp], xs) => let
184                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
185                                            val rator =mk.negTT dd1
186                  (BV.neg_f,              fn (y, [_,NK,SK], xs) => singleField(SK,EinOp.negField, [NK],y,xs)),                                          in
187                                                [assignEin(y, rator,xs)]
                 (BV.op_probe,           fn (y, [_, NK, SK], xs) =>  
                                         let  
                                             val dv=dimVarToTensor NK  (*Field*)  
                                             val sv=shapeVarToTensor SK (*Position*)  
                                             val dv'=peelFieldSK dv  
                                             val sv'=peelFieldSK sv  
                                             val einop= S.transform(EinOp.probe,[sv',dv'],[2])  
                                         in assignEin(y, einop,xs)  
188                                          end),                                          end),
189                  (BV.op_D,               fn (y, [_, NK], xs) => scalarField(EinOp.Grad,[NK], y,xs)),                  (BV.neg_f,              fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
190                  (BV.op_Dotimes,         fn (y, [_, NK, SK, NK2], xs) => singleField(SK,EinOp.Divergence,[NK], y,xs)),                                          [assignEin(y, mk.negFF(d, dd),xs)]),
191                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                  (BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
192                                                [assignEin(y, (mk.probe(dd,d)),xs)]),
193                    (BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>  (case d
194                                                of 2=>[assignEin(y, mk.grad([d]),xs)]
195                                                |  3=>[assignEin(y, mk.grad([d]),xs)]
196                                                | _ => raise Fail "unsupported gradient"
197                                                (*end case*))),
198                    (BV.op_Dotimes,         fn (y, [_, Ty.DIM d1, Ty.SHAPE dd, Ty.DIM d2], xs) =>
199                                                [assignEin(y, mk.dotimes(d1, dd@[d2]),xs)]),
200                    (BV.op_Ddot,         fn (y, [_, Ty.DIM d1,  Ty.SHAPE dd, Ty.DIM d2], xs) =>
201                                            [assignEin(y, mk.divergence(d1, dd),xs)] ),
202                    (BV.op_norm_tt,            fn (y, [sv], xs) => let
203                                                val ty=shapeVarToTensor sv
204                                                in (case shapeVarToTensor sv
205                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)
206                                              | ty => assign(y, Op.Norm ty, xs)                                                  | DstTy.TensorTy [_]    => assign(y, Op.Norm ty, xs)
207                                                    | DstTy.TensorTy[_,_]   => assign(y, Op.Norm ty, xs)
208                                                    | DstTy.TensorTy[_,_,_] => assign(y, Op.Norm ty, xs)
209                                                    | _ => raise Fail"unsupported norm of TensorTy"
210                                                    (* end case *))
211                                                end),
212                    (BV.op_norm_ff,            fn (y, [ _,Ty.DIM d1, Ty.SHAPE dd], xs) => (case dd
213                                                of []  =>  [assignEin(y, mk.magnitudeFF(d1, dd),xs)]
214                                                | [i]  =>  [assignEin(y, mk.magnitudeFF(d1, dd),xs@xs)]
215                                                | _ => raise Fail"unsupported norm of fieldTy"
216                                            (* end case *))),                                            (* end case *))),
   
217                 (BV.op_not,             simpleOp Op.Not),                 (BV.op_not,             simpleOp Op.Not),
218                  (BV.op_cross,           simpleEinOp EinOp.crossProduct),                  (BV.op_cross3_tt,           simpleEOp mk.cross3TT),
219                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let                  (BV.op_cross2_tt,          simpleEOp mk.cross2TT),
220                                              val d1 = [pruneDim(MV.toDim dv1)]                  (BV.op_cross2_ff,       simpleEOp mk.cross2FF),
221                                              val d2 = [pruneDim(MV.toDim dv2)]                  (BV.op_cross3_ff,       simpleEOp mk.cross3FF),
222                                            in                  (BV.op_outer_tt,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
223                                              assignEin( y, S.transform(EinOp.outerProduct,[d1,d2],[]),xs)                                              [assignEin(y, (mk.outerTT(d1, d2)), xs)]),
224                                            end),                  (BV.op_outer_ff,      fn (y, [_, Ty.DIM d1], xs)=>
225                  (BV.op_inner,        fn (y, [sh1, sh2, _], xs) =>                                              [assignEin(y, mk.outerFF d1,   xs)]),
226                                              let                  (BV.op_inner_tt,           fn (y, [sh1, sh2, _], xs) => let
227                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
228                                                  val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                              val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
                                                 val alpha= List.take(dd1, length(dd1)-1)  
                                                 val beta=  tl(dd2)  
                                                 val i =hd(dd2)  
                                                 val ilist=  [alpha, beta, [i]]  
229                                            in                                            in
230                                              assignEin(y, S.transform(EinOp.innerProduct, ilist,[]),xs)                                              [assignEin(y, (mk.innerTT(dd1,dd2)),xs)]
231                                          end),                                          end),
232    
233                  (BV.op_colon,         fn (y, [sh1, sh2, _], xs) =>                  (BV.op_inner_ff,      fn (y,  [_,_,Ty.SHAPE dd1,Ty.DIM d,Ty.SHAPE dd2,_], xs) =>
234                                              let                                              [assignEin(y, mk.innerFF(dd1,d,dd2),xs)]),
235                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape sh1  
236                                                  val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                  (BV.op_inner_ft,      fn (y,  [_,Ty.DIM d,Ty.SHAPE dd1,_,_], xs) =>
237                                                  val m= List.take(dd2,2)                                                  [assignEin(y, mk.cross3FF,xs)]),
238                                                  val i=hd(m)  
239                                                  val j=tl(m)                  (BV.op_colon_tt,           fn (y, [sh1, sh2, _], xs) => let
240                                                  val alpha= List.take(dd1, length(dd1)-2)                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
241                                                  val beta=tl(tl(dd2))                                              val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
                                                 val ilist=[alpha, beta, [i], j]  
242                                              in                                              in
243                                                  assignEin(y, S.transform(EinOp.doubleDot, ilist,[]),xs)                                              [assignEin(y, (mk.colonTT(dd1,dd2)),xs)]
244                                              end),                                              end),
245                    (BV.op_colon_ff,       fn (y, [_,Ty.SHAPE dd1,_,Ty.SHAPE dd2, _], xs) =>
246                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>                                              [assignEin(y, (mk.colonFF(dd1,dd2)),xs)]),
247                                            assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),                  (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) => assign(y, Op.Inside d, xs)),
248                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
249                  (BV.clamp_vvv,          vectorOp Op.Clamp),                  (BV.clamp_vvv,          vectorOp Op.Clamp),
250                  (BV.lerp3,              tensorOp Op.Lerp),                  (BV.lerp3,              tensorOp Op.Lerp),
251                  (BV.lerp5,         fn (y, [sv], [a, b, x0, x, x1]) =>let                  (BV.lerp5,         fn (y, [sv], [a, b, x0, x, x1]) =>let
                     (*assignEin(y, EinOp.subScalar,[x,x0])),*)  
   
252                                            val t1 = IL.Var.new("t1", DstTy.realTy)                                            val t1 = IL.Var.new("t1", DstTy.realTy)
253                                            val t2 = IL.Var.new("t2", DstTy.realTy)                                            val t2 = IL.Var.new("t2", DstTy.realTy)
254                                            val t3 = IL.Var.new("t3", DstTy.realTy)                                            val t3 = IL.Var.new("t3", DstTy.realTy)
255                                            in [                                            in [
256                                              assignEin2(t1, EinOp.subScalar,[x,x0]),                                              assignEin(t1, mk.subRR,[x,x0]),
257                                              assignEin2(t2, EinOp.subScalar,[x1,x0]),                                              assignEin(t2, mk.subRR,[x1,x0]),
258                                              assignEin2(t3, EinOp.divScalar,[t1,t2]),                                              assignEin(t3, mk.divRR,[t1,t2]),
   
259                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))
260                                            ] end),                                            ] end),
261                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),
262                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),
263                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),
264                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),
                 (BV.fn_max,             simpleOp Op.Max),  
                 (BV.fn_min,             simpleOp Op.Min),  
                 (BV.fn_modulate,         fn (y, _, xs) => assign (y, Op.IMul, xs)),  
                 (BV.fn_normalize,       vectorOp Op.Normalize),  
                 (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),  
265    
                (BV.fn_trace,           fn (y, [dv], xs) =>let  
                                             val d=dimVarToInt dv  
                                         in  
                                             assignEin(y,S.transform(EinOp.trace, [[d]],[]),xs)  
                                         end),  
266    
267                  (BV.fn_transpose,           fn (y, [dv1, dv2], xs) =>                  (BV.fn_max,             simpleOp Op.Max),
268                                          let                  (BV.fn_min,             simpleOp Op.Min),
                                             val d1=dimVarToInt dv1  
                                             val d2=dimVarToInt dv2  
                                         in  
                                             assignEin(y,S.transform(EinOp.transpose, [[d1],[d2]],[]),xs)  
                                         end),  
269    
270                    (*  modulate is vector * vector pointwise multiplication *)
271                    (BV.fn_modulate,        fn (y,[Ty.DIM dd1], xs) =>
272                                    [assignEin(y, (mk.modulate dd1),xs)]),
273                    (BV.fn_normalize_tt,   vectorOp Op.Normalize),
274                    (BV.fn_normalize_ff,             fn (y, [ _,Ty.DIM d1, Ty.SHAPE dd], xs) =>
275                        (case dd
276                            of [] => [assignEin(y, mk.normalizeFF(d1, []),xs)]
277                            | [i] => [assignEin(y, mk.normalizeFF(d1, [i]),xs@xs)]
278                            | _ => raise Fail"unsupported normalized of fieldTy"
279                        (* end case *))),
280                    (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
281                    (BV.fn_trace_t,           fn (y, [Ty.DIM d], xs) =>
282                                              [assignEin(y,(mk.traceT d), xs)]),
283                    (BV.fn_trace_f,           fn (y, [_,Ty.DIM d,Ty.SHAPE dd], xs) =>
284                            [assignEin(y,mk.traceF(d,dd), xs)]),
285                    (BV.fn_transpose_t,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
286                                              [assignEin(y, (mk.transposeT [d1,d2]), xs)]),
287                    (BV.fn_transpose_f,  fn (y, [_,Ty.DIM d1, Ty.DIM d2,Ty.DIM d3], xs) =>
288                        [assignEin(y, (mk.transposeF (d1,d2,d3)), xs)]),
289                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
290                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
291                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
# Line 315  Line 294 
294                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
295                  (BV.kn_c1tent,          kernel Kernel.tent),                  (BV.kn_c1tent,          kernel Kernel.tent),
296                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
297                    (BV.identity,           fn (y, [Ty.DIM d], xs) =>
298                  (BV.identity,           fn (y, [dv], xs) =>let                                            [assignEin(y, (mk.identity d), xs)]),
299                                              val d=dimVarToInt dv                 (BV.zero,               fn (y, [sv], []) =>
300                                          in assignEin(y, S.transform(EinOp.identity,[[d],[d]],[]),xs)                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),
301                                          end),                  (BV.subscript,          fn (y, [ty, Ty.DIM d], xs) =>
302                                              assign (y, Op.SeqSub(DstTy.SeqTy(trType ty, d)), xs))
              (*   (BV.zero,               fn (y, [sv], []) =>  
                                           assign(y, Op.Zero(shapeVarToTensor sv), [])),*)  
                (BV.subscript,          fn (y, [tv, dv], xs) =>  
                                           assign(y,  
                                             Op.SeqSub(DstTy.SeqTy(pruneTy tv, pruneDim(MV.toDim dv))),  
                                             xs))  
   
   
303              (*,              (*,
   
304              (BV.dynSubscript,       fn (y, [tv], args) =>              (BV.dynSubscript,       fn (y, [tv], args) =>
305                                          assign(y, Op.SeqSub(DstTy.DynSeqTy(pruneTy tv)), args))*)                                            assign(y, Op.SeqSub(DstTy.DynSeqTy(pruneTy tv)), args))
306    *)
307                  ];                  ];
   
308            (* add C math functions *)            (* add C math functions *)
309              List.app (fn (n, x) => insert(x, basisFn n)) BV.mathFns;              List.app (fn (n, x) => insert(x, basisFn n)) BV.mathFns;
310              tbl              tbl

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

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