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/basis/basis-vars.sml revision 81, Wed May 26 17:28:54 2010 UTC branches/lamont/src/compiler/basis/basis-vars.sml revision 3272, Fri Oct 9 19:23:16 2015 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 52  Line 53 
53     * by the argument type signature, where     * by the argument type signature, where
54     *    i  -- int     *    i  -- int
55     *    b  -- bool     *    b  -- bool
56       *s  -- string
57     *    r  -- real (tensor[])     *    r  -- real (tensor[])
58     *    t  -- tensor[shape]     *    t  -- tensor[shape]
59       *    f  -- field#k(d)[shape]
60       *    d  -- ty{}
61       *    T  -- ty
62     *)     *)
63    
64      (* concatenation of sequences *)
65        val at_dT = polyVar (N.op_at, all([TK],
66              fn [Ty.TYPE tv] => let
67                  val seqTyc = Ty.T_DynSequence(Ty.T_Var tv)
68                  in
69                    [seqTyc, Ty.T_Var tv] --> seqTyc
70                  end))
71        val at_Td = polyVar (N.op_at, all([TK],
72              fn [Ty.TYPE tv] => let
73                  val seqTyc = Ty.T_DynSequence(Ty.T_Var tv)
74                  in
75                    [Ty.T_Var tv, seqTyc] --> seqTyc
76                  end))
77        val at_dd = polyVar (N.op_at, all([TK],
78              fn [Ty.TYPE tv] => let
79                  val seqTyc = Ty.T_DynSequence(Ty.T_Var tv)
80                  in
81                    [seqTyc, seqTyc] --> seqTyc
82                  end))
83    
84      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)
85      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
86              val t = Ty.T_Tensor(Ty.ShapeVar dd)              val t = Ty.T_Tensor(Ty.ShapeVar dd)
87              in              in
88                [t, t] --> t                [t, t] --> t
89              end))              end))
90        val add_ff = polyVar(N.op_add, all([DK,NK,SK],
91              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
92                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
93                in
94                  [t, t] --> t
95                end))
96        val add_fr = polyVar(N.op_add, all([DK,NK], (* field + scalar *)
97              fn [Ty.DIFF k, Ty.DIM d] => let
98                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
99                in
100                  [t, Ty.realTy] --> t
101                end))
102        val add_rf = polyVar(N.op_add, all([DK,NK], (* scalar + field *)
103              fn [Ty.DIFF k, Ty.DIM d] => let
104                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
105                in
106                  [Ty.realTy, t] --> t
107                end))
108    
109      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)
110      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 112 
112              in              in
113                [t, t] --> t                [t, t] --> t
114              end))              end))
115        val sub_ff = polyVar(N.op_sub, all([DK,NK,SK],
116              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
117                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
118                in
119                  [t, t] --> t
120                end))
121        val sub_fr = polyVar(N.op_sub, all([DK,NK], (* field - scalar *)
122              fn [Ty.DIFF k, Ty.DIM d] => let
123                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
124                in
125                  [t, Ty.realTy] --> t
126                end))
127        val sub_rf = polyVar(N.op_sub, all([DK,NK], (* scalar - field *)
128              fn [Ty.DIFF k, Ty.DIM d] => let
129                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
130                in
131                  [Ty.realTy, t] --> t
132                end))
133    
134    (* 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
135     * takes precedence over mul_rt and mul_tr!     * takes precedence over mul_rt and mul_tr!
# Line 85  Line 146 
146              in              in
147                [t, Ty.realTy] --> t                [t, Ty.realTy] --> t
148              end))              end))
149        val mul_rf = polyVar(N.op_mul, all([DK,NK,SK],
150              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
151                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
152                in
153                  [Ty.realTy, t] --> t
154                end))
155        val mul_fr = polyVar(N.op_mul, all([DK,NK,SK],
156              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
157                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
158                in
159                  [t, Ty.realTy] --> t
160                end))
161    
162      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)
163      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 166 
166              in              in
167                [t, Ty.realTy] --> t                [t, Ty.realTy] --> t
168              end))              end))
169        val div_fr = polyVar(N.op_div, all([DK,NK,SK],
170              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
171                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
172                in
173                  [t, Ty.realTy] --> t
174                end))
175    
176      (* distance of tensors *)
177        local
178          val vec2Ty = let
179                val t = tensor[N2]
180                in
181                  [t, t] --> Ty.realTy
182                end
183           val vec3Ty = let
184                val t = tensor[N3]
185                in
186                  [t, t] --> Ty.realTy
187                end
188        in
189        val dist_t2  = monoVar (N.fn_dist, vec2Ty)
190        val dist_t3  = monoVar (N.fn_dist, vec3Ty)
191        end
192    
193      (* exponentiation; we distinguish between integer and real exponents to allow x^2 to be compiled
194       * as x*x.
195       *)
196        val exp_ri = monoVar(N.op_exp, [Ty.realTy, Ty.T_Int] --> Ty.realTy)
197        val exp_rr = monoVar(N.op_exp, [Ty.realTy, Ty.realTy] --> Ty.realTy)
198    
199        val convolve_vk = polyVar (N.op_convolve, all([DK, NK, SK],
200                fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
201                    val k = Ty.DiffVar(k, 0)
202                    val d = Ty.DimVar d
203                    val dd = Ty.ShapeVar dd
204                    in
205                      [Ty.T_Image{dim=d, shape=dd}, Ty.T_Kernel k]
206                        --> field(k, d, dd)
207                    end))
208        val convolve_kv = polyVar (N.op_convolve, all([DK, NK, SK],
209                fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
210                    val k = Ty.DiffVar(k, 0)
211                    val d = Ty.DimVar d
212                    val dd = Ty.ShapeVar dd
213                    in
214                      [Ty.T_Kernel k, Ty.T_Image{dim=d, shape=dd}]
215                        --> field(k, d, dd)
216                    end))
217    
218      (* curl on 2d and 3d vector fields *)
219        local
220          val diff0 = Ty.DiffConst 0
221          fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
222        in
223    (* FIXME: we want to be able to require that k > 0, but we don't have a way to do that! *)
224        val curl2D = polyVar (N.op_curl, all([DK],
225              fn [Ty.DIFF k] =>
226                [field' (Ty.DiffVar(k, 0), 2, [2])] --> field' (diff0, 2, [])))
227        val curl3D = polyVar (N.op_curl, all([DK],
228              fn [Ty.DIFF k] =>
229                [field' (Ty.DiffVar(k, 0), 3, [3])] --> field' (diff0, 2, [3])))
230        end (* local *)
231    
232      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)
233      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 248 
248      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)
249    
250    
251      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)
252      val neg_t = polyVar(N.op_neg, all([SK],      val neg_t = polyVar(N.op_neg, all([SK],
253            fn [Ty.SHAPE dd] => let            fn [Ty.SHAPE dd] => let
254                val t = Ty.T_Tensor(Ty.ShapeVar dd)                val t = Ty.T_Tensor(Ty.ShapeVar dd)
# Line 129  Line 264 
264                  [field(k, d, dd)] --> field(k, d, dd)                  [field(k, d, dd)] --> field(k, d, dd)
265                end))                end))
266    
267      (* clamp is overloaded at scalars and vectors *)
268        val clamp_rrr = monoVar(N.fn_clamp, [Ty.realTy, Ty.realTy, Ty.realTy] --> Ty.realTy)
269        val clamp_vvv = polyVar (N.fn_clamp, allNK(fn tv => let
270              val t = tensor[Ty.DimVar tv]
271              in
272                [t, t, t] --> t
273              end))
274    
275        val lerp3 = polyVar(N.fn_lerp, all([SK],
276              fn [Ty.SHAPE dd] => let
277                  val t = Ty.T_Tensor(Ty.ShapeVar dd)
278                  in
279                    [t, t, Ty.realTy] --> t
280                  end))
281        val lerp5 = polyVar(N.fn_lerp, all([SK],
282              fn [Ty.SHAPE dd] => let
283                  val t = Ty.T_Tensor(Ty.ShapeVar dd)
284                  in
285                    [t, t, Ty.realTy, Ty.realTy, Ty.realTy] --> t
286                  end))
287    
288        val all_rs = monoVar(N.fn_all, [Ty.realTy, Ty.T_String] --> Ty.realTy)
289    
290    
291      (* Eigenvalues/vectors of a matrix; we only support this operation on 2x2 and 3x3 matrices, so
292       * we overload the function.
293       *)
294        local
295          fun evals d = monoVar (N.fn_evals, [matrix d] --> Ty.T_Sequence(Ty.realTy, d))
296          fun evecs d = monoVar (N.fn_evecs, [matrix d] --> Ty.T_Sequence(tensor[d], d))
297        in
298        val evals2x2 = evals(Ty.DimConst 2)
299        val evecs2x2 = evecs(Ty.DimConst 2)
300        val evals3x3 = evals(Ty.DimConst 3)
301        val evecs3x3 = evecs(Ty.DimConst 3)
302        end
303    
304    
305    (***** non-overloaded operators, etc. *****)    (***** non-overloaded operators, etc. *****)
306    
307      val op_at = polyVar (N.op_at, all([DK, NK, SK],    (* C math functions *)
308        val mathFns : (MathFuns.name * Var.var) list = let
309              fun ty n = List.tabulate(MathFuns.arity n, fn _ => Ty.realTy) --> Ty.realTy
310              in
311                List.map (fn n => (n, monoVar(MathFuns.toAtom n, ty n))) MathFuns.allFuns
312              end
313    
314      (* pseudo-operator for probing a field *)
315        val op_probe = polyVar (N.op_at, 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
317                val k = Ty.DiffVar(k, 0)                val k = Ty.DiffVar(k, 0)
318                val d = Ty.DimVar d                val d = Ty.DimVar d
# Line 141  Line 321 
321                  [field(k, d, dd), tensor[d]] --> Ty.T_Tensor dd                  [field(k, d, dd), tensor[d]] --> Ty.T_Tensor dd
322                end))                end))
323    
324      val op_D = polyVar (N.op_D, all([DK, NK, SK],    (* differentiation of scalar fields *)
325            fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let      val op_D = polyVar (N.op_D, all([DK, NK],
326              fn [Ty.DIFF k, Ty.DIM d] => let
327                val k0 = Ty.DiffVar(k, 0)                val k0 = Ty.DiffVar(k, 0)
328                val km1 = Ty.DiffVar(k, ~1)                val km1 = Ty.DiffVar(k, ~1)
329                val d = Ty.DimVar d                val d = Ty.DimVar d
330                  in
331                    [field(k0, d, Ty.Shape[])]
332                      --> field(km1, d, Ty.Shape[d])
333                  end))
334      (* differetiation of higher-order tensor fields *)
335        val op_Dotimes = polyVar (N.op_Dotimes, all([DK, NK, SK, NK],
336              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd, Ty.DIM d'] => let
337                  val k0 = Ty.DiffVar(k, 0)
338                  val km1 = Ty.DiffVar(k, ~1)
339                  val d = Ty.DimVar d
340                  val d' = Ty.DimVar d'
341                val dd = Ty.ShapeVar dd                val dd = Ty.ShapeVar dd
342                in                in
343                  [field(k0, d, dd), tensor[d]]                  [field(k0, d, Ty.ShapeExt(dd, d'))]
344                    --> field(km1, d, Ty.ShapeExt(dd, d))                    --> field(km1, d, Ty.ShapeExt(Ty.ShapeExt(dd, d'), d))
345                end))                end))
346    
347      val op_norm = polyVar (N.op_norm, all([SK],      val op_norm = polyVar (N.op_norm, all([SK],
# Line 157  Line 349 
349    
350      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)
351    
   
352    (* functions *)    (* functions *)
353      val fn_CL = polyVar (N.fn_CL, ty([tensor[N3, N3]] --> Ty.vec3Ty))      local
354          val crossTy = let
355                val t = tensor[N3]
356                in
357                  [t, t] --> t
358                end
359        in
360        val op_cross = monoVar (N.op_cross, crossTy)
361        end
362    
363      val fn_convolve = polyVar (N.fn_convolve, all([DK, NK, SK],    (* Query functions *)
364              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let    (* distance of tensors *)
365                  val k = Ty.DiffVar(k, 0)      local
366          val implicit = fn [Ty.TYPE tv] => [Ty.realTy] --> Ty.T_DynSequence(Ty.T_Var tv)
367          val realTy = fn [Ty.TYPE tv] => [Ty.realTy, Ty.realTy] --> Ty.T_DynSequence(Ty.T_Var tv)
368          val vec2Ty = let
369                val t = tensor[N2]
370                in
371                  fn [Ty.TYPE tv] => [t, Ty.realTy] --> Ty.T_DynSequence(Ty.T_Var tv)
372                end
373           val vec3Ty = let
374                val t = tensor[N3]
375                in
376                  fn [Ty.TYPE tv] => [t, Ty.realTy] --> Ty.T_DynSequence(Ty.T_Var tv)
377                end
378        in
379        val fn_sphere_im  = polyVar (N.fn_sphere,all([TK], implicit))
380        val fn_sphere_r  = polyVar (N.fn_sphere,all([TK], realTy))
381        val fn_sphere_t2  = polyVar (N.fn_sphere,all([TK], vec2Ty))
382        val fn_sphere_t3 = polyVar (N.fn_sphere,all([TK], vec3Ty))
383        end
384    
385    
386      (* the inner product operator (including dot product) is treated as a special case in the
387       * typechecker.  It is not included in the basis environment, but we define its type scheme
388       * here.  There is an implicit constraint on its type to have the following scheme:
389       *
390       *     ALL[sigma1, d1, sigma2] . tensor[sigma1, d1] * tensor[d1, sigma2] -> tensor[sigma1, sigma2]
391       *)
392        val op_inner = polyVar (N.op_dot, all([SK, SK, SK],
393                fn [Ty.SHAPE s1, Ty.SHAPE s2, Ty.SHAPE s3] =>
394                    [Ty.T_Tensor(Ty.ShapeVar s1), Ty.T_Tensor(Ty.ShapeVar s2)]
395                      --> Ty.T_Tensor(Ty.ShapeVar s3)))
396    
397      (* the colon (or double-dot) product operator is treated as a special case in the
398       * typechecker.  It is not included in the basis environment, but we define its type
399       * schemehere.  There is an implicit constraint on its type to have the following scheme:
400       *
401       *     ALL[sigma1, d1, d2, sigma2] .
402       *       tensor[sigma1, d1, d2] * tensor[d1, d2, sigma2] -> tensor[sigma1, sigma2]
403       *)
404        val op_colon = polyVar (N.op_colon, all([SK, SK, SK],
405                fn [Ty.SHAPE s1, Ty.SHAPE s2, Ty.SHAPE s3] =>
406                    [Ty.T_Tensor(Ty.ShapeVar s1), Ty.T_Tensor(Ty.ShapeVar s2)]
407                      --> Ty.T_Tensor(Ty.ShapeVar s3)))
408    
409      (* load image from nrrd *)
410        val fn_image = polyVar (N.fn_image, all([NK, SK],
411                fn [Ty.DIM d, Ty.SHAPE dd] => let
412                  val d = Ty.DimVar d                  val d = Ty.DimVar d
413                  val dd = Ty.ShapeVar dd                  val dd = Ty.ShapeVar dd
414                  in                  in
415                    [Ty.T_Kernel k, Ty.T_Image{dim=d, shape=dd}]                    [Ty.T_String] --> Ty.T_Image{dim=d, shape=dd}
                     --> field(k, d, dd)  
416                  end))                  end))
417    
     val fn_cos = polyVar (N.fn_cos, ty([Ty.realTy] --> Ty.realTy))  
   
     val fn_dot = polyVar (N.fn_dot, allNK(fn tv => [tensor[Ty.DimVar tv]] --> tensor[Ty.DimVar tv]))  
   
418      val fn_inside = polyVar (N.fn_inside,       all([DK, NK, SK],      val fn_inside = polyVar (N.fn_inside,       all([DK, NK, SK],
419              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
420                  val k = Ty.DiffVar(k, 0)                  val k = Ty.DiffVar(k, 0)
# Line 185  Line 425 
425                      --> Ty.T_Bool                      --> Ty.T_Bool
426                  end))                  end))
427    
428      val fn_load = polyVar (N.fn_load,   all([NK, SK],      (* Reduction Operations *)
429              fn [Ty.DIM d, Ty.SHAPE dd] => let      val fn_rMean = monoVar (N.fn_mean, [Ty.realTy] --> Ty.realTy)
430                  val d = Ty.DimVar d      val fn_rAll = monoVar (N.fn_all, [Ty.T_Bool] --> Ty.T_Bool)
431                  val dd = Ty.ShapeVar dd      val fn_rMax = monoVar (N.fn_max, [Ty.realTy] --> Ty.realTy)
432        val fn_rMin = monoVar (N.fn_min, [Ty.realTy] --> Ty.realTy)
433        val fn_rExists = monoVar (N.fn_exists, [Ty.T_Bool] --> Ty.T_Bool)
434        val fn_rProduct = monoVar (N.fn_product, [Ty.realTy] --> Ty.realTy)
435        val fn_rSum = monoVar (N.fn_sum, [Ty.realTy] --> Ty.realTy)
436        val fn_rVariance = monoVar (N.fn_variance, [Ty.realTy] --> Ty.realTy)
437    
438    
439      (* load dynamic sequence from nrrd *)
440        val fn_load = polyVar (N.fn_load, all([TK],
441                fn [Ty.TYPE tv] => [Ty.T_String] --> Ty.T_DynSequence(Ty.T_Var tv)))
442    
443        val fn_length = polyVar (N.fn_length, all([TK],
444                fn [Ty.TYPE tv] => [Ty.T_DynSequence(Ty.T_Var tv)] --> Ty.T_Int))
445    
446        val fn_max = monoVar (N.fn_max, [Ty.realTy, Ty.realTy] --> Ty.realTy)
447        val fn_min = monoVar (N.fn_min, [Ty.realTy, Ty.realTy] --> Ty.realTy)
448    
449        val fn_modulate = polyVar (N.fn_modulate, all([NK],
450                fn [Ty.DIM d] => let
451                    val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])
452                  in                  in
453                    [Ty.T_String] --> Ty.T_Image{dim=d, shape=dd}                    [t, t] --> t
454                  end))                  end))
455    
456      val fn_pow = polyVar (N.fn_pow, ty([Ty.realTy, Ty.realTy] --> Ty.realTy))      val fn_normalize = polyVar (N.fn_normalize, all([NK],
457                fn [Ty.DIM d] => let
458                    val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])
459                    in
460                      [t] --> t
461                    end))
462    
463  (*    (* outer product *)
464      val fn_principleEvec = Atom.atom "principleEvec"      local
465  *)        fun mkOuter [Ty.DIM d1, Ty.DIM d2] = let
466                val vt1 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1])
467                val vt2 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d2])
468                val mt = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1, Ty.DimVar d2])
469                in
470                  [vt1, vt2] --> mt
471                end
472        in
473        val op_outer = polyVar (N.op_outer, all([NK, NK], mkOuter))
474        end
475    
476      val fn_sin = polyVar (N.fn_sin, ty([Ty.realTy] --> Ty.realTy))      val fn_principleEvec = polyVar (N.fn_principleEvec, all([NK],
477                fn [Ty.DIM d] => let
478                    val d = Ty.DimVar d
479                    in
480                      [matrix d] --> tensor[d]
481                    end))
482    
483        val fn_trace = polyVar (N.fn_trace, all([NK],
484                fn [Ty.DIM d] => [matrix(Ty.DimVar d)] --> Ty.realTy))
485    
486        val fn_transpose = polyVar (N.fn_transpose, all([NK, NK],
487                fn [Ty.DIM d1, Ty.DIM d2] =>
488                  [tensor[Ty.DimVar d1, Ty.DimVar d2]] --> tensor[Ty.DimVar d2, Ty.DimVar d1]))
489    
490    (* kernels *)    (* kernels *)
491      val kn_bspln3 = polyVar (N.kn_bspln3, ty(Ty.T_Kernel(Ty.DiffConst 2)))  (* FIXME: we should really get the continuity info from the kernels themselves *)
492      val kn_tent = polyVar (N.kn_tent, ty(Ty.T_Kernel(Ty.DiffConst 0)))      val kn_bspln3 = monoVar (N.kn_bspln3, Ty.T_Kernel(Ty.DiffConst 2))
493        val kn_bspln5 = monoVar (N.kn_bspln5, Ty.T_Kernel(Ty.DiffConst 4))
494        val kn_c4hexic = monoVar (N.kn_c4hexic, Ty.T_Kernel(Ty.DiffConst 4))
495        val kn_ctmr = monoVar (N.kn_ctmr, Ty.T_Kernel(Ty.DiffConst 1))
496        val kn_tent = monoVar (N.kn_tent, Ty.T_Kernel(Ty.DiffConst 0))
497      (* kernels with false claims of differentiability, for pedagogy *)
498        val kn_c1tent = monoVar (N.kn_c1tent, Ty.T_Kernel(Ty.DiffConst 1))
499        val kn_c2ctmr = monoVar (N.kn_c2ctmr, Ty.T_Kernel(Ty.DiffConst 2))
500    
501      (***** internal variables *****)
502    
503      (* integer to real conversion *)
504        val i2r = monoVar (Atom.atom "$i2r", [Ty.T_Int] --> Ty.realTy)
505    
506      (* identity matrix *)
507        val identity = polyVar (Atom.atom "$id", allNK (fn dv => [] --> matrix(Ty.DimVar dv)))
508    
509      (* zero tensor *)
510        val zero = polyVar (Atom.atom "$zero", all ([SK],
511                fn [Ty.SHAPE dd] => [] --> Ty.T_Tensor(Ty.ShapeVar dd)))
512    
513      (* sequence subscript *)
514        val subscript = polyVar (Atom.atom "$sub", all ([TK, NK],
515                fn [Ty.TYPE tv, Ty.DIM d] =>
516                  [Ty.T_Sequence(Ty.T_Var tv, Ty.DimVar d), Ty.T_Int] --> Ty.T_Var tv))
517    
518        val dynSubscript = polyVar (Atom.atom "$dynsub", all ([TK],
519                fn [Ty.TYPE tv] => [Ty.T_DynSequence(Ty.T_Var tv), Ty.T_Int] --> Ty.T_Var tv))
520    
521      end (* local *)      end (* local *)
522    end    end

Legend:
Removed from v.81  
changed lines
  Added in v.3272

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