Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/basis/basis-vars.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/basis/basis-vars.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/src/basis/basis-vars.sml revision 83, Wed May 26 18:50:44 2010 UTC trunk/src/compiler/basis/basis-vars.sml revision 1640, Wed Nov 16 02:19:51 2011 UTC
# Line 1  Line 1 
1  (* basis-vars.sml  (* basis-vars.sml
2   *   *
3   * COPYRIGHT (c) 2010 The Diderot Project (http://diderot.cs.uchicago.edu)   * COPYRIGHT (c) 2010 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4   * All rights reserved.   * All rights reserved.
5   *   *
6   * This module defines the AST variables for the built in operators and functions.   * This module defines the AST variables for the built in operators and functions.
# Line 21  Line 21 
21    
22      (* short names for kinds *)      (* short names for kinds *)
23        val TK : unit -> Ty.meta_var = Ty.TYPE o MV.newTyVar        val TK : unit -> Ty.meta_var = Ty.TYPE o MV.newTyVar
24        fun DK () = Ty.DIFF(MV.newDiffVar 0)        fun DK () : Ty.meta_var = Ty.DIFF(MV.newDiffVar 0)
25        val SK : unit -> Ty.meta_var = Ty.SHAPE o MV.newShapeVar        val SK : unit -> Ty.meta_var = Ty.SHAPE o MV.newShapeVar
26        val NK : unit -> Ty.meta_var = Ty.DIM o MV.newDimVar        val NK : unit -> Ty.meta_var = Ty.DIM o MV.newDimVar
27    
# 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 54  Line 55 
55     *    b  -- bool     *    b  -- bool
56     *    r  -- real (tensor[])     *    r  -- real (tensor[])
57     *    t  -- tensor[shape]     *    t  -- tensor[shape]
58       *    f  -- field#k(d)[shape]
59     *)     *)
60    
61      val add_ii = monoVar(N.op_add, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)      val add_ii = monoVar(N.op_add, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
# Line 62  Line 64 
64              in              in
65                [t, t] --> t                [t, t] --> t
66              end))              end))
67        val add_ff = polyVar(N.op_add, all([DK,NK,SK],
68              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
69                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
70                in
71                  [t, t] --> t
72                end))
73    
74      val sub_ii = monoVar(N.op_sub, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)      val sub_ii = monoVar(N.op_sub, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
75      val sub_tt = polyVar(N.op_sub, all([SK], fn [Ty.SHAPE dd] => let      val sub_tt = polyVar(N.op_sub, all([SK], fn [Ty.SHAPE dd] => let
# Line 69  Line 77 
77              in              in
78                [t, t] --> t                [t, t] --> t
79              end))              end))
80        val sub_ff = polyVar(N.op_sub, all([DK,NK,SK],
81              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
82                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
83                in
84                  [t, t] --> t
85                end))
86    
87    (* note that we assume that operators are tested in the order defined here, so that mul_rr    (* note that we assume that operators are tested in the order defined here, so that mul_rr
88     * takes precedence over mul_rt and mul_tr!     * takes precedence over mul_rt and mul_tr!
# Line 85  Line 99 
99              in              in
100                [t, Ty.realTy] --> t                [t, Ty.realTy] --> t
101              end))              end))
102        val mul_rf = polyVar(N.op_mul, all([DK,NK,SK],
103              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
104                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
105                in
106                  [Ty.realTy, t] --> t
107                end))
108        val mul_fr = polyVar(N.op_mul, all([DK,NK,SK],
109              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
110                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
111                in
112                  [t, Ty.realTy] --> t
113                end))
114    
115      val div_ii = monoVar(N.op_div, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)      val div_ii = monoVar(N.op_div, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
116      val div_rr = monoVar(N.op_div, [Ty.realTy, Ty.realTy] --> Ty.realTy)      val div_rr = monoVar(N.op_div, [Ty.realTy, Ty.realTy] --> Ty.realTy)
# Line 93  Line 119 
119              in              in
120                [t, Ty.realTy] --> t                [t, Ty.realTy] --> t
121              end))              end))
122        val div_fr = polyVar(N.op_div, all([DK,NK,SK],
123              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
124                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
125                in
126                  [t, Ty.realTy] --> t
127                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)
# Line 113  Line 170 
170      val neq_rr = monoVar(N.op_neq, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)      val neq_rr = monoVar(N.op_neq, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
171    
172    
173      val neg_i = monoVar(N.op_neg, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)      val neg_i = monoVar(N.op_neg, [Ty.T_Int] --> Ty.T_Int)
174      val neg_t = polyVar(N.op_neg, all([SK],      val neg_t = polyVar(N.op_neg, all([SK],
175            fn [Ty.SHAPE dd] => let            fn [Ty.SHAPE dd] => let
176                val t = Ty.T_Tensor(Ty.ShapeVar dd)                val t = Ty.T_Tensor(Ty.ShapeVar dd)
# Line 129  Line 186 
186                  [field(k, d, dd)] --> field(k, d, dd)                  [field(k, d, dd)] --> field(k, d, dd)
187                end))                end))
188    
189      (* clamp is overloaded at scalars and vectors *)
190        val clamp_rrr = monoVar(N.fn_clamp, [Ty.realTy, Ty.realTy, Ty.realTy] --> Ty.realTy)
191        val clamp_vvv = polyVar (N.fn_clamp, allNK(fn tv => let
192              val t = tensor[Ty.DimVar tv]
193              in
194                [t, t, t] --> t
195              end))
196    
197        val lerp3 = polyVar(N.fn_lerp, all([SK],
198              fn [Ty.SHAPE dd] => let
199                  val t = Ty.T_Tensor(Ty.ShapeVar dd)
200                  in
201                    [t, t, Ty.realTy] --> t
202                  end))
203        val lerp5 = polyVar(N.fn_lerp, all([SK],
204              fn [Ty.SHAPE dd] => let
205                  val t = Ty.T_Tensor(Ty.ShapeVar dd)
206                  in
207                    [t, t, Ty.realTy, Ty.realTy, Ty.realTy] --> t
208                  end))
209    
210      (* Eigenvalues/vectors of a matrix; we only support this operation on 2x2 and 3x3 matrices, so
211       * we overload the function.
212       *)
213        local
214          fun evals d = monoVar (N.fn_evals, [matrix d] --> Ty.T_Sequence(Ty.realTy, d))
215          fun evecs d = monoVar (N.fn_evecs, [matrix d] --> Ty.T_Sequence(tensor[d], d))
216        in
217        val evals2x2 = evals(Ty.DimConst 2)
218        val evecs2x2 = evecs(Ty.DimConst 2)
219        val evals3x3 = evals(Ty.DimConst 3)
220        val evecs3x3 = evecs(Ty.DimConst 3)
221        end
222    
223    
224    (***** non-overloaded operators, etc. *****)    (***** non-overloaded operators, etc. *****)
225    
# Line 141  Line 232 
232                  [field(k, d, dd), tensor[d]] --> Ty.T_Tensor dd                  [field(k, d, dd), tensor[d]] --> Ty.T_Tensor dd
233                end))                end))
234    
235      val op_D = polyVar (N.op_D, all([DK, NK, SK],    (* differentiation of scalar fields *)
236            fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let      val op_D = polyVar (N.op_D, all([DK, NK],
237              fn [Ty.DIFF k, Ty.DIM d] => let
238                  val k0 = Ty.DiffVar(k, 0)
239                  val km1 = Ty.DiffVar(k, ~1)
240                  val d = Ty.DimVar d
241                  in
242                    [field(k0, d, Ty.Shape[])]
243                      --> field(km1, d, Ty.Shape[d])
244                  end))
245      (* differetiation of higher-order tensor fields *)
246        val op_Dotimes = polyVar (N.op_Dotimes, all([DK, NK, SK, NK],
247              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd, Ty.DIM d'] => let
248                val k0 = Ty.DiffVar(k, 0)                val k0 = Ty.DiffVar(k, 0)
249                val km1 = Ty.DiffVar(k, ~1)                val km1 = Ty.DiffVar(k, ~1)
250                val d = Ty.DimVar d                val d = Ty.DimVar d
251                  val d' = Ty.DimVar d'
252                val dd = Ty.ShapeVar dd                val dd = Ty.ShapeVar dd
253                in                in
254                  [field(k0, d, dd), tensor[d]]                  [field(k0, d, Ty.ShapeExt(dd, d'))]
255                    --> field(km1, d, Ty.ShapeExt(dd, d))                    --> field(km1, d, Ty.ShapeExt(Ty.ShapeExt(dd, d'), d))
256                end))                end))
257    
258      val op_norm = polyVar (N.op_norm, all([SK],      val op_norm = polyVar (N.op_norm, all([SK],
# Line 157  Line 260 
260    
261      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)
262    
   
263    (* functions *)    (* functions *)
264      val fn_CL = polyVar (N.fn_CL, ty([tensor[N3, N3]] --> Ty.vec3Ty))      val fn_atan2 = monoVar (N.fn_atan2, [Ty.realTy, Ty.realTy] --> Ty.realTy)
265    
266    (* the following is depreciated in favor of the infix operator *)
267      val fn_convolve = polyVar (N.fn_convolve, all([DK, NK, SK],      val fn_convolve = polyVar (N.fn_convolve, all([DK, NK, SK],
268              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
269                  val k = Ty.DiffVar(k, 0)                  val k = Ty.DiffVar(k, 0)
# Line 171  Line 274 
274                      --> field(k, d, dd)                      --> field(k, d, dd)
275                  end))                  end))
276    
277      val fn_cos = polyVar (N.fn_cos, ty([Ty.realTy] --> Ty.realTy))      val fn_cos = monoVar (N.fn_cos, [Ty.realTy] --> Ty.realTy)
278    
279        local
280          val crossTy = let
281                val t = tensor[N3]
282                in
283                  [t, t] --> t
284                end
285        in
286        val op_cross = monoVar (N.op_cross, crossTy)
287        val fn_cross = monoVar (N.fn_cross, crossTy)
288        end
289    
290      (* the depriciated 'dot' function *)
291        val fn_dot = polyVar (N.fn_dot, allNK(fn tv => let
292              val t = tensor[Ty.DimVar tv]
293              in
294                [t, t] --> Ty.realTy
295              end))
296    
297      val fn_dot = polyVar (N.fn_dot, allNK(fn tv => [tensor[Ty.DimVar tv]] --> tensor[Ty.DimVar tv]))    (* the inner product operator (including dot product) is treated as a special case in the
298       * typechecker.  It is not included in the basis environment, but we define its type scheme
299       * here.  There is an implicit constraint on its type to have the following scheme:
300       *
301       *     ALL[sigma1, d1, sigma2] . tensor[sigma1, d1] * tensor[d1, sigma2] -> tensor[sigma1, sigma2]
302       *)
303        val op_inner = polyVar (N.op_dot, all([SK, SK, SK],
304                fn [Ty.SHAPE s1, Ty.SHAPE s2, Ty.SHAPE s3] =>
305                    [Ty.T_Tensor(Ty.ShapeVar s1), Ty.T_Tensor(Ty.ShapeVar s2)]
306                      --> Ty.T_Tensor(Ty.ShapeVar s3)))
307    
308      val fn_inside = polyVar (N.fn_inside,       all([DK, NK, SK],      val fn_inside = polyVar (N.fn_inside,       all([DK, NK, SK],
309              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
# Line 193  Line 323 
323                    [Ty.T_String] --> Ty.T_Image{dim=d, shape=dd}                    [Ty.T_String] --> Ty.T_Image{dim=d, shape=dd}
324                  end))                  end))
325    
326        val fn_max = monoVar (N.fn_max, [Ty.realTy, Ty.realTy] --> Ty.realTy)
327        val fn_min = monoVar (N.fn_min, [Ty.realTy, Ty.realTy] --> Ty.realTy)
328    
329      val fn_modulate = polyVar (N.fn_modulate, all([NK],      val fn_modulate = polyVar (N.fn_modulate, all([NK],
330              fn [Ty.DIM d] => let              fn [Ty.DIM d] => let
331                  val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])                  val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])
# Line 200  Line 333 
333                    [t, t] --> t                    [t, t] --> t
334                  end))                  end))
335    
336      val fn_pow = polyVar (N.fn_pow, ty([Ty.realTy, Ty.realTy] --> Ty.realTy))      val fn_normalize = polyVar (N.fn_normalize, all([NK],
337                fn [Ty.DIM d] => let
338                    val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])
339                    in
340                      [t] --> t
341                    end))
342    
343  (*    (* outer product *)
344      val fn_principleEvec = Atom.atom "principleEvec"      local
345  *)        fun mkOuter [Ty.DIM d1, Ty.DIM d2] = let
346                val vt1 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1])
347                val vt2 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d2])
348                val mt = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1, Ty.DimVar d2])
349                in
350                  [vt1, vt2] --> mt
351                end
352        in
353        val fn_outer = polyVar (N.fn_outer, all([NK, NK], mkOuter))
354        val op_outer = polyVar (N.op_outer, all([NK, NK], mkOuter))
355        end
356    
357        val fn_pow = monoVar (N.fn_pow, [Ty.realTy, Ty.realTy] --> Ty.realTy)
358    
359        val fn_principleEvec = polyVar (N.fn_principleEvec, all([NK],
360                fn [Ty.DIM d] => let
361                    val d = Ty.DimVar d
362                    in
363                      [matrix d] --> tensor[d]
364                    end))
365    
366        val fn_sin = monoVar (N.fn_sin, [Ty.realTy] --> Ty.realTy)
367    
368        val fn_sqrt = monoVar (N.fn_sqrt, [Ty.realTy] --> Ty.realTy)
369    
370      val fn_sin = polyVar (N.fn_sin, ty([Ty.realTy] --> Ty.realTy))      val fn_tan = monoVar (N.fn_tan, [Ty.realTy] --> Ty.realTy)
371    
372        val fn_trace = polyVar (N.fn_trace, all([NK],
373                fn [Ty.DIM d] => [matrix(Ty.DimVar d)] --> Ty.realTy))
374    
375    (* kernels *)    (* kernels *)
376    (* FIXME: we should really get the continuity info from the kernels themselves *)
377      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))
378        val kn_bspln5 = monoVar (N.kn_bspln5, Ty.T_Kernel(Ty.DiffConst 4))
379        val kn_ctmr = monoVar (N.kn_ctmr, Ty.T_Kernel(Ty.DiffConst 1))
380      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))
381      (* kernels with false claims of differentiability, for pedagogy *)
382    (* internal variables *)      val kn_c1tent = monoVar (N.kn_c1tent, Ty.T_Kernel(Ty.DiffConst 1))
383      val i2r = monoVar (Atom.atom "$i2r", [Ty.T_Int] --> Ty.realTy)      (* integer to real conversion *)      val kn_c2ctmr = monoVar (N.kn_c2ctmr, Ty.T_Kernel(Ty.DiffConst 2))
384    
385      (***** internal variables *****)
386    
387      (* integer to real conversion *)
388        val i2r = monoVar (Atom.atom "$i2r", [Ty.T_Int] --> Ty.realTy)
389    
390      (* identity matrix *)
391        val identity = polyVar (Atom.atom "$id", allNK (fn dv => [] --> matrix(Ty.DimVar dv)))
392    
393      (* zero tensor *)
394        val zero = polyVar (Atom.atom "$zero", all ([SK],
395                fn [Ty.SHAPE dd] => [] --> Ty.T_Tensor(Ty.ShapeVar dd)))
396    
397      (* sequence subscript *)
398        val subscript = polyVar (Atom.atom "$sub", all ([TK, NK],
399                fn [Ty.TYPE tv, Ty.DIM d] =>
400                  [Ty.T_Sequence(Ty.T_Var tv, Ty.DimVar d), Ty.T_Int] --> Ty.T_Var tv))
401      end (* local *)      end (* local *)
402    end    end

Legend:
Removed from v.83  
changed lines
  Added in v.1640

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