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 2611, Mon May 5 21:21:12 2014 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 mk= mkOperators      structure mk= mkOperators
27    
28      fun trType (Ty.TY ty) = TranslateTy.tr ty      fun trType (Ty.TY ty) = TranslateTy.tr ty
# 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 75  Line 81 
81    
82      fun  simpleEOp rator (y, _,xs) = [assignEin(y, rator, xs)]      fun  simpleEOp rator (y, _,xs) = [assignEin(y, rator, xs)]
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 *)
# Line 106  Line 108 
108                  (BV.add_ii,             simpleOp Op.IAdd),                  (BV.add_ii,             simpleOp Op.IAdd),
109                  (BV.add_tt,             fn (y, [shp], xs) => let                  (BV.add_tt,             fn (y, [shp], xs) => let
110                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
111                                          val rator =mk.addTen(dd1)                                          val rator =mk.addTT(dd1)
112                                          in                                          in
113                                              [assignEin(y, rator,xs)]                                              [assignEin(y, rator,xs)]
114                                          end),                                          end),
115                  (BV.add_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>                  (BV.add_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
116                                              [assignEin(y, mk.addField(d, dd),xs)]),                                              [assignEin(y, mk.addFF(d, dd),xs)]),
   
                 (BV.add_fr,             fn (y, [_,Ty.DIM d], [f,s]) =>  
                                             [assignEin(y, mk.addTenField(d),[s,f])]),  
   
                 (BV.add_rf,             fn (y, [_,Ty.DIM d], xs) =>  
                                             [assignEin(y, mk.addTenField(d),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,             fn (y, [shp], xs) => let                  (BV.sub_tt,             fn (y, [shp], xs) => let
125                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
126                                          val rator =mk.subTen(dd1)                                          val rator =mk.subTT dd1
127                                          in                                          in
128                                              [assignEin(y, rator,xs)]                                              [assignEin(y, rator,xs)]
129                                          end),                                          end),
130                  (BV.sub_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>                  (BV.sub_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
131                                                [assignEin(y, mk.subField(d, dd),xs)]),                                                [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_fr,             fn (y, [_,Ty.DIM d], xs) =>                  (BV.sub_tf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
135                                              [assignEin(y, mk.subFieldTen(d),xs)]),                                                  [assignEin(y, mk.subTF(d,dd),xs)]),
   
                 (BV.sub_rf,             fn (y, [_,Ty.DIM d], xs) =>  
                                           [assignEin(y, mk.subTenField(d),xs)]),  
   
136                  (BV.mul_ii,             simpleOp Op.IMul),                  (BV.mul_ii,             simpleOp Op.IMul),
137                  (BV.mul_rr,             fn (y,_,args) => [assignEin(y, mk.prodScalar,args)]),                  (BV.mul_rr,             fn (y,_,args) => [assignEin(y, mk.mulRR,args)]),
138                  (BV.mul_rt,             fn (y, [shp], xs) => let                  (BV.mul_rt,             fn (y, [shp], xs) => let
139                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
140                                          val rator =mk.scaleTen(dd1)                                          val rator =mk.mulRT(dd1)
141                                          in                                          in
142                                              [assignEin(y, rator,xs)]                                              [assignEin(y, rator,xs)]
143                                          end),                                          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 = mk.scaleTen 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, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>                  (BV.mul_rf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
151                                              [assignEin(y, mk.scaleField(d, dd),xs)]),                                              [assignEin(y, mk.mulRF(d, dd),xs)]),
152                  (BV.mul_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f, s]) =>                  (BV.mul_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f, s]) =>
153                                              [assignEin(y, mk.scaleField(d, dd),[s,f])]),                                              [assignEin(y, mk.mulRF(d, dd),[s,f])]),
 (*MARK-mul_ff*)  
154                  (BV.mul_ss,             fn (y, [_,Ty.DIM d], xs) =>                  (BV.mul_ss,             fn (y, [_,Ty.DIM d], xs) =>
155                                          [assignEin(y, mk.mulFieldss d,xs)]),                                          [assignEin(y, mk.mulSS d,xs)]),
156                  (BV.mul_sf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>                  (BV.mul_sf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
157                                              [assignEin(y, mk.mulFieldsf(d,dd),xs)]),                                              [assignEin(y, mk.mulSF(d,dd),xs)]),
158                  (BV.mul_fs,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f,s]) =>                  (BV.mul_fs,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [s,f]) =>
159                                          [assignEin(y, mk.mulFieldsf(d,dd),[s,f])]),                                          [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, mk.divScalar,args)]),                  (BV.div_rr,             fn (y,_,args) => [assignEin(y, mk.divRR,args)]),
162                  (BV.div_tr,             fn (y, [shp], xs) => let                  (BV.div_tr,             fn (y, [shp], xs) => let
163                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
164                                          val rator =mk.divTen(dd1)                                          val rator =mk.divTR dd1
165                                          in                                          in
166                                              [assignEin(y, rator,xs)]                                              [assignEin(y, rator,xs)]
167                                          end),                                          end),
168                  (BV.div_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>                  (BV.div_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
169                                              [assignEin(y, mk.divideField(d, dd),xs)]),                                              [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) =>                  (BV.div_ss,             fn (y, [_,Ty.DIM d], xs) =>
173                                              [assignEin(y, mk.divFieldss d,xs)]),                                              [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,              simpleEOp mk.curl2d),                  (BV.curl2D,              simpleEOp mk.curl2d),
# Line 187  Line 182 
182                  (BV.neg_i,              simpleOp Op.INeg),                  (BV.neg_i,              simpleOp Op.INeg),
183                  (BV.neg_t,              fn (y, [shp], xs) => let                  (BV.neg_t,              fn (y, [shp], xs) => let
184                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
185                                          val rator =mk.negTen(dd1)                                          val rator =mk.negTT dd1
186                                          in                                          in
187                                              [assignEin(y, rator,xs)]                                              [assignEin(y, rator,xs)]
188                                          end),                                          end),
189                  (BV.neg_f,              fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>                  (BV.neg_f,              fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
190                                          [assignEin(y, mk.negField(d, dd),xs)]),                                          [assignEin(y, mk.negFF(d, dd),xs)]),
191                  (BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>                  (BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
192                                              [assignEin(y, (mk.probe(dd,d)),xs)]),                                              [assignEin(y, (mk.probe(dd,d)),xs)]),
193                  (BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>  [assignEin(y, mk.grad([d]),xs)]),                  (BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>  (case d
194                                                of 2=>[assignEin(y, mk.grad([d]),xs)]
195                  (BV.op_Dotimes,         fn (y, [_, Ty.DIM d1, Ty.SHAPE dd, Ty.DIM d2], xs) => let                                              |  3=>[assignEin(y, mk.grad([d]),xs)]
196                                      val x= print (String.concat[" d1:",Int.toString(d1)," d2:",Int.toString(d2),                                              | _ => raise Fail "unsupported gradient"
197                                          " shape:",Int.toString(length(dd)), "\n"])                                              (*end case*))),
198                                          val g=print "*******\n"                  (BV.op_Dotimes,         fn (y, [_, Ty.DIM d1, Ty.SHAPE dd, Ty.DIM d2], xs) =>
199                                          val gg2=print(Int.toString(length(xs)))                                              [assignEin(y, mk.dotimes(d1, dd@[d2]),xs)]),
                         in  
                                     [assignEin(y, mk.dotimes(d1, dd@[d2]),xs)] end ),  
200                  (BV.op_Ddot,         fn (y, [_, Ty.DIM d1,  Ty.SHAPE dd, Ty.DIM d2], xs) =>                  (BV.op_Ddot,         fn (y, [_, Ty.DIM d1,  Ty.SHAPE dd, Ty.DIM d2], xs) =>
201                                          [assignEin(y, mk.divergence(d1, dd),xs)] ),                                          [assignEin(y, mk.divergence(d1, dd),xs)] ),
202                    (BV.op_norm_tt,            fn (y, [sv], xs) => let
203                                                val ty=shapeVarToTensor sv
204                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                                              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,            simpleEOp mk.crossProduct),                  (BV.op_cross3_tt,           simpleEOp mk.cross3TT),
219                  (BV.op_crossField,       simpleEOp mk.crossProductField),                  (BV.op_cross2_tt,          simpleEOp mk.cross2TT),
220                  (BV.op_outer,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>                  (BV.op_cross2_ff,       simpleEOp mk.cross2FF),
221                                              [assignEin(y, (mk.outerProduct(d1, d2)), xs)]),                  (BV.op_cross3_ff,       simpleEOp mk.cross3FF),
222  (* Any Shape fields                  (BV.op_outer_tt,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
223                   (BV.op_outerField,      fn (y, [_, Ty.DIM d1, Ty.SHAPE dd1, Ty.SHAPE dd2], xs)=>                                              [assignEin(y, (mk.outerTT(d1, d2)), xs)]),
224                                          [assignEin(y, mk.outerField(d1, dd1, dd2),   xs)]),                  (BV.op_outer_ff,      fn (y, [_, Ty.DIM d1], xs)=>
225  *)                                              [assignEin(y, mk.outerFF d1,   xs)]),
226                  (BV.op_outerField,      fn (y, [_, Ty.DIM d1], xs)=>                  (BV.op_inner_tt,           fn (y, [sh1, sh2, _], xs) => let
                                             [assignEin(y, mk.outerField(d1),   xs)]),  
   
   
                 (BV.op_inner,           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
229                                          in                                          in
230                                              [assignEin(y, (mk.innerProduct(dd1,dd2)),xs)]                                              [assignEin(y, (mk.innerTT(dd1,dd2)),xs)]
231                                          end),                                          end),
232    
233                  (BV.op_innerField,      fn (y,  [_,Ty.SHAPE dd1,Ty.DIM d,Ty.SHAPE dd2,_], xs) =>                  (BV.op_inner_ff,      fn (y,  [_,_,Ty.SHAPE dd1,Ty.DIM d,Ty.SHAPE dd2,_], xs) =>
234                                              [assignEin(y, mk.innerProductField(dd1,d,dd2),xs)]),                                              [assignEin(y, mk.innerFF(dd1,d,dd2),xs)]),
235                  (BV.op_colon,           fn (y, [sh1, sh2, _], xs) => let  
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
242                                          in                                          in
243                                              [assignEin(y, (mk.doubleDot(dd1,dd2)),xs)]                                              [assignEin(y, (mk.colonTT(dd1,dd2)),xs)]
244                                          end),                                          end),
245                  (BV.op_colonField,       fn (y, [_,Ty.SHAPE dd1,_,Ty.SHAPE dd2, _], xs) =>                  (BV.op_colon_ff,       fn (y, [_,Ty.SHAPE dd1,_,Ty.SHAPE dd2, _], xs) =>
246                                              [assignEin(y, (mk.doubleDotField(dd1,dd2)),xs)]),                                              [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),
# Line 251  Line 253 
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                                              assignEin(t1, mk.subScalar,[x,x0]),                                              assignEin(t1, mk.subRR,[x,x0]),
257                                              assignEin(t2, mk.subScalar,[x1,x0]),                                              assignEin(t2, mk.subRR,[x1,x0]),
258                                              assignEin(t3, mk.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    
270                  (*  modulate is vector * vector pointwise multiplication *)                  (*  modulate is vector * vector pointwise multiplication *)
271                  (BV.fn_modulate,        fn (y,[Ty.DIM dd1], xs) =>                  (BV.fn_modulate,        fn (y,[Ty.DIM dd1], xs) =>
272                                  [assignEin(y, (mk.modulate dd1),xs)]),                                  [assignEin(y, (mk.modulate dd1),xs)]),
273                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (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,(mk.trace d), xs)]),                                            [assignEin(y,(mk.traceT d), xs)]),
283                  (BV.fn_traceField,           fn (y, [_,Ty.DIM d,Ty.SHAPE dd], xs) =>                  (BV.fn_trace_f,           fn (y, [_,Ty.DIM d,Ty.SHAPE dd], xs) =>
284                          [assignEin(y,mk.traceField(d,dd), xs)]),                          [assignEin(y,mk.traceF(d,dd), xs)]),
285                    (BV.fn_transpose_t,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
286                  (BV.fn_transpose,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>                                            [assignEin(y, (mk.transposeT [d1,d2]), xs)]),
287                                            [assignEin(y, (mk.transpose [d1,d2]), xs)]),                  (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)]),
                 (BV.fn_transposeField,  fn (y, [_,Ty.DIM d1, Ty.DIM d2,Ty.DIM d3], xs) =>  
                     [assignEin(y, (mk.transposeField (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 289  Line 296 
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, (mk.identity 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.2611  
changed lines
  Added in v.2922

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