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 103, Tue Jun 1 16:04:04 2010 UTC branches/charisee/src/compiler/basis/basis-vars.sml revision 2603, Thu Apr 24 03:58:37 2014 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        val add_fr = polyVar(N.op_add, all([DK,NK], (* field + scalar *)
74              fn [Ty.DIFF k, Ty.DIM d] => let
75                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
76                in
77                  [t, Ty.realTy] --> t
78                end))
79        val add_rf = polyVar(N.op_add, all([DK,NK], (* scalar + field *)
80              fn [Ty.DIFF k, Ty.DIM d] => let
81                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
82                in
83                  [Ty.realTy, t] --> t
84                end))
85    
86      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)
87      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 89 
89              in              in
90                [t, t] --> t                [t, t] --> t
91              end))              end))
92        val sub_ff = polyVar(N.op_sub, all([DK,NK,SK],
93              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
94                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
95                in
96                  [t, t] --> t
97                end))
98        val sub_fr = polyVar(N.op_sub, all([DK,NK], (* field - scalar *)
99              fn [Ty.DIFF k, Ty.DIM d] => let
100                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
101                in
102                  [t, Ty.realTy] --> t
103                end))
104        val sub_rf = polyVar(N.op_sub, all([DK,NK], (* scalar - field *)
105              fn [Ty.DIFF k, Ty.DIM d] => let
106                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
107                in
108                  [Ty.realTy, t] --> t
109                end))
110    
111    (* 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
112     * takes precedence over mul_rt and mul_tr!     * takes precedence over mul_rt and mul_tr!
# Line 85  Line 123 
123              in              in
124                [t, Ty.realTy] --> t                [t, Ty.realTy] --> t
125              end))              end))
126        val mul_rf = polyVar(N.op_mul, all([DK,NK,SK],
127              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
128                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
129                in
130                  [Ty.realTy, t] --> t
131                end))
132        val mul_fr = polyVar(N.op_mul, all([DK,NK,SK],
133              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
134                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
135                in
136                  [t, Ty.realTy] --> t
137                end))
138    
139    
140    (****MARK *)
141        val mul_ss = polyVar(N.op_mul, all([DK,NK],
142        fn [Ty.DIFF k, Ty.DIM d] => let
143            val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape []}
144            in
145            [t, t] --> t
146            end))
147    (*Right now assumes same level of k*)
148        val mul_sf = polyVar(N.op_mul, all([DK,NK,SK],
149        fn [Ty.DIFF k, Ty.DIM d,Ty.SHAPE dd] => let
150        val a = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape []}
151        val b = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
152        in
153            [a,b] --> b
154        end))
155    
156    val mul_fs = polyVar(N.op_mul, all([DK,NK,SK],
157    fn [Ty.DIFF k, Ty.DIM d,Ty.SHAPE dd] => let
158    val a = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape []}
159    val b = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
160    in
161    [b,a] --> b
162    end))
163    
164    
165      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)
166      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 169 
169              in              in
170                [t, Ty.realTy] --> t                [t, Ty.realTy] --> t
171              end))              end))
172        val div_fr = polyVar(N.op_div, all([DK,NK,SK],
173              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
174                val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
175                in
176                  [t, Ty.realTy] --> t
177                end))
178    
179      (* exponentiation; we distinguish between integer and real exponents to allow x^2 to be compiled
180       * as x*x.
181       *)
182        val exp_ri = monoVar(N.op_exp, [Ty.realTy, Ty.T_Int] --> Ty.realTy)
183        val exp_rr = monoVar(N.op_exp, [Ty.realTy, Ty.realTy] --> Ty.realTy)
184    
185        val convolve_vk = polyVar (N.op_convolve, all([DK, NK, SK],
186                fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
187                    val k = Ty.DiffVar(k, 0)
188                    val d = Ty.DimVar d
189                    val dd = Ty.ShapeVar dd
190                    in
191                      [Ty.T_Image{dim=d, shape=dd}, Ty.T_Kernel k]
192                        --> field(k, d, dd)
193                    end))
194        val convolve_kv = polyVar (N.op_convolve, all([DK, NK, SK],
195                fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
196                    val k = Ty.DiffVar(k, 0)
197                    val d = Ty.DimVar d
198                    val dd = Ty.ShapeVar dd
199                    in
200                      [Ty.T_Kernel k, Ty.T_Image{dim=d, shape=dd}]
201                        --> field(k, d, dd)
202                    end))
203    
204      (* curl on 2d and 3d vector fields *)
205        local
206          val diff0 = Ty.DiffConst 0
207          fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
208        in
209    (* FIXME: we want to be able to require that k > 0, but we don't have a way to do that! *)
210        val curl2D = polyVar (N.op_curl, all([DK],
211              fn [Ty.DIFF k] =>
212                [field' (Ty.DiffVar(k, 0), 2, [2])] --> field' (diff0, 2, [])))
213        val curl3D = polyVar (N.op_curl, all([DK],
214              fn [Ty.DIFF k] =>
215                [field' (Ty.DiffVar(k, 0), 3, [3])] --> field' (diff0, 2, [3])))
216        end (* local *)
217    
218      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)
219      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 234 
234      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)
235    
236    
237      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)
238      val neg_t = polyVar(N.op_neg, all([SK],      val neg_t = polyVar(N.op_neg, all([SK],
239            fn [Ty.SHAPE dd] => let            fn [Ty.SHAPE dd] => let
240                val t = Ty.T_Tensor(Ty.ShapeVar dd)                val t = Ty.T_Tensor(Ty.ShapeVar dd)
# Line 129  Line 250 
250                  [field(k, d, dd)] --> field(k, d, dd)                  [field(k, d, dd)] --> field(k, d, dd)
251                end))                end))
252    
253      (* clamp is overloaded at scalars and vectors *)
254        val clamp_rrr = monoVar(N.fn_clamp, [Ty.realTy, Ty.realTy, Ty.realTy] --> Ty.realTy)
255        val clamp_vvv = polyVar (N.fn_clamp, allNK(fn tv => let
256              val t = tensor[Ty.DimVar tv]
257              in
258                [t, t, t] --> t
259              end))
260    
261        val lerp3 = polyVar(N.fn_lerp, all([SK],
262              fn [Ty.SHAPE dd] => let
263                  val t = Ty.T_Tensor(Ty.ShapeVar dd)
264                  in
265                    [t, t, Ty.realTy] --> t
266                  end))
267        val lerp5 = polyVar(N.fn_lerp, all([SK],
268              fn [Ty.SHAPE dd] => let
269                  val t = Ty.T_Tensor(Ty.ShapeVar dd)
270                  in
271                    [t, t, Ty.realTy, Ty.realTy, Ty.realTy] --> t
272                  end))
273    
274      (* Eigenvalues/vectors of a matrix; we only support this operation on 2x2 and 3x3 matrices, so
275       * we overload the function.
276       *)
277        local
278          fun evals d = monoVar (N.fn_evals, [matrix d] --> Ty.T_Sequence(Ty.realTy, d))
279          fun evecs d = monoVar (N.fn_evecs, [matrix d] --> Ty.T_Sequence(tensor[d], d))
280        in
281        val evals2x2 = evals(Ty.DimConst 2)
282        val evecs2x2 = evecs(Ty.DimConst 2)
283        val evals3x3 = evals(Ty.DimConst 3)
284        val evecs3x3 = evecs(Ty.DimConst 3)
285        end
286    
287    
288    (***** non-overloaded operators, etc. *****)    (***** non-overloaded operators, etc. *****)
289    
290      val op_at = polyVar (N.op_at, all([DK, NK, SK],    (* C math functions *)
291        val mathFns : (MathFuns.name * Var.var) list = let
292              fun ty n = List.tabulate(MathFuns.arity n, fn _ => Ty.realTy) --> Ty.realTy
293              in
294                List.map (fn n => (n, monoVar(MathFuns.toAtom n, ty n))) MathFuns.allFuns
295              end
296    
297      (* pseudo-operator for probing a field *)
298        val op_probe = polyVar (N.op_at, all([DK, NK, SK],
299            fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let            fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
300                val k = Ty.DiffVar(k, 0)                val k = Ty.DiffVar(k, 0)
301                val d = Ty.DimVar d                val d = Ty.DimVar d
# Line 141  Line 304 
304                  [field(k, d, dd), tensor[d]] --> Ty.T_Tensor dd                  [field(k, d, dd), tensor[d]] --> Ty.T_Tensor dd
305                end))                end))
306    
307      val op_D = polyVar (N.op_D, all([DK, NK, SK],    (* differentiation of scalar fields *)
308            fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let      val op_D = polyVar (N.op_D, all([DK, NK],
309              fn [Ty.DIFF k, Ty.DIM d] => let
310                  val k0 = Ty.DiffVar(k, 0)
311                  val km1 = Ty.DiffVar(k, ~1)
312                  val d = Ty.DimVar d
313                  in
314                    [field(k0, d, Ty.Shape[])]
315                      --> field(km1, d, Ty.Shape[d])
316                  end))
317      (* differentiation of higher-order tensor fields *)
318        val op_Dotimes = polyVar (N.op_Dotimes, all([DK, NK, SK, NK],
319              fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd, Ty.DIM d'] => let
320                val k0 = Ty.DiffVar(k, 0)                val k0 = Ty.DiffVar(k, 0)
321                val km1 = Ty.DiffVar(k, ~1)                val km1 = Ty.DiffVar(k, ~1)
322                val d = Ty.DimVar d                val d = Ty.DimVar d
323                  val d' = Ty.DimVar d'
324                val dd = Ty.ShapeVar dd                val dd = Ty.ShapeVar dd
325                in                in
326                  [field(k0, d, dd)]                  [field(k0, d, Ty.ShapeExt(dd, d'))]
327                    --> field(km1, d, Ty.ShapeExt(dd, d))                    --> field(km1, d, Ty.ShapeExt(Ty.ShapeExt(dd, d'), d))
328                  end))
329    
330    
331    
332       (* divergence differentiation of higher-order tensor fields *)
333        val op_Ddot = polyVar (N.op_Ddot, all([DK, NK, SK, NK],
334            fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd, Ty.DIM d'] => let
335                val k0 = Ty.DiffVar(k, 0)
336                val km1 = Ty.DiffVar(k, ~1)
337                val d = Ty.DimVar d
338                val d' = Ty.DimVar d'
339                val ddK = Ty.ShapeVar dd
340                in
341                    [field(k0, d, Ty.ShapeExt(ddK, d'))]
342                    --> field(k0, d, Ty.ShapeVar dd)
343                end))                end))
344    
345      val op_norm = polyVar (N.op_norm, all([SK],      val op_norm = polyVar (N.op_norm, all([SK],
# Line 157  Line 347 
347    
348      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)
349    
350      val op_subscript = polyVar (N.op_subscript, all([SK, NK],    (* functions *)
351            fn [Ty.SHAPE dd, Ty.DIM d] => let      local
352                val dd = Ty.ShapeVar dd        val crossTy = let
353                val d = Ty.DimVar d              val t = tensor[N3]
354                in                in
355                  [Ty.T_Tensor(Ty.ShapeExt(dd, d)), Ty.T_Int]                [t, t] --> t
356                    --> Ty.T_Tensor dd              end
357        in
358        val op_cross = monoVar (N.op_cross, crossTy)
359        end
360    
361    
362    
363        val op_crossField  = polyVar (N.op_cross, all([DK],
364            fn [Ty.DIFF k] => let
365                  fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
366                (*Hard-coded 2, should be 3 *)
367                val f = field' (Ty.DiffVar(k, 0), 2, [2])
368                in
369                    [f, f] --> f
370                end))                end))
371    
372    (* functions *)    (* the inner product operator (including dot product) is treated as a special case in the
373      val fn_CL = polyVar (N.fn_CL, ty([tensor[N3, N3]] --> Ty.realTy))     * typechecker.  It is not included in the basis environment, but we define its type scheme
374       * here.  There is an implicit constraint on its type to have the following scheme:
375       *
376       *     ALL[sigma1, d1, sigma2] . tensor[sigma1, d1] * tensor[d1, sigma2] -> tensor[sigma1, sigma2]
377       *)
378        val op_inner = polyVar (N.op_dot, all([SK, SK, SK],
379                fn [Ty.SHAPE s1, Ty.SHAPE s2, Ty.SHAPE s3] =>
380                    [Ty.T_Tensor(Ty.ShapeVar s1), Ty.T_Tensor(Ty.ShapeVar s2)]
381                      --> Ty.T_Tensor(Ty.ShapeVar s3)))
382    
383    
384        val op_innerField = polyVar (N.op_dot, all([DK, SK,NK, SK,SK],
385            fn [Ty.DIFF k,Ty.SHAPE dd1, Ty.DIM d, Ty.SHAPE dd2,Ty.SHAPE dd3] => let
386                 val _=print "\n E"
387                val k0=Ty.DiffVar(k, 0)
388                val d' = Ty.DimVar d
389                val _ = print(String.concat["\n Basis Var Inner product Field. "])
390    
391                val t1 = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd1}
392                val t2 = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd2}
393                val t3 = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape =     Ty.ShapeVar dd3}
394    (*
395                val h = field(k0, d',  Ty.Shape[Ty.DimConst 3, Ty.DimConst 2])
396    *)
397                val f = field(k0, d',  Ty.Shape[ Ty.DimConst 2])
398                val h = field(k0, d',  Ty.Shape[])
399    
     val fn_convolve = polyVar (N.fn_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  
400                  in                  in
401                    [Ty.T_Kernel k, Ty.T_Image{dim=d, shape=dd}]  
402                      --> field(k, d, dd)                  [f,f] --> h
403                  end))                  end))
404    
     val fn_cos = polyVar (N.fn_cos, ty([Ty.realTy] --> Ty.realTy))  
405    
406      val fn_dot = polyVar (N.fn_dot, allNK(fn tv => let  
407            val t = tensor[Ty.DimVar tv]  
408    
409      (* the colon (or double-dot) product operator is treated as a special case in the
410       * typechecker.  It is not included in the basis environment, but we define its type
411       * schemehere.  There is an implicit constraint on its type to have the following scheme:
412       *
413       *     ALL[sigma1, d1, d2, sigma2] .
414       *       tensor[sigma1, d1, d2] * tensor[d1, d2, sigma2] -> tensor[sigma1, sigma2]
415       *)
416        val op_colon = polyVar (N.op_colon, all([SK, SK, SK],
417                fn [Ty.SHAPE s1, Ty.SHAPE s2, Ty.SHAPE s3] =>
418                    [Ty.T_Tensor(Ty.ShapeVar s1), Ty.T_Tensor(Ty.ShapeVar s2)]
419                      --> Ty.T_Tensor(Ty.ShapeVar s3)))
420    
421      (* load image from nrrd *)
422        val fn_image = polyVar (N.fn_image, all([NK, SK],
423                fn [Ty.DIM d, Ty.SHAPE dd] => let
424                    val d = Ty.DimVar d
425                    val dd = Ty.ShapeVar dd
426            in            in
427              [t, t] --> Ty.realTy                    [Ty.T_String] --> Ty.T_Image{dim=d, shape=dd}
428            end))            end))
429    
430      val fn_inside = polyVar (N.fn_inside,       all([DK, NK, SK],      val fn_inside = polyVar (N.fn_inside,       all([DK, NK, SK],
# Line 205  Line 445 
445                    [Ty.T_String] --> Ty.T_Image{dim=d, shape=dd}                    [Ty.T_String] --> Ty.T_Image{dim=d, shape=dd}
446                  end))                  end))
447    
448        val fn_max = monoVar (N.fn_max, [Ty.realTy, Ty.realTy] --> Ty.realTy)
449        val fn_min = monoVar (N.fn_min, [Ty.realTy, Ty.realTy] --> Ty.realTy)
450    
451      val fn_modulate = polyVar (N.fn_modulate, all([NK],      val fn_modulate = polyVar (N.fn_modulate, all([NK],
452              fn [Ty.DIM d] => let              fn [Ty.DIM d] => let
453                  val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])                  val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])
# Line 212  Line 455 
455                    [t, t] --> t                    [t, t] --> t
456                  end))                  end))
457    
458      val fn_pow = polyVar (N.fn_pow, ty([Ty.realTy, Ty.realTy] --> Ty.realTy))      val fn_normalize = polyVar (N.fn_normalize, all([NK],
459                fn [Ty.DIM d] => let
460                    val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])
461                    in
462                      [t] --> t
463                    end))
464    
465      (* outer products*)
466    
467        local
468          fun mkOuter [Ty.DIM d1, Ty.DIM d2] = let
469                val vt1 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1])
470                val vt2 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d2])
471                val mt = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1, Ty.DimVar d2])
472    
473    
474    
475    
476                in
477                  [vt1, vt2] --> mt
478                end
479        in
480        val op_outer = polyVar (N.op_outer, all([NK, NK], mkOuter))
481        end
482    
483    
484    
485    
486    
487        fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
488    
489        local
490        fun mkOuterField [Ty.DIFF k, Ty.DIM d] = let
491            val k0=Ty.DiffVar(k, 0)
492            val d' = Ty.DimVar d
493            val f = field(k0, d', Ty.Shape[d'])
494           (* val h = field(k0, d',  Ty.Shape[d',d'])*)
495            val h = field(k0, d',  Ty.Shape[ d', d'])
496            in
497                [f, f] --> h
498            end
499        in
500            val op_outerField = polyVar (N.op_outer, all([DK,NK], mkOuterField))
501        end
502    (*
503        local
504        fun mkOuterFieldTen [Ty.DIFF k, Ty.DIM d] = let
505            val k0=Ty.DiffVar(k, 0)
506            val d' = Ty.DimVar d
507    
508            val t = Ty.T_Tensor(Ty.Shape[d'])
509            val f = field(k0, d', Ty.Shape[d'])
510            val h = field(k0, d',  Ty.Shape[d',d'])
511    
512            in
513                [f, t] --> h
514            end
515        in
516            val op_outerFieldTen = polyVar (N.op_outer, all([DK,NK], mkOuterFieldTen))
517        end
518    *)
519    
520    
521    
522    (* Fields of any shape, and dimension
523    fun mkOuterField [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd1, Ty.SHAPE dd2] = let
524    val d1 = Ty.ShapeVar dd1
525    val d2 = Ty.ShapeVar dd2
526    val k0=Ty.DiffVar(k, 0)
527    val d' = Ty.DimVar d
528    
529    val f = field(k0, d', d1)
530    val g = field(k0, d',  d2)
531    val h = field'(k0, 2,  [2,2])
532    
533    
534    in
535    [f, g] --> h
536    end
537    in
538    val op_outerField = polyVar (N.op_outer, all([DK,NK, SK,SK], mkOuterField))
539    end
540    
541    
542    *)
543    
544      val fn_principleEvec = polyVar (N.fn_principleEvec, all([NK],      val fn_principleEvec = polyVar (N.fn_principleEvec, all([NK],
545              fn [Ty.DIM d] => let              fn [Ty.DIM d] => let
546                  val d = Ty.DimVar d                  val d = Ty.DimVar d
547                  in                  in
548                    [tensor[d,d]] --> tensor[d]                    [matrix d] --> tensor[d]
549                  end))                  end))
550    
551      val fn_sin = polyVar (N.fn_sin, ty([Ty.realTy] --> Ty.realTy))      val fn_trace = polyVar (N.fn_trace, all([NK],
552                fn [Ty.DIM d] => [matrix(Ty.DimVar d)] --> Ty.realTy))
553    
554        local
555            fun mktraceField [Ty.DIFF k, Ty.DIM d,Ty.SHAPE dd1] = let
556            val k0=Ty.DiffVar(k, 0)
557            val d' = Ty.DimVar d
558            val d1 = Ty.ShapeVar dd1
559            val f = field(k0, d', Ty.ShapeExt(Ty.ShapeExt(d1,d'),d'))
560            val h = field(k0, d', d1)
561            in
562                [f] --> h
563            end
564        in
565            val fn_traceField = polyVar (N.fn_trace, all([DK,NK,SK], mktraceField))
566    end
567    
568    
569    
570        val fn_transpose = polyVar (N.fn_transpose, all([NK, NK],
571                fn [Ty.DIM d1, Ty.DIM d2] =>
572                  [tensor[Ty.DimVar d1, Ty.DimVar d2]] --> tensor[Ty.DimVar d2, Ty.DimVar d1]))
573    
574    
575        local
576            fun mktransposeField [Ty.DIFF k, Ty.DIM d,Ty.DIM a, Ty.DIM b] = let
577            val k0=Ty.DiffVar(k, 0)
578            val d' = Ty.DimVar d
579             val a' = Ty.DimVar a
580             val b' = Ty.DimVar b
581            val f = field(k0, d', Ty.Shape[a',b'])
582            val h = field(k0, d', Ty.Shape[b',a'])
583            in
584                [f] --> h
585            end
586        in
587            val fn_transposeField = polyVar (N.fn_transpose, all([DK,NK,NK,NK], mktransposeField))
588        end
589    
590    
591    (* kernels *)    (* kernels *)
592    (* FIXME: we should really get the continuity info from the kernels themselves *)
593      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))
594        val kn_bspln5 = monoVar (N.kn_bspln5, Ty.T_Kernel(Ty.DiffConst 4))
595        val kn_c4hexic = monoVar (N.kn_c4hexic, Ty.T_Kernel(Ty.DiffConst 4))
596        val kn_ctmr = monoVar (N.kn_ctmr, Ty.T_Kernel(Ty.DiffConst 1))
597      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))
598      (* kernels with false claims of differentiability, for pedagogy *)
599    (* internal variables *)      val kn_c1tent = monoVar (N.kn_c1tent, Ty.T_Kernel(Ty.DiffConst 1))
600      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))
601    
602      (***** internal variables *****)
603    
604      (* integer to real conversion *)
605        val i2r = monoVar (Atom.atom "$i2r", [Ty.T_Int] --> Ty.realTy)
606    
607      (* identity matrix *)
608        val identity = polyVar (Atom.atom "$id", allNK (fn dv => [] --> matrix(Ty.DimVar dv)))
609    
610      (* zero tensor *)
611        val zero = polyVar (Atom.atom "$zero", all ([SK],
612                fn [Ty.SHAPE dd] => [] --> Ty.T_Tensor(Ty.ShapeVar dd)))
613    
614      (* sequence subscript *)
615        val subscript = polyVar (Atom.atom "$sub", all ([TK, NK],
616                fn [Ty.TYPE tv, Ty.DIM d] =>
617                  [Ty.T_Sequence(Ty.T_Var tv, Ty.DimVar d), Ty.T_Int] --> Ty.T_Var tv))
618      end (* local *)      end (* local *)
619    end    end

Legend:
Removed from v.103  
changed lines
  Added in v.2603

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