Home My Page Projects Code Snippets Project Openings diderot

# SCM Repository

[diderot] Diff of /trunk/src/compiler/basis/basis-vars.sml
 [diderot] / trunk / src / compiler / basis / basis-vars.sml

# Diff of /trunk/src/compiler/basis/basis-vars.sml

revision 470, Tue Nov 2 16:33:48 2010 UTC revision 1116, Thu May 5 04:49:02 2011 UTC
# Line 39  Line 39
39
40        fun field (k, d, dd) = Ty.T_Field{diff=k, dim=d, shape=dd}        fun field (k, d, dd) = Ty.T_Field{diff=k, dim=d, shape=dd}
41        fun tensor ds = Ty.T_Tensor(Ty.Shape ds)        fun tensor ds = Ty.T_Tensor(Ty.Shape ds)
42          fun matrix d = tensor[d,d]
43
44        fun monoVar (name, ty) = Var.new (name, AST.BasisVar, ty)        fun monoVar (name, ty) = Var.new (name, AST.BasisVar, ty)
45        fun polyVar (name, scheme) = Var.newPoly (name, AST.BasisVar, scheme)        fun polyVar (name, scheme) = Var.newPoly (name, AST.BasisVar, scheme)
# Line 125  Line 126
126                [t, Ty.realTy] --> t                [t, Ty.realTy] --> t
127              end))              end))
128
129      (* exponentiation; we distinguish between integer and real exponents to allow x^2 to be compiled
130       * as x*x.
131       *)
132        val exp_ri = monoVar(N.op_exp, [Ty.realTy, Ty.T_Int] --> Ty.realTy)
133        val exp_rr = monoVar(N.op_exp, [Ty.realTy, Ty.realTy] --> Ty.realTy)
134
135        val convolve_vk = polyVar (N.op_convolve, all([DK, NK, SK],
136                fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
137                    val k = Ty.DiffVar(k, 0)
138                    val d = Ty.DimVar d
139                    val dd = Ty.ShapeVar dd
140                    in
141                      [Ty.T_Image{dim=d, shape=dd}, Ty.T_Kernel k]
142                        --> field(k, d, dd)
143                    end))
144        val convolve_kv = polyVar (N.op_convolve, all([DK, NK, SK],
145                fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
146                    val k = Ty.DiffVar(k, 0)
147                    val d = Ty.DimVar d
148                    val dd = Ty.ShapeVar dd
149                    in
150                      [Ty.T_Kernel k, Ty.T_Image{dim=d, shape=dd}]
151                        --> field(k, d, dd)
152                    end))
153
154      val lt_ii = monoVar(N.op_lt, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)      val lt_ii = monoVar(N.op_lt, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
155      val lt_rr = monoVar(N.op_lt, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)      val lt_rr = monoVar(N.op_lt, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
156      val lte_ii = monoVar(N.op_lte, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)      val lte_ii = monoVar(N.op_lte, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
# Line 160  Line 186
186                  [field(k, d, dd)] --> field(k, d, dd)                  [field(k, d, dd)] --> field(k, d, dd)
187                end))                end))
188
189        val lerp3 = polyVar(N.fn_lerp, all([SK],
190              fn [Ty.SHAPE dd] => let
191                  val t = Ty.T_Tensor(Ty.ShapeVar dd)
192                  in
193                    [t, t, Ty.realTy] --> t
194                  end))
195        val lerp5 = polyVar(N.fn_lerp, all([SK],
196              fn [Ty.SHAPE dd] => let
197                  val t = Ty.T_Tensor(Ty.ShapeVar dd)
198                  in
199                    [t, t, Ty.realTy, Ty.realTy, Ty.realTy] --> t
200                  end))
201
203
# Line 172  Line 210
210                  [field(k, d, dd), tensor[d]] --> Ty.T_Tensor dd                  [field(k, d, dd), tensor[d]] --> Ty.T_Tensor dd
211                end))                end))
212
(* NOTE: this should be overloaded to allow both v*h and h*v orders *)
val op_convolve = polyVar (N.op_convolve, all([DK, NK, SK],
fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
val k = Ty.DiffVar(k, 0)
val d = Ty.DimVar d
val dd = Ty.ShapeVar dd
in
[Ty.T_Image{dim=d, shape=dd}, Ty.T_Kernel k]
--> field(k, d, dd)
end))

213      val op_D = polyVar (N.op_D, all([DK, NK, SK],      val op_D = polyVar (N.op_D, all([DK, NK, SK],
214            fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let            fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
215                val k0 = Ty.DiffVar(k, 0)                val k0 = Ty.DiffVar(k, 0)
# Line 200  Line 227
227      val op_not = monoVar (N.op_not, [Ty.T_Bool] --> Ty.T_Bool)      val op_not = monoVar (N.op_not, [Ty.T_Bool] --> Ty.T_Bool)
228
229    (* functions *)    (* functions *)
230        val fn_atan2 = monoVar (N.fn_atan2, [Ty.realTy, Ty.realTy] --> Ty.realTy)
231
232      val fn_CL = monoVar (N.fn_CL, [tensor[N3, N3]] --> Ty.realTy)      val fn_CL = monoVar (N.fn_CL, [tensor[N3, N3]] --> Ty.realTy)
233
234  (* the following is depreciated in favor of the infix operator *)  (* the following is depreciated in favor of the infix operator *)
# Line 215  Line 244
244
245      val fn_cos = monoVar (N.fn_cos, [Ty.realTy] --> Ty.realTy)      val fn_cos = monoVar (N.fn_cos, [Ty.realTy] --> Ty.realTy)
246
247        local
248          val crossTy = let
249                val t = tensor[N3]
250                in
251                  [t, t] --> t
252                end
253        in
254        val op_cross = monoVar (N.op_cross, crossTy)
255        val fn_cross = monoVar (N.fn_cross, crossTy)
256        end
257
258      (* the depriciated 'dot' function *)
259      val fn_dot = polyVar (N.fn_dot, allNK(fn tv => let      val fn_dot = polyVar (N.fn_dot, allNK(fn tv => let
260            val t = tensor[Ty.DimVar tv]            val t = tensor[Ty.DimVar tv]
261            in            in
262              [t, t] --> Ty.realTy              [t, t] --> Ty.realTy
263            end))            end))
264
265      (* the inner product operator (including dot product) is treated as a special case in the
266       * typechecker.  It is not included in the basis environment, but we define its type scheme
267       * here.  There is an implicit constraint on its type to have the following scheme:
268       *
269       *     ALL[sigma1, d1, sigma2] . tensor[sigma1, d1] * tensor[d1, sigma2] -> tensor[sigma1, sigma2]
270       *)
271        val op_inner = polyVar (N.op_dot, all([SK, SK, SK],
272                fn [Ty.SHAPE s1, Ty.SHAPE s2, Ty.SHAPE s3] =>
273                    [Ty.T_Tensor(Ty.ShapeVar s1), Ty.T_Tensor(Ty.ShapeVar s2)]
274                      --> Ty.T_Tensor(Ty.ShapeVar s3)))
275
276      (* Eigenvalues of a matrix *)
277        val fn_evals = polyVar (N.fn_trace, all([NK],
278                fn [Ty.DIM d] => let
279                    val d = Ty.DimVar d
280                    in
281                      [matrix d] --> Ty.T_Sequence(Ty.realTy, d)
282                    end))
283
284      (* Eigenvectors of a matrix *)
285        val fn_evecs = polyVar (N.fn_trace, all([NK],
286                fn [Ty.DIM d] => let
287                    val d = Ty.DimVar d
288                    in
289                      [matrix d] --> Ty.T_Sequence(tensor[d], d)
290                    end))
291
292      val fn_inside = polyVar (N.fn_inside, all([DK, NK, SK],      val fn_inside = polyVar (N.fn_inside, all([DK, NK, SK],
293              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
294                  val k = Ty.DiffVar(k, 0)                  val k = Ty.DiffVar(k, 0)
# Line 249  Line 317
317                    [t, t] --> t                    [t, t] --> t
318                  end))                  end))
319
320        val fn_normalize = polyVar (N.fn_normalize, all([NK],
321                fn [Ty.DIM d] => let
322                    val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])
323                    in
324                      [t] --> t
325                    end))
326
327      (* outer product *)
328        local
329          fun mkOuter [Ty.DIM d1, Ty.DIM d2] = let
330                val vt1 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1])
331                val vt2 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d2])
332                val mt = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1, Ty.DimVar d2])
333                in
334                  [vt1, vt2] --> mt
335                end
336        in
337        val fn_outer = polyVar (N.fn_outer, all([NK, NK], mkOuter))
338        val op_outer = polyVar (N.op_outer, all([NK, NK], mkOuter))
339        end
340
341      val fn_pow = monoVar (N.fn_pow, [Ty.realTy, Ty.realTy] --> Ty.realTy)      val fn_pow = monoVar (N.fn_pow, [Ty.realTy, Ty.realTy] --> Ty.realTy)
342
343      val fn_principleEvec = polyVar (N.fn_principleEvec, all([NK],      val fn_principleEvec = polyVar (N.fn_principleEvec, all([NK],
344              fn [Ty.DIM d] => let              fn [Ty.DIM d] => let
345                  val d = Ty.DimVar d                  val d = Ty.DimVar d
346                  in                  in
347                    [tensor[d,d]] --> tensor[d]                    [matrix d] --> tensor[d]
348                  end))                  end))
349
350      val fn_sin = monoVar (N.fn_sin, [Ty.realTy] --> Ty.realTy)      val fn_sin = monoVar (N.fn_sin, [Ty.realTy] --> Ty.realTy)
351
352        val fn_sqrt = monoVar (N.fn_sqrt, [Ty.realTy] --> Ty.realTy)
353
354        val fn_tan = monoVar (N.fn_tan, [Ty.realTy] --> Ty.realTy)
355
356        val fn_trace = polyVar (N.fn_trace, all([NK],
357                fn [Ty.DIM d] => let
358                    val d = Ty.DimVar d
359                    in
360                      [matrix d] --> Ty.realTy
361                    end))
362
363    (* kernels *)    (* kernels *)
364  (* FIXME: we should really get the continuity info from the kernels themselves *)  (* FIXME: we should really get the continuity info from the kernels themselves *)
365      val kn_bspln3 = monoVar (N.kn_bspln3, Ty.T_Kernel(Ty.DiffConst 2))      val kn_bspln3 = monoVar (N.kn_bspln3, Ty.T_Kernel(Ty.DiffConst 2))
366      val kn_bspln5 = monoVar (N.kn_bspln5, Ty.T_Kernel(Ty.DiffConst 4))      val kn_bspln5 = monoVar (N.kn_bspln5, Ty.T_Kernel(Ty.DiffConst 4))
367      val kn_ctmr = monoVar (N.kn_ctmr, Ty.T_Kernel(Ty.DiffConst 2))      val kn_ctmr = monoVar (N.kn_ctmr, Ty.T_Kernel(Ty.DiffConst 1))
368      val kn_tent = monoVar (N.kn_tent, Ty.T_Kernel(Ty.DiffConst 0))      val kn_tent = monoVar (N.kn_tent, Ty.T_Kernel(Ty.DiffConst 0))
369      (* kernels with false claims of differentiability, for pedagogy *)
370        val kn_c1tent = monoVar (N.kn_c1tent, Ty.T_Kernel(Ty.DiffConst 1))
371        val kn_c2ctmr = monoVar (N.kn_c2ctmr, Ty.T_Kernel(Ty.DiffConst 2))
372
373      (***** internal variables *****)
374
375      (* integer to real conversion *)
376        val i2r = monoVar (Atom.atom "\$i2r", [Ty.T_Int] --> Ty.realTy)
377
378      (* identity matrix *)
379        val identity = polyVar (Atom.atom "\$id", allNK (fn dv => [] --> matrix(Ty.DimVar dv)))
380
381    (* internal variables *)    (* zero tensor *)
382      val i2r = monoVar (Atom.atom "\$i2r", [Ty.T_Int] --> Ty.realTy)      (* integer to real conversion *)      val zero = polyVar (Atom.atom "\$zero", all ([SK],
383                fn [Ty.SHAPE dd] => [] --> Ty.T_Tensor(Ty.ShapeVar dd)))
384
385      end (* local *)      end (* local *)
386    end    end

Legend:
 Removed from v.470 changed lines Added in v.1116