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 2411, Sun Aug 4 17:45:59 2013 UTC revision 2412, Wed Aug 7 02:17:53 2013 UTC
# Line 86  Line 86 
86                  end                  end
87            end            end
88    
89    
90        (*Ein Operators*)
91      fun createTenEin (operator, sv) = let      fun createTenEin (operator, sv) = let
92            val shape=shapeVarToTensor sv            val shape=shapeVarToTensor sv
93            in            in
94              S.transform(operator,[(len(shape), shape)])              S.transform(operator,[[shape]])
95            end            end
96    
97    
98      fun createFldEin(operator, f)=S.transform(operator,[])      fun createFldEin(operator, f)=S.transform(operator,[])
99    
100    
101      fun assignEin (y, rator, xs) = [IL.ASSGN(y, IL.EINAPP(R.evalEinApp(rator, xs)))]      fun assignEin (y, rator, xs) = [IL.ASSGN(y, IL.EINAPP(R.evalEinApp(rator, xs)))]
102      fun simpleEinOp rator (y, [], xs) = assignEin (y, S.transform(rator,[]), xs)  
103        fun simpleEinOp rator (y, [], xs) = assignEin (y, S.transform(rator,[[]]), xs)
104    
105      fun tensorEinOp rator (y, [sv], xs) = assignEin(y, createTenEin(rator, sv), xs)      fun tensorEinOp rator (y, [sv], xs) = assignEin(y, createTenEin(rator, sv), xs)
106    
107    
108    (* build a table that maps Basis variables to their translation functions *)    (* build a table that maps Basis variables to their translation functions *)
109      val tbl : ((IL.var * Ty.meta_var list * IL.var list) -> IL.assignment list) VTbl.hash_table = let      val tbl : ((IL.var * Ty.meta_var list * IL.var list) -> IL.assignment list) VTbl.hash_table = let
110            val tbl = VTbl.mkTable (128, Fail "Translate table")            val tbl = VTbl.mkTable (128, Fail "Translate table")
# Line 121  Line 128 
128                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),
129                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),
130                  (BV.add_ii,             simpleOp(Op.IAdd DstTy.IntTy)),                  (BV.add_ii,             simpleOp(Op.IAdd DstTy.IntTy)),
131                  (BV.add_tt,             tensorEinOp(EinOp.addTensors)),                  (BV.add_tt,             fn (y, [sh1], xs) =>
132                                                let
133   (*SrcOp.Field d*)                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
134                  (BV.add_ff,             fn (y, [_, dv, sv], [f, g])                                              in
135                                              => assignEin(y, createFldEin(EinOp.addField,f ), [f, g])),                                                  assignEin(y, S.tranform(EinOp.addTensors, [dd1],[]),xs)
136                  (BV.add_fr,             fn (y, _, [f, s])                                              end),
                                             => assignEin(y, createFldEin(EinOp.addTenField,f ), [f, s])),  
                 (BV.add_rf,             fn (y, _, [s, f])  
                                             => assignEin(y, createFldEin(EinOp.addTenField,f ), [f, s])),  
137    
138                    (BV.add_ff,             fn (y, [DK,NK,SK], [f, g])=>
139                                            let val rator= S.transform(EinOp.addField, [DK],[DK])
140                                            in assignEin(y, rator, [f, g])),
141                    (BV.add_fr,             fn (y, [DK,NK], [f, s])=>
142                                            let val rator=S.transform(EinOp.addTenField, [DK],[DK])
143                                                in
144                                               assignEin(y, rator, [f, s])
145                                            end),
146                    (BV.add_rf,             fn (y, [DK,NK], [s, f])
147                                            let val rator=S.transform(EinOp.addTenField, [DK],[DK])
148                                            in
149                                                assignEin(y, rator, [f, s])
150                                            end),
151                  (BV.sub_ii,             simpleOp(Op.ISub DstTy.IntTy)),                  (BV.sub_ii,             simpleOp(Op.ISub DstTy.IntTy)),
152                  (BV.sub_tt,             tensorEinOp(EinOp.subTensor)),                  (BV.sub_tt,             fn(y, [sv],xs)=>
153                  (BV.sub_ff,             fn (y, _, [f, g])                                              let val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
154                                              => assignEin(y, createFldEin(EinOp.subField,f), [f, g])),                                                  val rator =S.transform(EinOp.subTensor,[dd1],[])
155                                                in
156                                                    assignEin(y, rator,xs)
157                                                end),
158                    (BV.sub_ff,             fn (y, [DK,NK,SK], [f, g])
159                                                let val rator=S.transform(EinOp.subField, [DK],[DK])
160                                                => assignEin(y, rator, [f, g])),
161    
162  (***********Examine subfr, and subrf*)  (***********Examine subfr, and subrf*)
163                  (BV.sub_fr,             fn (y, _, [f, s]) => let                  (BV.sub_fr,             fn (y, _, [f, s]) => let
# Line 151  Line 174 
174                                              IL.ASSGN(y, IL.OP(Op.OffsetField, [f', s]))                                              IL.ASSGN(y, IL.OP(Op.OffsetField, [f', s]))
175                                            ] end),                                            ] end),
176    
                 (BV.mul_ii,             simpleOp Op.IMul),  
                 (BV.mul_rr,             simpleOp(Op.IMul DstTy.IntTy)),  
                 (BV.mul_rt,             tensorEinOp(EinOp.scaleTensor)),  
                 (BV.mul_tr,             fn (y, [sv], [t, r]) =>  
                                             assignEin(y, createTenEin(EinOp.scaleTensor, sv), [r, t])),  
                 (BV.mul_rf,             fn (y, _, [s, f]) =>  
                                             assignEin(y, createFldEin(EinOp.scaleField, f), [s, f])),  
                 (BV.mul_fr,             fn (y, _, [f, s]) =>  
                                             assignEin(y, createFldEin(EinOp.scaleField, f), [s, f])),  
177    
178                    (BV.mul_ii,              simpleOp(Op.IMul DstTy.IntTy)),
179                    (BV.mul_rr,              simpleOp(Op.IMul DstTy.IntTy)),
180                    (BV.mul_rt,              fn (y, sv, [t, r])=>
181                                            let
182                                                val rator =S.transform(EinOp.scaleTensor, [sv],[])
183                                            in assignEin(y,rator, [r,t]),
184                                            end)
185                    (BV.mul_tr,             fn (y, sv, [t, r])=>
186                                                let
187                                                    val rator =S.transform(EinOp.scaleTensor, [sv],[])
188                                                in assignEin(y,rator, [r,t]),
189                                                end)
190                    (BV.mul_rf,             fn (y, [DK,NK,SK], [s, f])
191                                                =>
192                                            let val rator=S.transform(EinOp.scaleField, [DK],[DK])
193                                            in assignEin(y, rator, [s, f])
194                                            end),
195                    (BV.mul_fr,             fn (y, [DK,NK,SK], [f, s])
196                                            let val rator=S.transform(EinOp.scaleField, [DK],[DK])
197                                            in assignEin(y, rator, [s, f])
198                                            end),
199                  (BV.div_ii,             simpleOp(Op.IDiv DstTy.IntTy)),                  (BV.div_ii,             simpleOp(Op.IDiv DstTy.IntTy)),
200                  (BV.div_rr,             simpleOp(Op.IDiv DstTy.realTy)),                  (BV.div_rr,             simpleOp(Op.IDiv DstTy.realTy)),
201                  (BV.div_tr,             fn (y, [sv], [x, s]) =>                  (BV.div_tr,             fn (y, [sv], [x, s]) =>
202                                            assignEin(y, createTenEin(EinOp.divideTensor, sv), [x, s])),                                            let
203                  (BV.div_fr,             fn (y, _, [f, s]) =>                                              val rator=S.transform(EinOp.divideTensor,[sv],[sv])
204                                            assignEin(y, createFldEin(EinOp.divideField, sv), [x, s])),                                           in  assignEin(y, rator, [x,s])
205                                              end ),
206                    (BV.div_fr,             fn (y, [DK,NK,SK], [f, s]) =>
207                                              let       (* [MX] *)
208                                                val rator = S.transform(EinOp.divideField,[DK],[DK])
209                                                in assignEin(y, rator, [x,s]),
210                                              end),
211                  (BV.exp_ri,             simpleOp(Op.Power)),                  (BV.exp_ri,             simpleOp(Op.Power)),
212                  (BV.exp_rr,             basisFn MathFuns.pow),                  (BV.exp_rr,             basisFn MathFuns.pow),
213    
214                  (*Note curl is in Ein and does not need to be specialized.*)  
215                  (BV.curl2D,             fn (y, _, xs) => assignEin(y, EinOp.Curl2d, xs)),                  (BV.curl2D,             fn (y, _, xs) =>
216                  (BV.curl3D,             fn (y, _, xs) => assignEin(y, EinOp.Curl3d, xs)),                                              let
217                                                    val rator=S.transform(EinOp.Curl,[[0],[2],[2]],[2])
218                                                in
219                                                    assignEin(y, rator, xs)
220                                                end),
221                    (BV.curl3D,             fn (y, _, xs) =>
222                                        let
223                                            val rator=S.transform(EinOp.Curl,[[3],[3],[3]],[3])
224                                        in
225                                            assignEin(y, rator, xs)
226                                        end),
227    
228    
229                  (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>let                  (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>
230                                        let
231                          val shape=pruneDim(MV.toDim dv)                          val shape=pruneDim(MV.toDim dv)
232                          val operator=EinOp.conv                                          val rator=S.transform(EinOp.conv,[shape],[])
233                      in                      in
                         S.transform(operator,[(len(shape), shape)])  
234                          assignEin (y, rator, xs)                          assignEin (y, rator, xs)
235                      end),                      end),
236                  (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>let                  (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>
237                                        let
238                          val shape=pruneDim(MV.toDim dv)                          val shape=pruneDim(MV.toDim dv)
239                          val operator=EinOp.conv                                          val rator= S.transform(EinOp.conv,[shape],[])
240                      in                      in
                         S.transform(operator,[(len(shape), shape)])  
241                          assignEin (y, rator, [v,k])                          assignEin (y, rator, [v,k])
242                      end),                      end),
243    
244                  (BV.neg_i,              simpleOp(Op.INeg DstTy.IntTy)),                  (BV.neg_i,              simpleOp(Op.INeg DstTy.IntTy)),
245                  (BV.neg_t,              tensorOp Op.INeg),                  (BV.neg_t,              tensorOp Op.INeg),
246                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),
                 (BV.op_probe,           fn (y, [_, dv, sv], xs) =>  
                           (*  assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs),*)  
247    
248    
249                    (BV.op_probe,           fn (y, [_, dv, sv], xs) =>
250                                          let                                          let
251                                          val dv'=dimVarToTensor dv                                              val dv'=dimVarToTensor dv  (*Field*)
252                                          val sv'=shapeVarToTensor sv                                              val sv'=shapeVarToTensor sv (*Position*)
253                                          val operator=EinOp.probe                                          val il= S.transform(EinOp.probe,[sv',dv'],[dv'])
254                                          (*field-0 sv', position-1 dv'*)                                          in assignEin(y, il,xs)
255                                          (*F(x)_alpha   <F(x_1)>_0*)                                          end ),
                                         val il= S.transform(operator,[(len(sv'), sv'),(len(dv'),dv')])  
                                         in assignEin(y, il,xs) end ),  
256    
 (*Should I not include shape in field operations? *)  
 (***********  What do I give as the arguments to Specialize*)  
                 (BV.op_D,               fn (y, _, xs) => assignEin(y, createFldEin(EinOp.Grad,xs), xs)),  
                 (BV.op_Dotimes,         fn (y, _, xs) => assignEin(y, createFldEin(EinOp.Divergence,xs), xs)),  
257    
258    (***********  What do I give as the arguments to Specialize*)
259                    (BV.op_D,               fn (y, [DK, NK], xs) =>
260                                                    (*Is D the dimension?*)
261                                                let
262                                                val rator=S.transform(EinOp.Grad,[DK],[DK])
263                                                in
264                                                    assignEin(y, rator, xs)
265                                                end),
266                    (BV.op_Dotimes,         fn (y, [DK, NK, SK, NK], xs) =>
267                                                let
268                                                    (*Is DK the dimension?*)
269                                                    val rator =S.transform(EinOp.Divergence,[DK],[DK])
270                                                in
271                                                   assignEin(y, rator, xs)
272                                                end
273                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv
274                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)
275                                              | ty => assign(y, Op.Norm ty, xs)                                              | ty => assign(y, Op.Norm ty, xs)
# Line 220  Line 279 
279  (****MV.toDim returns int, and DstTy.TensorTy returns intlist *)  (****MV.toDim returns int, and DstTy.TensorTy returns intlist *)
280    
281                  (BV.op_cross,           fn(y, _ , xs )=> assignEin(y,EinOp.crossProductE ,xs)),                  (BV.op_cross,           fn(y, _ , xs )=> assignEin(y,EinOp.crossProductE ,xs)),
282                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let                  (BV.op_outer,  (********************************************)
283                                                fn (y, [dv1, dv2], xs) => let
284                                            val d1 = [pruneDim(MV.toDim dv1)]                                            val d1 = [pruneDim(MV.toDim dv1)]
285                                            val d2 = [pruneDim(MV.toDim dv2)]                                            val d2 = [pruneDim(MV.toDim dv2)]
286                                            in assignEin( y, S.transform(EinOp.outerProduct,[(length(d1),d1), (length(d2),d2)]),xs)                                            in assignEin( y, S.transform(EinOp.outerProduct,[(length(d1),d1), (length(d2),d2)]),xs)
287                                            end),                                            end),
288                  (BV.op_inner,        fn (y, [sh1, sh2, _], xs) => let  
289                                                 (********************************************)
290                    (BV.op_inner,        fn (y, [sh1, sh2, _], xs) =>
291                                                let
292                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
293                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2
294                                            val ilist=  [(length(dd1)-1, List.take(dd1, length(dd1)-1) ) ,                                                  val alpha= List.take(dd1, length(dd1)-1)
295                                                  ( length(dd2)-1, tl(dd2)),                                                  val beta=  tl(dd2)
296                                                  ( 0, [hd(dd2)]) ]                                                  val i =hd(dd2)
297                                            in assignEin(y, S.tranform(EinOp.innerProduct, ilist),xs) end),                                                  val ilist=  [alpha, beta, i]
298                                              in
299                                                assignEin(y, S.tranform(EinOp.innerProduct, ilist,[]),xs)
300                                            end),
301    
302                  (BV.op_colon,         fn (y, [sh1, sh2, _], xs) => let                  (BV.op_colon,         fn (y, [sh1, sh2, _], xs) =>
303                                                let
304                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
305                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2
306                                            val ilist=    [ (length(dd1)-2 ,  List.take(q, length(q)-2)) ,                                                  val m= List.take(dd2,2)
307                                                  ( length(dd2)-2 , tl(tl(dd2))),                                                  val i=hd(m)
308                                                  (0, List.take(dd2,2))]                                                  val j=tl(m)
309                                           in assignEin(y, S.transform(EinOp.doubleDot, ilist),xs) end),                                                  val alpha= List.take(dd1, length(dd1)-2)
310                                                    val beta=tl(tl(dd2))
311    
312                                                    val ilist=[alpha, beta, i, j]
313                                                in
314                                                    assignEin(y, S.transform(EinOp.doubleDot, ilist,[]),xs)
315                                                end),
316    
317                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>
318                                            assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),                                            assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),
# Line 266  Line 339 
339                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (BV.fn_normalize,       vectorOp Op.Normalize),
340                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
341    
342                  (BV.fn_trace,           fn (y, [dv], xs) =>let                  (BV.fn_trace,           fn (y, [dv], xs) =>
343                                            let
344                                              val i=pruneDim(MV.toDim dv)                                              val i=pruneDim(MV.toDim dv)
345                                          in assignEin(y,S.transform(EinOp.trace, [1,i]),xs)  end),                                          in
346                                                assignEin(y,S.transform(EinOp.trace, [i],[]),xs)
347                                                end),
348    
349                  (BV.fn_transpose,       fn (y, [dv1, dv2], xs) =>let                  (BV.fn_transpose,           fn (y, [dv1, dv2], xs) =>
350                                              val d1=dimVarToInt dv1 val d2= dimVarToInt dv2                                          let
351                                          in assignEin(y,S.transform(EinOp.transpose, [(length(d1),d1),(length d2, d2)]),xs) end) ,                                              val d1=dimVarToInt dv1
352                                                val d2=dimVarToInt dv2
353                                            in
354                                                assignEin(y,S.transform(EinOp.transpose, [[d1],[d2]],[]),xs)
355                                            end),
356    
357                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
358                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
# Line 283  Line 363 
363                  (BV.kn_c1tent,          kernel Kernel.tent),                  (BV.kn_c1tent,          kernel Kernel.tent),
364                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
365    
366                  (BV.identity,           fn (y, [dv], []) =>let                  (BV.identity,           fn (y, [dv], []) =>
367                                                let
368                                                  val i=pruneDim(MV.toDim dv)                                                  val i=pruneDim(MV.toDim dv)
369                                              in assignEin(y, S.transform(EinOp.identity,[(1,i),(1,i)]),[]) end),                                              in assignEin(y, S.transform(EinOp.identity,[[i],[i]],[]))
370                                                end),
371    
372                  (BV.zero,               fn (y, [sv], []) =>                  (BV.zero,               fn (y, [sv], []) =>
373                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),

Legend:
Removed from v.2411  
changed lines
  Added in v.2412

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