Home My Page Projects Code Snippets Project Openings diderot

# SCM Repository

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

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

revision 2401, Sun Jul 7 19:43:45 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))),
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
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])=>
143                                                in
144                                               assignEin(y, rator, [f, s])
145                                            end),
146                    (BV.add_rf,             fn (y, [DK,NK], [s, f])
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
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.2401 changed lines Added in v.2412