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 2492, Tue Oct 22 15:25:50 2013 UTC revision 2922, Tue Mar 3 03:55:09 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, [shp], xs) = let  
           val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp  
           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)
112                  (BV.add_rf,             fn (y, [_,NK], [s, f]) => scalarField(EinOp.addTenField,[NK],y,[f,s])),                                          in
113                                                [assignEin(y, rator,xs)]
114                                            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                                                [assignEin(y, mk.addTF(d,dd),xs)]),
123                  (BV.sub_ii,             simpleOp Op.ISub),                  (BV.sub_ii,             simpleOp Op.ISub),
124                  (BV.sub_tt,             tensorEinOp EinOp.subTensor),                  (BV.sub_tt,             fn (y, [shp], xs) => let
125                  (BV.sub_ff,             fn (y, [_,NK,SK], xs) => singleField(SK,EinOp.subField, [NK,NK],y,xs)),                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
126                  (BV.sub_fr,             fn (y, [_,NK], xs) => scalarField(EinOp.subField,[NK], y,xs)),                                          val rator =mk.subTT dd1
127                  (BV.sub_rf,             fn (y, [_,NK], [s, f]) => scalarField(EinOp.subField,[NK], y,[f, s])),                                          in
128                  (* CHANGE create negative subtraction*)                                              [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),                  (BV.mul_ii,             simpleOp Op.IMul),
137                  (BV.mul_rr,             fn (y,_,args) => assignEin(y, EinOp.prodScalar,args)),                  (BV.mul_rr,             fn (y,_,args) => [assignEin(y, mk.mulRR,args)]),
138                  (BV.mul_rt,             tensorEinOp EinOp.scaleTensor),                  (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                  (BV.mul_tr,             fn (y, [shp], [t, r]) => let
145                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
146                                            val rator = S.transform(EinOp.scaleTensor, [dd1], [])                                            val rator = mk.mulRT dd1
147                                            in                                            in
148                                              assignEin(y, rator,[r,t])                                              [assignEin(y, rator,[r,t])]
149                                            end),                                            end),
150                  (BV.mul_rf,             fn (y, [_,NK,SK], xs) => singleField(SK,EinOp.scaleField,[NK],y, xs)),                  (BV.mul_rf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
151                  (BV.mul_fr,             fn (y, [_,NK,SK], [f, s]) => singleField(SK,EinOp.scaleField, [NK],y,[s,f])),                                              [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) => assignEin(y, EinOp.divScalar,args)),                  (BV.div_rr,             fn (y,_,args) => [assignEin(y, mk.divRR,args)]),
162                  (BV.div_tr,             tensorEinOp EinOp.divideTensor),                  (BV.div_tr,             fn (y, [shp], xs) => let
163                  (BV.div_fr,             fn (y, [_,NK,SK], xs) => singleField(SK,EinOp.divideField, [NK],y, xs)),                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
164                                            val rator =mk.divTR dd1
165                                            in
166                                                [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                  (BV.neg_f,              fn (y, [_,NK,SK], xs) => singleField(SK,EinOp.negField, [NK],y,xs)),                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
185                  (BV.op_probe,           fn (y, [_, NK, SK], xs) => let                                          val rator =mk.negTT dd1
186                                            val dv=dimVarToTensor NK  (*Field*)                                          in
187                                            val sv=shapeVarToTensor SK (*Position*)                                              [assignEin(y, rator,xs)]
188                                            val dv'=peelFieldSK dv                                          end),
189                                            val sv'=peelFieldSK sv                  (BV.neg_f,              fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
190                                            val einop= S.transform(EinOp.probe,[sv',dv'],[2])                                          [assignEin(y, mk.negFF(d, dd),xs)]),
191                                            in                  (BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
192                                              assignEin(y, einop,xs)                                              [assignEin(y, (mk.probe(dd,d)),xs)]),
193                                            end),                  (BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>  (case d
194                  (BV.op_D,               fn (y, [_, NK], xs) => scalarField(EinOp.Grad,[NK], y,xs)),                                              of 2=>[assignEin(y, mk.grad([d]),xs)]
195                  (BV.op_Dotimes,         fn (y, [_, NK, SK, NK2], xs) => singleField(SK,EinOp.Divergence,[NK], y,xs)),                                              |  3=>[assignEin(y, mk.grad([d]),xs)]
196                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                                              | _ => 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, [Ty.DIM d1, Ty.DIM d2], xs) =>                  (BV.op_cross2_tt,          simpleEOp mk.cross2TT),
220  (* CHECK: should it be [[d1], [d2]]? *)                  (BV.op_cross2_ff,       simpleEOp mk.cross2FF),
221                                            assignEin(y, S.transform(EinOp.outerProduct, [[d1, d2]], []), xs)),                  (BV.op_cross3_ff,       simpleEOp mk.cross3FF),
222                  (BV.op_inner,           fn (y, [sh1, sh2, _], xs) => let                  (BV.op_outer_tt,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
223                                                [assignEin(y, (mk.outerTT(d1, d2)), xs)]),
224                    (BV.op_outer_ff,      fn (y, [_, Ty.DIM d1], xs)=>
225                                                [assignEin(y, mk.outerFF d1,   xs)]),
226                    (BV.op_inner_tt,           fn (y, [sh1, sh2, _], xs) => let
227                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
228                                            val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor 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                  (BV.op_colon,           fn (y, [sh1, sh2, _], xs) => let  
233                    (BV.op_inner_ff,      fn (y,  [_,_,Ty.SHAPE dd1,Ty.DIM d,Ty.SHAPE dd2,_], xs) =>
234                                                [assignEin(y, mk.innerFF(dd1,d,dd2),xs)]),
235    
236                    (BV.op_inner_ft,      fn (y,  [_,Ty.DIM d,Ty.SHAPE dd1,_,_], xs) =>
237                                                    [assignEin(y, mk.cross3FF,xs)]),
238    
239                    (BV.op_colon_tt,           fn (y, [sh1, sh2, _], xs) => let
240                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
241                                            val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2                                            val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
                                           val i::j::beta = dd2  
                                           val alpha = List.take(dd1, length(dd1)-2)  
                                           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                                                [assignEin(y, (mk.colonFF(dd1,dd2)),xs)]),
247                  (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) => assign(y, Op.Inside d, 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)),
265    
266    
267                  (BV.fn_max,             simpleOp Op.Max),                  (BV.fn_max,             simpleOp Op.Max),
268                  (BV.fn_min,             simpleOp Op.Min),                  (BV.fn_min,             simpleOp Op.Min),
269  (* FIXME: modulate is vector * vector pointwise multiplication *)  
270                  (BV.fn_modulate,        fn (y, _, xs) => assign (y, Op.IMul, xs)),                  (*  modulate is vector * vector pointwise multiplication *)
271                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (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),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
281                  (BV.fn_trace,           fn (y, [Ty.DIM d], xs) =>                  (BV.fn_trace_t,           fn (y, [Ty.DIM d], xs) =>
282                                            assignEin(y,S.transform(EinOp.trace, [[d]],[]), xs)),                                            [assignEin(y,(mk.traceT d), xs)]),
283                  (BV.fn_transpose,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>                  (BV.fn_trace_f,           fn (y, [_,Ty.DIM d,Ty.SHAPE dd], xs) =>
284                                            assignEin(y, S.transform(EinOp.transpose, [[d1],[d2]],[]), xs)),                          [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 244  Line 295 
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) =>                  (BV.identity,           fn (y, [Ty.DIM d], xs) =>
298                                            assignEin(y, S.transform(EinOp.identity, [[d],[d]],[]), xs)),                                            [assignEin(y, (mk.identity d), xs)]),
299               (*   (BV.zero,               fn (y, [sv], []) =>                 (BV.zero,               fn (y, [sv], []) =>
300                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),*)                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),
301                  (BV.subscript,          fn (y, [ty, Ty.DIM d], xs) =>                  (BV.subscript,          fn (y, [ty, Ty.DIM d], xs) =>
302                                            assign (y, Op.SeqSub(DstTy.SeqTy(trType ty, d)), xs))                                            assign (y, Op.SeqSub(DstTy.SeqTy(trType ty, d)), xs))
303  (*,  (*,

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

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