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 2490, Mon Oct 21 21:17:25 2013 UTC revision 2955, Wed Mar 4 23:06:28 2015 UTC
# Line 23  Line 23 
23      structure Op = HighOps      structure Op = HighOps
24      structure Ty = SimpleTypes      structure Ty = SimpleTypes
25      structure VTbl = Var.Tbl      structure VTbl = Var.Tbl
26      structure EinOp = Operators      structure mk= mkOperators
     structure S = Specialize  
27    
28      fun trType (Ty.TY ty) = TranslateTy.tr ty      fun trType (Ty.TY ty) = TranslateTy.tr ty
29        | trType _ = raise Fail "expected type"        | trType _ = raise Fail "expected type"
# Line 51  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 71  Line 77 
77                  end                  end
78            end            end
79    
80      fun assignEin (y, rator, xs) = [IL.ASSGN(y, IL.EINAPP(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))  
81    
82      fun simpleEinOp rator (y, _,xs) = assignEin(y, rator, xs)      fun  simpleEOp 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    
# Line 133  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)]
188                  (BV.op_probe,           fn (y, [_, NK, SK], xs) =>                                          end),
189                                          let                  (BV.neg_f,              fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
190                                              val dv=dimVarToTensor NK  (*Field*)                                          [assignEin(y, mk.negFF(d, dd),xs)]),
191                                              val sv=shapeVarToTensor SK (*Position*)                  (BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
192                                              val dv'=peelFieldSK dv                                              [assignEin(y, (mk.probe(dd,d)),xs)]),
193                                              val sv'=peelFieldSK sv                  (BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>  (case d
194                                              val einop= S.transform(EinOp.probe,[sv',dv'],[2])                                              of 2=>[assignEin(y, mk.grad([d]),xs)]
195                                          in assignEin(y, einop,xs)                                              |  3=>[assignEin(y, mk.grad([d]),xs)]
196                                          end),                                              | _ => raise Fail "unsupported gradient"
197                  (BV.op_D,               fn (y, [_, NK], xs) => scalarField(EinOp.Grad,[NK], y,xs)),                                              (*end case*))),
198                  (BV.op_Dotimes,         fn (y, [_, NK, SK, NK2], xs) => singleField(SK,EinOp.Divergence,[NK], y,xs)),                  (BV.op_Dotimes,         fn (y, [_, Ty.DIM d1, Ty.SHAPE dd, Ty.DIM d2], xs) =>
199                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                                              [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_t,            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_f,            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
229                                                  val alpha= List.take(dd1, length(dd1)-1)                                          in
230                                                  val beta=  tl(dd2)                                              [assignEin(y, (mk.innerTT(dd1,dd2)),xs)]
231                                                  val i =hd(dd2)                                          end),
232                                                  val ilist=  [alpha, beta, [i]]  
233                                            in                  (BV.op_inner_tf,      fn (y,  [_,Ty.DIM d,sh1,Ty.SHAPE dd2,_], xs) =>let
234                                              assignEin(y, S.transform(EinOp.innerProduct, ilist,[]),xs)                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
235                                          end),                                          in
236                                                    [assignEin(y, mk.innerTF(dd1,d,dd2),xs)]
237                  (BV.op_colon,         fn (y, [sh1, sh2, _], xs) =>                                          end ),
238                                              let                  (BV.op_inner_ft,      fn (y,  [_,Ty.DIM d,Ty.SHAPE dd1,sh2,_], xs) =>let
239                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                              val ty1 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
                                                 val ty2 as DstTy.TensorTy dd2 = pruneShape sh2  
                                                 val m= List.take(dd2,2)  
                                                 val i=hd(m)  
                                                 val j=tl(m)  
                                                 val alpha= List.take(dd1, length(dd1)-2)  
                                                 val beta=tl(tl(dd2))  
                                                 val ilist=[alpha, beta, [i], j]  
240                                              in                                              in
241                                                  assignEin(y, S.transform(EinOp.doubleDot, ilist,[]),xs)                                                  [assignEin(y, mk.innerFT(dd1,d,dd2),xs)]
242                                              end),                                              end),
243    
244                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>                  (BV.op_inner_ff,      fn (y,  [_,_,Ty.DIM d,Ty.SHAPE dd1,Ty.SHAPE dd2,_], xs) =>
245                                            assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),                                              [assignEin(y, mk.innerFF(dd1,d,dd2),xs)]),
246    
247                    (BV.op_colon_tt,           fn (y, [sh1, sh2, _], xs) => let
248                                                val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
249                                                val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
250                                            in
251                                                [assignEin(y, (mk.colonTT(dd1,dd2)),xs)]
252                                            end),
253                    (BV.op_colon_ff,       fn (y, [_,Ty.SHAPE dd1,_,Ty.SHAPE dd2, _], xs) =>
254                                                [assignEin(y, (mk.colonFF(dd1,dd2)),xs)]),
255                    (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) => assign(y, Op.Inside d, xs)),
256                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
257                  (BV.clamp_vvv,          vectorOp Op.Clamp),                  (BV.clamp_vvv,          vectorOp Op.Clamp),
258                  (BV.lerp3,              tensorOp Op.Lerp),                  (BV.lerp3,              tensorOp Op.Lerp),
259                  (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])),*)  
   
260                                            val t1 = IL.Var.new("t1", DstTy.realTy)                                            val t1 = IL.Var.new("t1", DstTy.realTy)
261                                            val t2 = IL.Var.new("t2", DstTy.realTy)                                            val t2 = IL.Var.new("t2", DstTy.realTy)
262                                            val t3 = IL.Var.new("t3", DstTy.realTy)                                            val t3 = IL.Var.new("t3", DstTy.realTy)
263                                            in [                                            in [
264                                              assignEin2(t1, EinOp.subScalar,[x,x0]),                                              assignEin(t1, mk.subRR,[x,x0]),
265                                              assignEin2(t2, EinOp.subScalar,[x1,x0]),                                              assignEin(t2, mk.subRR,[x1,x0]),
266                                              assignEin2(t3, EinOp.divScalar,[t1,t2]),                                              assignEin(t3, mk.divRR,[t1,t2]),
   
267                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))
268                                            ] end),                                            ] end),
269                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),
270                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),
271                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),
272                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),
273    
274    
275                  (BV.fn_max,             simpleOp Op.Max),                  (BV.fn_max,             simpleOp Op.Max),
276                  (BV.fn_min,             simpleOp Op.Min),                  (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),  
277    
278                  (BV.fn_trace,           fn (y, [dv], xs) => let                  (*  modulate is vector * vector pointwise multiplication *)
279                                              val d=dimVarToInt dv                  (BV.fn_modulate,        fn (y,[Ty.DIM dd1], xs) =>
280                                          in                                  [assignEin(y, (mk.modulate dd1),xs)]),
281                                              assignEin(y,S.transform(EinOp.trace, [[d]],[]),xs)                  (BV.fn_normalize_t,   vectorOp Op.Normalize),
282                                          end),                  (BV.fn_normalize_f,             fn (y, [ _,Ty.DIM d1, Ty.SHAPE dd], xs) =>
283                  (BV.fn_transpose,       fn (y, [dv1, dv2], xs) => let                      (case dd
284                                              val d1=dimVarToInt dv1                          of [] => [assignEin(y, mk.normalizeFF(d1, []),xs)]
285                                              val d2=dimVarToInt dv2                          | [i] => [assignEin(y, mk.normalizeFF(d1, [i]),xs@xs)]
286                                          in                          | _ => raise Fail"unsupported normalized of fieldTy"
287                                              assignEin(y,S.transform(EinOp.transpose, [[d1],[d2]],[]),xs)                      (* end case *))),
288                                          end),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
289                    (BV.fn_trace_t,           fn (y, [Ty.DIM d], xs) =>
290                                              [assignEin(y,(mk.traceT d), xs)]),
291                    (BV.fn_trace_f,           fn (y, [_,Ty.DIM d,Ty.SHAPE dd], xs) =>
292                            [assignEin(y,mk.traceF(d,dd), xs)]),
293                    (BV.fn_transpose_t,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
294                                              [assignEin(y, (mk.transposeT [d1,d2]), xs)]),
295                    (BV.fn_transpose_f,  fn (y, [_,Ty.DIM d1, Ty.DIM d2,Ty.DIM d3], xs) =>
296                        [assignEin(y, (mk.transposeF (d1,d2,d3)), xs)]),
297                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
298                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
299                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
# Line 280  Line 302 
302                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
303                  (BV.kn_c1tent,          kernel Kernel.tent),                  (BV.kn_c1tent,          kernel Kernel.tent),
304                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
305                  (BV.identity,           fn (y, [dv], xs) =>let                  (BV.identity,           fn (y, [Ty.DIM d], xs) =>
306                                              val d=dimVarToInt dv                                            [assignEin(y, (mk.identity d), xs)]),
307                                          in assignEin(y, S.transform(EinOp.identity,[[d],[d]],[]),xs)                 (BV.zero,               fn (y, [sv], []) =>
308                                          end),                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),
309               (*   (BV.zero,               fn (y, [sv], []) =>                  (BV.subscript,          fn (y, [ty, Ty.DIM d], xs) =>
310                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),*)                                            assign (y, Op.SeqSub(DstTy.SeqTy(trType ty, d)), xs))
                 (BV.subscript,          fn (y, [tv, dv], xs) =>  
                                           assign(y,  
                                             Op.SeqSub(DstTy.SeqTy(pruneTy tv, pruneDim(MV.toDim dv))),  
                                             xs))  
311  (*,  (*,
312                    (BV.dynSubscript,     fn (y, [tv], args) =>                    (BV.dynSubscript,     fn (y, [tv], args) =>
313                                            assign(y, Op.SeqSub(DstTy.DynSeqTy(pruneTy tv)), args))                                            assign(y, Op.SeqSub(DstTy.DynSeqTy(pruneTy tv)), args))

Legend:
Removed from v.2490  
changed lines
  Added in v.2955

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