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
 [diderot] / branches / charisee / src / compiler / translate / translate-basis.sml

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

revision 2413, Mon Aug 12 17:36:05 2013 UTC revision 2414, Mon Aug 19 05:02:14 2013 UTC
# Line 87  Line 87
87            end            end
88
89
(*Ein Operators*)
fun createTenEin (operator, sv) = let
val shape=shapeVarToTensor sv
in
S.transform(operator,[[shape]])
end

90
fun createFldEin(operator, f)=S.transform(operator,[])
91
92
93      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)))]
94
fun simpleEinOp rator (y, [], xs) = assignEin (y, S.transform(rator,[[]]), xs)
95
96   fun tensorEinOp rator (y, [sv], xs) = assignEin(y, createTenEin(rator, sv), xs)      fun FieldD(0)=  []
97          | FieldD(SK)=SK
98
99
100        fun singleScalarField(rator,y,NK,xs)=
101                let val rator=S.transform(rator, [],[NK])
102                in
103                    assignEin(y, rator, xs)
104                end
105
106        fun singleField(rator, y, SK, NK, xs)=
107                let
108                    val einShape=FieldD(SK)
109                    val rator=S.transform(rator, einShape,[NK])
110                in assignEin(y, rator, xs)
111                end
112
113    (****MV.toDim returns int, and DstTy.TensorTy returns intlist *)
114
115    (* shape is an int list, DIM is in int|variable, k-level of differntiation *)
116
117   (* build a table that maps Basis variables to their translation functions *)   (* build a table that maps Basis variables to their translation functions *)
118      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
# Line 128  Line 137
137                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),
138                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),
140                  (BV.add_tt,             fn (y, [sh1], xs) =>                  (BV.add_tt,             fn (y, [SK], xs) =>
141                                              let                                              let
142                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape SK
143                                                    val rator=S.tranform(EinOp.addTensors, [dd1],[])
144                                              in                                              in
145                                                  assignEin(y, S.tranform(EinOp.addTensors, [dd1],[]),xs)                                                  assignEin(y,rator,xs)
146                                              end),                                              end),
147
148                  (BV.add_ff,             fn (y, [DK,NK,SK], [f, g])=>                  (BV.add_ff,             fn (y, [_,NK,SK], [f, g])=>
149                                          let val rator= S.transform(EinOp.addField, [DK],[DK])                                          let
150                                          in assignEin(y, rator, [f, g])),                                              val einShape=FieldD(SK)
151                  (BV.add_fr,             fn (y, [DK,NK], [f, s])=>                                              val rator= S.transform(EinOp.addField, einShape,[NK,NK])
152                                          let val rator=S.transform(EinOp.addTenField, [DK],[DK])                                              in assignEin(y, rator, [f, g])
in
assignEin(y, rator, [f, s])
end),
(BV.add_rf,             fn (y, [DK,NK], [s, f])
let val rator=S.transform(EinOp.addTenField, [DK],[DK])
in
assignEin(y, rator, [f, s])
153                                          end),                                          end),
154                    (BV.add_fr,             fn (y, [_,NK], xs)=> singleScalarField(EinOp.addTenField,y, NK, xs)),
155                    (BV.add_rf,             fn (y, [_,NK], [s, f])=>singleScalarField(EinOp.addTenField,y, NK, [f,s])),
156                  (BV.sub_ii,              simpleOp(Op.ISub DstTy.IntTy)),                  (BV.sub_ii,              simpleOp(Op.ISub DstTy.IntTy)),
157                  (BV.sub_tt,             fn(y, [sv],xs)=>                  (BV.sub_tt,             fn(y, [SK],xs)=>
158                                              let val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                              let val ty1 as DstTy.TensorTy dd1 = pruneShape SK
159                                                  val rator =S.transform(EinOp.subTensor,[dd1],[])                                                  val rator =S.transform(EinOp.subTensor,[dd1],[])
160                                              in                                              in
161                                                  assignEin(y, rator,xs)                                                  assignEin(y, rator,xs)
162                                              end),                                              end),
163                  (BV.sub_ff,             fn (y, [DK,NK,SK], [f, g])                  (BV.sub_ff,             fn (y, [_,NK,SK], [f, g])=>
164                                              let val rator=S.transform(EinOp.subField, [DK],[DK])                                              let
165                                              => assignEin(y, rator, [f, g])),                                              val einShape=FieldD(SK)
166                                                val rator=S.transform(EinOp.subField, einShape,[NK,NK])
167  (***********Examine subfr, and subrf*)                                              in assignEin(y, rator, [f, g])
168                  (BV.sub_fr,             fn (y, _, [f, s]) => let                                              end),
val s' = IL.Var.copy s
in [
IL.ASSGN(s', IL.OP(Op.Neg DstTy.realTy, [s])),
IL.ASSGN(y, IL.OP(Op.OffsetField, [f, s']))
] end),

(BV.sub_rf,             fn (y, _, [s, f]) => let
val f' = IL.Var.copy f
in [
IL.ASSGN(f', IL.OP(Op.NegField, [f])),
IL.ASSGN(y, IL.OP(Op.OffsetField, [f', s]))
] end),

169
170                    (BV.sub_fr,             fn (y, [_,NK], xs) =>  singleScalarField(EinOp.subField, y,NK, xs)),
171                    (BV.sub_rf,             fn (y, [_,NK], [s, f]) => singleScalarField(EinOp.subField, y,NK, [f, s])),
172                  (BV.mul_ii,              simpleOp(Op.IMul DstTy.IntTy)),                  (BV.mul_ii,              simpleOp(Op.IMul DstTy.IntTy)),
173                  (BV.mul_rr,              simpleOp(Op.IMul DstTy.IntTy)),                  (BV.mul_rr,              simpleOp(Op.IMul DstTy.IntTy)),
174                  (BV.mul_rt,              fn (y, sv, [t, r])=>                  (BV.mul_rt,              fn (y, [SK], [r,t])=>
175                                          let                                          let
176                                              val rator =S.transform(EinOp.scaleTensor, [sv],[])                                              val rator =S.transform(EinOp.scaleTensor, [SK],[])
177                                          in assignEin(y,rator, [r,t]),                                          in assignEin(y,rator, [r,t]),
178                                          end)                                          end)
179                  (BV.mul_tr,             fn (y, sv, [t, r])=>                  (BV.mul_tr,             fn (y, [SK], [t, r])=>
180                                              let                                              let
181                                                  val rator =S.transform(EinOp.scaleTensor, [sv],[])                                              val rator =S.transform(EinOp.scaleTensor, [SK],[])
182                                              in assignEin(y,rator, [r,t]),                                              in assignEin(y,rator, [r,t]),
183                                              end)                                              end)
184                  (BV.mul_rf,             fn (y, [DK,NK,SK], [s, f])                  (BV.mul_rf,             fn (y, [_,NK,SK], xs)
185                                              =>                                      => singleField(EinOp.scaleField, y, SK, NK, xs)),
186                                          let val rator=S.transform(EinOp.scaleField, [DK],[DK])                  (BV.mul_fr,             fn (y, [_,NK,SK], [f, s])
187                                          in assignEin(y, rator, [s, f])                                      => singleField(EinOp.scaleField, y, SK, NK, [s,f])),
end),
(BV.mul_fr,             fn (y, [DK,NK,SK], [f, s])
let val rator=S.transform(EinOp.scaleField, [DK],[DK])
in assignEin(y, rator, [s, f])
end),
188                  (BV.div_ii,             simpleOp(Op.IDiv DstTy.IntTy)),                  (BV.div_ii,             simpleOp(Op.IDiv DstTy.IntTy)),
189                  (BV.div_rr,             simpleOp(Op.IDiv DstTy.realTy)),                  (BV.div_rr,             simpleOp(Op.IDiv DstTy.realTy)),
190                  (BV.div_tr,             fn (y, [sv], [x, s]) =>                  (BV.div_tr,             fn (y, [SK], xs) =>
191                                            let                                            let
192                                              val rator=S.transform(EinOp.divideTensor,[sv],[sv])                                              val rator=S.transform(EinOp.divideTensor,[SK],[])
193                                           in  assignEin(y, rator, [x,s])                                           in  assignEin(y, rator, xs)
end ),
(BV.div_fr,             fn (y, [DK,NK,SK], [f, s]) =>
let       (* [MX] *)
val rator = S.transform(EinOp.divideField,[DK],[DK])
in assignEin(y, rator, [x,s]),
194                                            end),                                            end),
195                    (BV.div_fr,             fn (y, [DK,NK,SK], xs) =>singleField(EinOp.divideField, y, SK, NK, xs)),
196                  (BV.exp_ri,             simpleOp(Op.Power)),                  (BV.exp_ri,             simpleOp(Op.Power)),
197                  (BV.exp_rr,             basisFn MathFuns.pow),                  (BV.exp_rr,             basisFn MathFuns.pow),
198
199
200                  (BV.curl2D,             fn (y, _, xs) =>                  (BV.curl2D,             fn (y, [DK], xs) =>
201                                              let                                              let
202                                                  val rator=S.transform(EinOp.Curl,[[0],[2],[2]],[2])                                                  val rator=S.transform(EinOp.Curl,[[0],[2],[2]],[2])
203                                              in                                              in
204                                                  assignEin(y, rator, xs)                                                  assignEin(y, rator, xs)
205                                              end),                                              end),
206                  (BV.curl3D,             fn (y, _, xs) =>                  (BV.curl3D,             fn (y, [DK], xs) =>
207                                      let                                      let
208                                          val rator=S.transform(EinOp.Curl,[[3],[3],[3]],[3])                                          val rator=S.transform(EinOp.Curl,[[3],[3],[3]],[3])
209                                      in                                      in
# Line 226  Line 211
211                                      end),                                      end),
212
213
214                  (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>                  (BV.convolve_vk,        fn (y, [DK, NK, SK], xs) =>
215                                      let                                      let
216                                          val shape=pruneDim(MV.toDim dv)                                          val shape=pruneDim(MV.toDim NK)
217                                          val rator=S.transform(EinOp.conv,[shape],[])                                          val rator=S.transform(EinOp.conv,[shape],[])
218                                      in                                      in
219                                          assignEin (y, rator, xs)                                          assignEin (y, rator, xs)
220                                      end),                                      end),
221                  (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>                  (BV.convolve_kv,        fn (y, [DK, NK, SK], [k, v]) =>
222                                      let                                      let
223                                          val shape=pruneDim(MV.toDim dv)                                          val shape=pruneDim(MV.toDim NK)
224                                          val rator= S.transform(EinOp.conv,[shape],[])                                          val rator= S.transform(EinOp.conv,[shape],[])
225                                      in                                      in
226                                          assignEin (y, rator, [v,k])                                          assignEin (y, rator, [v,k])
# Line 250  Line 235
235                                          let                                          let
236                                              val dv'=dimVarToTensor dv  (*Field*)                                              val dv'=dimVarToTensor dv  (*Field*)
237                                              val sv'=shapeVarToTensor sv (*Position*)                                              val sv'=shapeVarToTensor sv (*Position*)
238                                          val il= S.transform(EinOp.probe,[sv',dv'],[dv'])                                          val il= S.transform(EinOp.probe,[dv',sv'],[dv'])
239                                          in assignEin(y, il,xs)                                          in assignEin(y, il,xs)
240                                          end ),                                          end ),
241
242
(***********  What do I give as the arguments to Specialize*)
243                  (BV.op_D,               fn (y, [DK, NK], xs) =>                  (BV.op_D,               fn (y, [DK, NK], xs) =>
(*Is D the dimension?*)
244                                              let                                              let
246                                              in                                              in
247                                                  assignEin(y, rator, xs)                                                  assignEin(y, rator, xs)
248                                              end),                                              end),
249                  (BV.op_Dotimes,         fn (y, [DK, NK, SK, NK], xs) =>                  (BV.op_Dotimes,         fn (y, [DK, NK, SK, NK], xs) =>
250                                              let                                              singleField(EinOp.Divergence, y, SK, NK, xs)
(*Is DK the dimension?*)
val rator =S.transform(EinOp.Divergence,[DK],[DK])
in
assignEin(y, rator, xs)
end
251                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv
252                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)
253                                              | ty => assign(y, Op.Norm ty, xs)                                              | ty => assign(y, Op.Norm ty, xs)
254                                            (* end case *))),                                            (* end case *))),
255                  (BV.op_not,             simpleOp Op.Not),                  (BV.op_not,             simpleOp Op.Not),
256
257  (****MV.toDim returns int, and DstTy.TensorTy returns intlist *)
258
259                  (BV.op_cross,           fn(y, _ , xs )=> assignEin(y,EinOp.crossProductE ,xs)),                  (BV.op_cross,           fn(y, _ , xs )=> assignEin(y,EinOp.crossProductE ,xs)),
260                  (BV.op_outer,  (********************************************)                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let
fn (y, [dv1, dv2], xs) => let
261                                            val d1 = [pruneDim(MV.toDim dv1)]                                            val d1 = [pruneDim(MV.toDim dv1)]
262                                            val d2 = [pruneDim(MV.toDim dv2)]                                            val d2 = [pruneDim(MV.toDim dv2)]
263                                            in assignEin( y, S.transform(EinOp.outerProduct,[(length(d1),d1), (length(d2),d2)]),xs)                                            in
264                                                assignEin( y, S.transform(EinOp.outerProduct,[d1,d2],[]),xs)
265                                            end),                                            end),
266
(********************************************)
267                  (BV.op_inner,        fn (y, [sh1, sh2, _], xs) =>                  (BV.op_inner,        fn (y, [sh1, sh2, _], xs) =>
268                                              let                                              let
269                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
# Line 371  Line 348
348
349                  (BV.zero,               fn (y, [sv], []) =>                  (BV.zero,               fn (y, [sv], []) =>
350                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),
351                  (BV.subscript,          fn (y, [tv, dv], args) =>                  (BV.subscript,          fn (y, [tv, dv], xs) =>s
352                                            assign(y,                                            assign(y,
353                                              Op.SeqSub(DstTy.SeqTy(pruneTy tv, pruneDim(MV.toDim dv))),                                              Op.SeqSub(DstTy.SeqTy(pruneTy tv, pruneDim(MV.toDim dv))),
354                                              args))                                              xs))
355                  ];                  ];
356
357            (* add C math functions *)            (* add C math functions *)

Legend:
 Removed from v.2413 changed lines Added in v.2414

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