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

SCM Repository

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

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

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

trunk/src/compiler/basis/basis-vars.sml revision 169, Thu Jul 22 20:07:37 2010 UTC branches/vis12/src/compiler/basis/basis-vars.sml revision 1925, Sat Jun 23 14:16:09 2012 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       *    d  -- ty{}
60       *    T  -- ty
61     *)     *)
62    
63      (* concatenation of sequences *)
64        val at_dT = polyVar (N.op_at, all([TK],
65              fn [Ty.TYPE tv] => let
66                  val seqTyc = Ty.T_DynSequence(Ty.T_Var tv)
67                  in
68                    [seqTyc, Ty.T_Var tv] --> seqTyc
69                  end))
70        val at_Td = polyVar (N.op_at, all([TK],
71              fn [Ty.TYPE tv] => let
72                  val seqTyc = Ty.T_DynSequence(Ty.T_Var tv)
73                  in
74                    [Ty.T_Var tv, seqTyc] --> seqTyc
75                  end))
76        val at_dd = polyVar (N.op_at, all([TK],
77              fn [Ty.TYPE tv] => let
78                  val seqTyc = Ty.T_DynSequence(Ty.T_Var tv)
79                  in
80                    [seqTyc, seqTyc] --> seqTyc
81                  end))
82    
83      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)
84      val add_tt = polyVar(N.op_add, all([SK], fn [Ty.SHAPE dd] => let      val add_tt = polyVar(N.op_add, all([SK], fn [Ty.SHAPE dd] => let
85              val t = Ty.T_Tensor(Ty.ShapeVar dd)              val t = Ty.T_Tensor(Ty.ShapeVar dd)
86              in              in
87                [t, t] --> t                [t, t] --> t
88              end))              end))
89        val add_ff = polyVar(N.op_add, all([DK,NK,SK],
90              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
91                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
92                in
93                  [t, t] --> t
94                end))
95    
96      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)
97      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 99 
99              in              in
100                [t, t] --> t                [t, t] --> t
101              end))              end))
102        val sub_ff = polyVar(N.op_sub, 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                  [t, t] --> t
107                end))
108    
109    (* 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
110     * takes precedence over mul_rt and mul_tr!     * takes precedence over mul_rt and mul_tr!
# Line 85  Line 121 
121              in              in
122                [t, Ty.realTy] --> t                [t, Ty.realTy] --> t
123              end))              end))
124        val mul_rf = polyVar(N.op_mul, all([DK,NK,SK],
125              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
126                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
127                in
128                  [Ty.realTy, t] --> t
129                end))
130        val mul_fr = polyVar(N.op_mul, all([DK,NK,SK],
131              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
132                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
133                in
134                  [t, Ty.realTy] --> t
135                end))
136    
137      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)
138      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 141 
141              in              in
142                [t, Ty.realTy] --> t                [t, Ty.realTy] --> t
143              end))              end))
144        val div_fr = polyVar(N.op_div, all([DK,NK,SK],
145              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
146                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
147                in
148                  [t, Ty.realTy] --> t
149                end))
150    
151      (* exponentiation; we distinguish between integer and real exponents to allow x^2 to be compiled
152       * as x*x.
153       *)
154        val exp_ri = monoVar(N.op_exp, [Ty.realTy, Ty.T_Int] --> Ty.realTy)
155        val exp_rr = monoVar(N.op_exp, [Ty.realTy, Ty.realTy] --> Ty.realTy)
156    
157        val convolve_vk = polyVar (N.op_convolve, all([DK, NK, SK],
158                fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
159                    val k = Ty.DiffVar(k, 0)
160                    val d = Ty.DimVar d
161                    val dd = Ty.ShapeVar dd
162                    in
163                      [Ty.T_Image{dim=d, shape=dd}, Ty.T_Kernel k]
164                        --> field(k, d, dd)
165                    end))
166        val convolve_kv = polyVar (N.op_convolve, all([DK, NK, SK],
167                fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
168                    val k = Ty.DiffVar(k, 0)
169                    val d = Ty.DimVar d
170                    val dd = Ty.ShapeVar dd
171                    in
172                      [Ty.T_Kernel k, Ty.T_Image{dim=d, shape=dd}]
173                        --> field(k, d, dd)
174                    end))
175    
176      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)
177      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 192 
192      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)
193    
194    
195      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)
196      val neg_t = polyVar(N.op_neg, all([SK],      val neg_t = polyVar(N.op_neg, all([SK],
197            fn [Ty.SHAPE dd] => let            fn [Ty.SHAPE dd] => let
198                val t = Ty.T_Tensor(Ty.ShapeVar dd)                val t = Ty.T_Tensor(Ty.ShapeVar dd)
# Line 129  Line 208 
208                  [field(k, d, dd)] --> field(k, d, dd)                  [field(k, d, dd)] --> field(k, d, dd)
209                end))                end))
210    
211      (* clamp is overloaded at scalars and vectors *)
212        val clamp_rrr = monoVar(N.fn_clamp, [Ty.realTy, Ty.realTy, Ty.realTy] --> Ty.realTy)
213        val clamp_vvv = polyVar (N.fn_clamp, allNK(fn tv => let
214              val t = tensor[Ty.DimVar tv]
215              in
216                [t, t, t] --> t
217              end))
218    
219        val lerp3 = polyVar(N.fn_lerp, all([SK],
220              fn [Ty.SHAPE dd] => let
221                  val t = Ty.T_Tensor(Ty.ShapeVar dd)
222                  in
223                    [t, t, Ty.realTy] --> t
224                  end))
225        val lerp5 = polyVar(N.fn_lerp, all([SK],
226              fn [Ty.SHAPE dd] => let
227                  val t = Ty.T_Tensor(Ty.ShapeVar dd)
228                  in
229                    [t, t, Ty.realTy, Ty.realTy, Ty.realTy] --> t
230                  end))
231    
232      (* Eigenvalues/vectors of a matrix; we only support this operation on 2x2 and 3x3 matrices, so
233       * we overload the function.
234       *)
235        local
236          fun evals d = monoVar (N.fn_evals, [matrix d] --> Ty.T_Sequence(Ty.realTy, d))
237          fun evecs d = monoVar (N.fn_evecs, [matrix d] --> Ty.T_Sequence(tensor[d], d))
238        in
239        val evals2x2 = evals(Ty.DimConst 2)
240        val evecs2x2 = evecs(Ty.DimConst 2)
241        val evals3x3 = evals(Ty.DimConst 3)
242        val evecs3x3 = evecs(Ty.DimConst 3)
243        end
244    
245    
246    (***** non-overloaded operators, etc. *****)    (***** non-overloaded operators, etc. *****)
247    
248      val op_at = polyVar (N.op_at, all([DK, NK, SK],    (* C math functions *)
249        val mathFns : (MathFuns.name * Var.var) list = let
250              fun ty n = List.tabulate(MathFuns.arity n, fn _ => Ty.realTy) --> Ty.realTy
251              in
252                List.map (fn n => (n, monoVar(MathFuns.toAtom n, ty n))) MathFuns.allFuns
253              end
254    
255      (* pseudo-operator for probing a field *)
256        val op_probe = polyVar (N.op_at, all([DK, NK, SK],
257            fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let            fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
258                val k = Ty.DiffVar(k, 0)                val k = Ty.DiffVar(k, 0)
259                val d = Ty.DimVar d                val d = Ty.DimVar d
# Line 141  Line 262 
262                  [field(k, d, dd), tensor[d]] --> Ty.T_Tensor dd                  [field(k, d, dd), tensor[d]] --> Ty.T_Tensor dd
263                end))                end))
264    
265      val op_D = polyVar (N.op_D, all([DK, NK, SK],    (* differentiation of scalar fields *)
266            fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let      val op_D = polyVar (N.op_D, all([DK, NK],
267              fn [Ty.DIFF k, Ty.DIM d] => let
268                  val k0 = Ty.DiffVar(k, 0)
269                  val km1 = Ty.DiffVar(k, ~1)
270                  val d = Ty.DimVar d
271                  in
272                    [field(k0, d, Ty.Shape[])]
273                      --> field(km1, d, Ty.Shape[d])
274                  end))
275      (* differetiation of higher-order tensor fields *)
276        val op_Dotimes = polyVar (N.op_Dotimes, all([DK, NK, SK, NK],
277              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd, Ty.DIM d'] => let
278                val k0 = Ty.DiffVar(k, 0)                val k0 = Ty.DiffVar(k, 0)
279                val km1 = Ty.DiffVar(k, ~1)                val km1 = Ty.DiffVar(k, ~1)
280                val d = Ty.DimVar d                val d = Ty.DimVar d
281                  val d' = Ty.DimVar d'
282                val dd = Ty.ShapeVar dd                val dd = Ty.ShapeVar dd
283                in                in
284                  [field(k0, d, dd)]                  [field(k0, d, Ty.ShapeExt(dd, d'))]
285                    --> field(km1, d, Ty.ShapeExt(dd, d))                    --> field(km1, d, Ty.ShapeExt(Ty.ShapeExt(dd, d'), d))
286                end))                end))
287    
288      val op_norm = polyVar (N.op_norm, all([SK],      val op_norm = polyVar (N.op_norm, all([SK],
# Line 157  Line 290 
290    
291      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)
292    
     val op_subscript = polyVar (N.op_subscript, all([SK, NK],  
           fn [Ty.SHAPE dd, Ty.DIM d] => let  
               val dd = Ty.ShapeVar dd  
               val d = Ty.DimVar d  
               in  
                 [Ty.T_Tensor(Ty.ShapeExt(dd, d)), Ty.T_Int]  
                   --> Ty.T_Tensor dd  
               end))  
   
293    (* functions *)    (* functions *)
294      val fn_CL = polyVar (N.fn_CL, ty([tensor[N3, N3]] --> Ty.realTy))      local
295          val crossTy = let
296      val fn_convolve = polyVar (N.fn_convolve, all([DK, NK, SK],              val t = tensor[N3]
             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  
297                  in                  in
298                    [Ty.T_Kernel k, Ty.T_Image{dim=d, shape=dd}]                [t, t] --> t
299                      --> field(k, d, dd)              end
                 end))  
   
     val fn_cos = monoVar (N.fn_cos, [Ty.realTy] --> Ty.realTy)  
   
     val fn_dot = polyVar (N.fn_dot, allNK(fn tv => let  
           val t = tensor[Ty.DimVar tv]  
300            in            in
301              [t, t] --> Ty.realTy      val op_cross = monoVar (N.op_cross, crossTy)
302            end))      end
303    
304      (* the inner product operator (including dot product) is treated as a special case in the
305       * typechecker.  It is not included in the basis environment, but we define its type scheme
306       * here.  There is an implicit constraint on its type to have the following scheme:
307       *
308       *     ALL[sigma1, d1, sigma2] . tensor[sigma1, d1] * tensor[d1, sigma2] -> tensor[sigma1, sigma2]
309       *)
310        val op_inner = polyVar (N.op_dot, all([SK, SK, SK],
311                fn [Ty.SHAPE s1, Ty.SHAPE s2, Ty.SHAPE s3] =>
312                    [Ty.T_Tensor(Ty.ShapeVar s1), Ty.T_Tensor(Ty.ShapeVar s2)]
313                      --> Ty.T_Tensor(Ty.ShapeVar s3)))
314    
315      val fn_inside = polyVar (N.fn_inside, all([DK, NK, SK],      val fn_inside = polyVar (N.fn_inside, all([DK, NK, SK],
316              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
# Line 205  Line 330 
330                    [Ty.T_String] --> Ty.T_Image{dim=d, shape=dd}                    [Ty.T_String] --> Ty.T_Image{dim=d, shape=dd}
331                  end))                  end))
332    
333        val fn_length = polyVar (N.fn_length, all([TK],
334                fn [Ty.TYPE tv] => [Ty.T_DynSequence(Ty.T_Var tv)] --> Ty.T_Int))
335    
336      val fn_max = monoVar (N.fn_max, [Ty.realTy, Ty.realTy] --> Ty.realTy)      val fn_max = monoVar (N.fn_max, [Ty.realTy, Ty.realTy] --> Ty.realTy)
337      val fn_min = monoVar (N.fn_min, [Ty.realTy, Ty.realTy] --> Ty.realTy)      val fn_min = monoVar (N.fn_min, [Ty.realTy, Ty.realTy] --> Ty.realTy)
338    
# Line 215  Line 343 
343                    [t, t] --> t                    [t, t] --> t
344                  end))                  end))
345    
346      val fn_pow = monoVar (N.fn_pow, [Ty.realTy, Ty.realTy] --> Ty.realTy)      val fn_normalize = polyVar (N.fn_normalize, all([NK],
347                fn [Ty.DIM d] => let
348                    val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])
349                    in
350                      [t] --> t
351                    end))
352    
353      (* outer product *)
354        local
355          fun mkOuter [Ty.DIM d1, Ty.DIM d2] = let
356                val vt1 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1])
357                val vt2 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d2])
358                val mt = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1, Ty.DimVar d2])
359                in
360                  [vt1, vt2] --> mt
361                end
362        in
363        val op_outer = polyVar (N.op_outer, all([NK, NK], mkOuter))
364        end
365    
366      val fn_principleEvec = polyVar (N.fn_principleEvec, all([NK],      val fn_principleEvec = polyVar (N.fn_principleEvec, all([NK],
367              fn [Ty.DIM d] => let              fn [Ty.DIM d] => let
368                  val d = Ty.DimVar d                  val d = Ty.DimVar d
369                  in                  in
370                    [tensor[d,d]] --> tensor[d]                    [matrix d] --> tensor[d]
371                  end))                  end))
372    
373      val fn_sin = monoVar (N.fn_sin, [Ty.realTy] --> Ty.realTy)      val fn_trace = polyVar (N.fn_trace, all([NK],
374                fn [Ty.DIM d] => [matrix(Ty.DimVar d)] --> Ty.realTy))
375    
376    (* kernels *)    (* kernels *)
377  (* FIXME: we should really get the continuity info from the kernels themselves *)  (* FIXME: we should really get the continuity info from the kernels themselves *)
378      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))
379      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))
380      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))
381      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))
382      (* kernels with false claims of differentiability, for pedagogy *)
383    (* internal variables *)      val kn_c1tent = monoVar (N.kn_c1tent, Ty.T_Kernel(Ty.DiffConst 1))
384      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))
385    
386      (***** internal variables *****)
387    
388      (* integer to real conversion *)
389        val i2r = monoVar (Atom.atom "$i2r", [Ty.T_Int] --> Ty.realTy)
390    
391      (* identity matrix *)
392        val identity = polyVar (Atom.atom "$id", allNK (fn dv => [] --> matrix(Ty.DimVar dv)))
393    
394      (* zero tensor *)
395        val zero = polyVar (Atom.atom "$zero", all ([SK],
396                fn [Ty.SHAPE dd] => [] --> Ty.T_Tensor(Ty.ShapeVar dd)))
397    
398      (* sequence subscript *)
399        val subscript = polyVar (Atom.atom "$sub", all ([TK, NK],
400                fn [Ty.TYPE tv, Ty.DIM d] =>
401                  [Ty.T_Sequence(Ty.T_Var tv, Ty.DimVar d), Ty.T_Int] --> Ty.T_Var tv))
402      end (* local *)      end (* local *)
403    end    end

Legend:
Removed from v.169  
changed lines
  Added in v.1925

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