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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2298 - (view) (download)

1 : jhr 79 (* basis-vars.sml
2 :     *
3 : jhr 435 * COPYRIGHT (c) 2010 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 : jhr 79 * All rights reserved.
5 :     *
6 :     * This module defines the AST variables for the built in operators and functions.
7 :     *)
8 :    
9 :     structure BasisVars =
10 :     struct
11 :     local
12 :     structure N = BasisNames
13 :     structure Ty = Types
14 :     structure MV = MetaVar
15 :    
16 : jhr 81 fun --> (tys1, ty) = Ty.T_Fun(tys1, ty)
17 : jhr 79 infix -->
18 :    
19 :     val N2 = Ty.DimConst 2
20 :     val N3 = Ty.DimConst 3
21 :    
22 :     (* short names for kinds *)
23 :     val TK : unit -> Ty.meta_var = Ty.TYPE o MV.newTyVar
24 : jhr 470 fun DK () : Ty.meta_var = Ty.DIFF(MV.newDiffVar 0)
25 : jhr 79 val SK : unit -> Ty.meta_var = Ty.SHAPE o MV.newShapeVar
26 :     val NK : unit -> Ty.meta_var = Ty.DIM o MV.newDimVar
27 :    
28 :     fun ty t = ([], t)
29 :     fun all (kinds, mkTy : Ty.meta_var list -> Ty.ty) = let
30 :     val tvs = List.map (fn mk => mk()) kinds
31 :     in
32 :     (tvs, mkTy tvs)
33 :     end
34 :     fun allNK mkTy = let
35 :     val tv = MV.newDimVar()
36 :     in
37 :     ([Ty.DIM tv], mkTy tv)
38 :     end
39 :    
40 :     fun field (k, d, dd) = Ty.T_Field{diff=k, dim=d, shape=dd}
41 :     fun tensor ds = Ty.T_Tensor(Ty.Shape ds)
42 : jhr 1116 fun matrix d = tensor[d,d]
43 : jhr 79
44 :     fun monoVar (name, ty) = Var.new (name, AST.BasisVar, ty)
45 :     fun polyVar (name, scheme) = Var.newPoly (name, AST.BasisVar, scheme)
46 :     in
47 :    
48 :     (* TODO: I'm not sure how to extend + and - to fields, since the typing rules should allow
49 :     * two fields with different differentiation levels to be added.
50 :     *)
51 :    
52 :     (* overloaded operators; the naming convention is to use the operator name followed
53 :     * by the argument type signature, where
54 :     * i -- int
55 :     * b -- bool
56 :     * r -- real (tensor[])
57 :     * t -- tensor[shape]
58 : jhr 470 * f -- field#k(d)[shape]
59 : jhr 1687 * d -- ty{}
60 :     * T -- ty
61 : jhr 79 *)
62 :    
63 : jhr 1687 (* 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 : jhr 79 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
85 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
86 :     in
87 :     [t, t] --> t
88 :     end))
89 : jhr 470 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 : jhr 2298 val add_fr = polyVar(N.op_add, all([DK,NK], (* field + scalar *)
96 :     fn [Ty.DIFF k, Ty.DIM d] => let
97 :     val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
98 :     in
99 :     [t, Ty.realTy] --> t
100 :     end))
101 :     val add_rf = polyVar(N.op_add, all([DK,NK], (* scalar + field *)
102 :     fn [Ty.DIFF k, Ty.DIM d] => let
103 :     val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
104 :     in
105 :     [Ty.realTy, t] --> t
106 :     end))
107 : jhr 79
108 :     val sub_ii = monoVar(N.op_sub, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
109 :     val sub_tt = polyVar(N.op_sub, all([SK], fn [Ty.SHAPE dd] => let
110 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
111 :     in
112 :     [t, t] --> t
113 :     end))
114 : jhr 470 val sub_ff = polyVar(N.op_sub, all([DK,NK,SK],
115 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
116 :     val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
117 :     in
118 :     [t, t] --> t
119 :     end))
120 : jhr 2298 val sub_fr = polyVar(N.op_sub, all([DK,NK], (* field - scalar *)
121 :     fn [Ty.DIFF k, Ty.DIM d] => let
122 :     val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
123 :     in
124 :     [t, Ty.realTy] --> t
125 :     end))
126 :     val sub_rf = polyVar(N.op_sub, all([DK,NK], (* scalar - field *)
127 :     fn [Ty.DIFF k, Ty.DIM d] => let
128 :     val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
129 :     in
130 :     [Ty.realTy, t] --> t
131 :     end))
132 : jhr 79
133 :     (* note that we assume that operators are tested in the order defined here, so that mul_rr
134 :     * takes precedence over mul_rt and mul_tr!
135 :     *)
136 :     val mul_ii = monoVar(N.op_mul, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
137 :     val mul_rr = monoVar(N.op_mul, [Ty.realTy, Ty.realTy] --> Ty.realTy)
138 :     val mul_rt = polyVar(N.op_mul, all([SK], fn [Ty.SHAPE dd] => let
139 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
140 :     in
141 :     [Ty.realTy, t] --> t
142 :     end))
143 :     val mul_tr = polyVar(N.op_mul, all([SK], fn [Ty.SHAPE dd] => let
144 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
145 :     in
146 :     [t, Ty.realTy] --> t
147 :     end))
148 : jhr 470 val mul_rf = polyVar(N.op_mul, all([DK,NK,SK],
149 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
150 :     val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
151 :     in
152 :     [Ty.realTy, t] --> t
153 :     end))
154 :     val mul_fr = polyVar(N.op_mul, all([DK,NK,SK],
155 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
156 :     val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
157 :     in
158 :     [t, Ty.realTy] --> t
159 :     end))
160 : jhr 79
161 :     val div_ii = monoVar(N.op_div, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
162 :     val div_rr = monoVar(N.op_div, [Ty.realTy, Ty.realTy] --> Ty.realTy)
163 :     val div_tr = polyVar(N.op_div, all([SK], fn [Ty.SHAPE dd] => let
164 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
165 :     in
166 :     [t, Ty.realTy] --> t
167 :     end))
168 : jhr 470 val div_fr = polyVar(N.op_div, all([DK,NK,SK],
169 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
170 :     val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
171 :     in
172 :     [t, Ty.realTy] --> t
173 :     end))
174 : jhr 79
175 : lamonts 2120 (* distance of tensors *)
176 :     local
177 :     val vec2Ty = let
178 :     val t = tensor[N2]
179 :     in
180 :     [t, t] --> Ty.realTy
181 :     end
182 :     val vec3Ty = let
183 :     val t = tensor[N3]
184 :     in
185 :     [t, t] --> Ty.realTy
186 :     end
187 :     in
188 :     val dist_t2 = monoVar (N.fn_dist, vec2Ty)
189 :     val dist_t3 = monoVar (N.fn_dist, vec3Ty)
190 :     end
191 :    
192 : jhr 1116 (* exponentiation; we distinguish between integer and real exponents to allow x^2 to be compiled
193 :     * as x*x.
194 :     *)
195 :     val exp_ri = monoVar(N.op_exp, [Ty.realTy, Ty.T_Int] --> Ty.realTy)
196 :     val exp_rr = monoVar(N.op_exp, [Ty.realTy, Ty.realTy] --> Ty.realTy)
197 :    
198 :     val convolve_vk = polyVar (N.op_convolve, all([DK, NK, SK],
199 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
200 :     val k = Ty.DiffVar(k, 0)
201 :     val d = Ty.DimVar d
202 :     val dd = Ty.ShapeVar dd
203 :     in
204 :     [Ty.T_Image{dim=d, shape=dd}, Ty.T_Kernel k]
205 :     --> field(k, d, dd)
206 :     end))
207 :     val convolve_kv = polyVar (N.op_convolve, all([DK, NK, SK],
208 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
209 :     val k = Ty.DiffVar(k, 0)
210 :     val d = Ty.DimVar d
211 :     val dd = Ty.ShapeVar dd
212 :     in
213 :     [Ty.T_Kernel k, Ty.T_Image{dim=d, shape=dd}]
214 :     --> field(k, d, dd)
215 :     end))
216 :    
217 : jhr 2298 (* curl on 2d and 3d vector fields *)
218 :     local
219 :     val diff0 = Ty.DiffConst 0
220 :     fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
221 :     in
222 :     (* FIXME: we want to be able to require that k > 0, but we don't have a way to do that! *)
223 :     val curl2D = polyVar (N.op_curl, all([DK],
224 :     fn [Ty.DIFF k] =>
225 :     [field' (Ty.DiffVar(k, 0), 2, [2])] --> field' (diff0, 2, [])))
226 :     val curl3D = polyVar (N.op_curl, all([DK],
227 :     fn [Ty.DIFF k] =>
228 :     [field' (Ty.DiffVar(k, 0), 3, [3])] --> field' (diff0, 2, [3])))
229 :     end (* local *)
230 :    
231 : jhr 79 val lt_ii = monoVar(N.op_lt, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
232 :     val lt_rr = monoVar(N.op_lt, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
233 :     val lte_ii = monoVar(N.op_lte, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
234 :     val lte_rr = monoVar(N.op_lte, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
235 :     val gte_ii = monoVar(N.op_gte, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
236 :     val gte_rr = monoVar(N.op_gte, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
237 :     val gt_ii = monoVar(N.op_gt, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
238 :     val gt_rr = monoVar(N.op_gt, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
239 :    
240 :     val equ_bb = monoVar(N.op_equ, [Ty.T_Bool, Ty.T_Bool] --> Ty.T_Bool)
241 :     val equ_ii = monoVar(N.op_equ, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
242 :     val equ_ss = monoVar(N.op_equ, [Ty.T_String, Ty.T_String] --> Ty.T_Bool)
243 :     val equ_rr = monoVar(N.op_equ, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
244 :     val neq_bb = monoVar(N.op_neq, [Ty.T_Bool, Ty.T_Bool] --> Ty.T_Bool)
245 :     val neq_ii = monoVar(N.op_neq, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
246 :     val neq_ss = monoVar(N.op_neq, [Ty.T_String, Ty.T_String] --> Ty.T_Bool)
247 :     val neq_rr = monoVar(N.op_neq, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
248 :    
249 :    
250 : jhr 1640 val neg_i = monoVar(N.op_neg, [Ty.T_Int] --> Ty.T_Int)
251 : jhr 79 val neg_t = polyVar(N.op_neg, all([SK],
252 :     fn [Ty.SHAPE dd] => let
253 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
254 :     in
255 :     [t] --> t
256 :     end))
257 :     val neg_f = polyVar(N.op_neg, all([DK, NK, SK],
258 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
259 :     val k = Ty.DiffVar(k, 0)
260 :     val d = Ty.DimVar d
261 :     val dd = Ty.ShapeVar dd
262 :     in
263 :     [field(k, d, dd)] --> field(k, d, dd)
264 :     end))
265 :    
266 : jhr 1295 (* clamp is overloaded at scalars and vectors *)
267 :     val clamp_rrr = monoVar(N.fn_clamp, [Ty.realTy, Ty.realTy, Ty.realTy] --> Ty.realTy)
268 :     val clamp_vvv = polyVar (N.fn_clamp, allNK(fn tv => let
269 :     val t = tensor[Ty.DimVar tv]
270 :     in
271 :     [t, t, t] --> t
272 :     end))
273 :    
274 : jhr 1116 val lerp3 = polyVar(N.fn_lerp, all([SK],
275 :     fn [Ty.SHAPE dd] => let
276 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
277 :     in
278 :     [t, t, Ty.realTy] --> t
279 :     end))
280 :     val lerp5 = polyVar(N.fn_lerp, all([SK],
281 :     fn [Ty.SHAPE dd] => let
282 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
283 :     in
284 :     [t, t, Ty.realTy, Ty.realTy, Ty.realTy] --> t
285 :     end))
286 : jhr 79
287 : jhr 1640 (* Eigenvalues/vectors of a matrix; we only support this operation on 2x2 and 3x3 matrices, so
288 :     * we overload the function.
289 :     *)
290 :     local
291 :     fun evals d = monoVar (N.fn_evals, [matrix d] --> Ty.T_Sequence(Ty.realTy, d))
292 :     fun evecs d = monoVar (N.fn_evecs, [matrix d] --> Ty.T_Sequence(tensor[d], d))
293 :     in
294 :     val evals2x2 = evals(Ty.DimConst 2)
295 :     val evecs2x2 = evecs(Ty.DimConst 2)
296 :     val evals3x3 = evals(Ty.DimConst 3)
297 :     val evecs3x3 = evecs(Ty.DimConst 3)
298 :     end
299 : jhr 1296
300 : jhr 1640
301 : jhr 79 (***** non-overloaded operators, etc. *****)
302 :    
303 : jhr 1922 (* C math functions *)
304 :     val mathFns : (MathFuns.name * Var.var) list = let
305 :     fun ty n = List.tabulate(MathFuns.arity n, fn _ => Ty.realTy) --> Ty.realTy
306 :     in
307 :     List.map (fn n => (n, monoVar(MathFuns.toAtom n, ty n))) MathFuns.allFuns
308 :     end
309 :    
310 : jhr 1687 (* pseudo-operator for probing a field *)
311 :     val op_probe = polyVar (N.op_at, all([DK, NK, SK],
312 : jhr 79 fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
313 :     val k = Ty.DiffVar(k, 0)
314 :     val d = Ty.DimVar d
315 :     val dd = Ty.ShapeVar dd
316 :     in
317 :     [field(k, d, dd), tensor[d]] --> Ty.T_Tensor dd
318 :     end))
319 :    
320 : jhr 1383 (* differentiation of scalar fields *)
321 :     val op_D = polyVar (N.op_D, all([DK, NK],
322 :     fn [Ty.DIFF k, Ty.DIM d] => let
323 : jhr 79 val k0 = Ty.DiffVar(k, 0)
324 :     val km1 = Ty.DiffVar(k, ~1)
325 :     val d = Ty.DimVar d
326 : jhr 1383 in
327 :     [field(k0, d, Ty.Shape[])]
328 :     --> field(km1, d, Ty.Shape[d])
329 :     end))
330 :     (* differetiation of higher-order tensor fields *)
331 :     val op_Dotimes = polyVar (N.op_Dotimes, all([DK, NK, SK, NK],
332 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd, Ty.DIM d'] => let
333 :     val k0 = Ty.DiffVar(k, 0)
334 :     val km1 = Ty.DiffVar(k, ~1)
335 :     val d = Ty.DimVar d
336 :     val d' = Ty.DimVar d'
337 : jhr 79 val dd = Ty.ShapeVar dd
338 :     in
339 : jhr 1383 [field(k0, d, Ty.ShapeExt(dd, d'))]
340 :     --> field(km1, d, Ty.ShapeExt(Ty.ShapeExt(dd, d'), d))
341 : jhr 79 end))
342 :    
343 :     val op_norm = polyVar (N.op_norm, all([SK],
344 :     fn [Ty.SHAPE dd] => [Ty.T_Tensor(Ty.ShapeVar dd)] --> Ty.realTy))
345 :    
346 :     val op_not = monoVar (N.op_not, [Ty.T_Bool] --> Ty.T_Bool)
347 :    
348 :     (* functions *)
349 : jhr 1116 local
350 :     val crossTy = let
351 :     val t = tensor[N3]
352 :     in
353 :     [t, t] --> t
354 :     end
355 :     in
356 :     val op_cross = monoVar (N.op_cross, crossTy)
357 :     end
358 :    
359 : lamonts 2160 (* Query functions *)
360 :     val fn_sphere = polyVar (N.fn_sphere, all([TK],
361 :     fn [Ty.TYPE tv] => [Ty.realTy] --> Ty.T_DynSequence(Ty.T_Var tv)))
362 :    
363 : jhr 1116 (* the inner product operator (including dot product) is treated as a special case in the
364 :     * typechecker. It is not included in the basis environment, but we define its type scheme
365 :     * here. There is an implicit constraint on its type to have the following scheme:
366 :     *
367 :     * ALL[sigma1, d1, sigma2] . tensor[sigma1, d1] * tensor[d1, sigma2] -> tensor[sigma1, sigma2]
368 :     *)
369 :     val op_inner = polyVar (N.op_dot, all([SK, SK, SK],
370 :     fn [Ty.SHAPE s1, Ty.SHAPE s2, Ty.SHAPE s3] =>
371 :     [Ty.T_Tensor(Ty.ShapeVar s1), Ty.T_Tensor(Ty.ShapeVar s2)]
372 :     --> Ty.T_Tensor(Ty.ShapeVar s3)))
373 :    
374 : jhr 1945 (* the colon (or double-dot) product operator is treated as a special case in the
375 :     * typechecker. It is not included in the basis environment, but we define its type
376 :     * schemehere. There is an implicit constraint on its type to have the following scheme:
377 :     *
378 :     * ALL[sigma1, d1, d2, sigma2] .
379 :     * tensor[sigma1, d1, d2] * tensor[d1, d2, sigma2] -> tensor[sigma1, sigma2]
380 :     *)
381 :     val op_colon = polyVar (N.op_colon, all([SK, SK, SK],
382 :     fn [Ty.SHAPE s1, Ty.SHAPE s2, Ty.SHAPE s3] =>
383 :     [Ty.T_Tensor(Ty.ShapeVar s1), Ty.T_Tensor(Ty.ShapeVar s2)]
384 :     --> Ty.T_Tensor(Ty.ShapeVar s3)))
385 :    
386 : jhr 1926 (* load image from nrrd *)
387 :     val fn_image = polyVar (N.fn_image, all([NK, SK],
388 :     fn [Ty.DIM d, Ty.SHAPE dd] => let
389 :     val d = Ty.DimVar d
390 :     val dd = Ty.ShapeVar dd
391 :     in
392 :     [Ty.T_String] --> Ty.T_Image{dim=d, shape=dd}
393 :     end))
394 :    
395 : jhr 143 val fn_inside = polyVar (N.fn_inside, all([DK, NK, SK],
396 : jhr 79 fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
397 :     val k = Ty.DiffVar(k, 0)
398 :     val d = Ty.DimVar d
399 :     val dd = Ty.ShapeVar dd
400 :     in
401 :     [Ty.T_Tensor(Ty.Shape[d]), field(k, d, dd)]
402 :     --> Ty.T_Bool
403 :     end))
404 :    
405 : jhr 1926 (* load dynamic sequence from nrrd *)
406 :     val fn_load = polyVar (N.fn_load, all([TK],
407 :     fn [Ty.TYPE tv] => [Ty.T_String] --> Ty.T_DynSequence(Ty.T_Var tv)))
408 : jhr 79
409 : jhr 1925 val fn_length = polyVar (N.fn_length, all([TK],
410 :     fn [Ty.TYPE tv] => [Ty.T_DynSequence(Ty.T_Var tv)] --> Ty.T_Int))
411 :    
412 : jhr 143 val fn_max = monoVar (N.fn_max, [Ty.realTy, Ty.realTy] --> Ty.realTy)
413 :     val fn_min = monoVar (N.fn_min, [Ty.realTy, Ty.realTy] --> Ty.realTy)
414 : jhr 2298
415 : jhr 83 val fn_modulate = polyVar (N.fn_modulate, all([NK],
416 :     fn [Ty.DIM d] => let
417 :     val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])
418 :     in
419 :     [t, t] --> t
420 :     end))
421 :    
422 : jhr 1116 val fn_normalize = polyVar (N.fn_normalize, all([NK],
423 :     fn [Ty.DIM d] => let
424 :     val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])
425 :     in
426 :     [t] --> t
427 :     end))
428 :    
429 :     (* outer product *)
430 :     local
431 :     fun mkOuter [Ty.DIM d1, Ty.DIM d2] = let
432 :     val vt1 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1])
433 :     val vt2 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d2])
434 :     val mt = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1, Ty.DimVar d2])
435 :     in
436 :     [vt1, vt2] --> mt
437 :     end
438 :     in
439 :     val op_outer = polyVar (N.op_outer, all([NK, NK], mkOuter))
440 :     end
441 :    
442 : jhr 91 val fn_principleEvec = polyVar (N.fn_principleEvec, all([NK],
443 :     fn [Ty.DIM d] => let
444 :     val d = Ty.DimVar d
445 :     in
446 : jhr 1116 [matrix d] --> tensor[d]
447 : jhr 91 end))
448 : jhr 79
449 : jhr 1116 val fn_trace = polyVar (N.fn_trace, all([NK],
450 : jhr 1640 fn [Ty.DIM d] => [matrix(Ty.DimVar d)] --> Ty.realTy))
451 : jhr 1116
452 : jhr 79 (* kernels *)
453 : jhr 169 (* FIXME: we should really get the continuity info from the kernels themselves *)
454 : jhr 83 val kn_bspln3 = monoVar (N.kn_bspln3, Ty.T_Kernel(Ty.DiffConst 2))
455 : jhr 169 val kn_bspln5 = monoVar (N.kn_bspln5, Ty.T_Kernel(Ty.DiffConst 4))
456 : jhr 1950 val kn_c4hexic = monoVar (N.kn_c4hexic, Ty.T_Kernel(Ty.DiffConst 4))
457 : jhr 1116 val kn_ctmr = monoVar (N.kn_ctmr, Ty.T_Kernel(Ty.DiffConst 1))
458 : jhr 83 val kn_tent = monoVar (N.kn_tent, Ty.T_Kernel(Ty.DiffConst 0))
459 : jhr 1116 (* kernels with false claims of differentiability, for pedagogy *)
460 :     val kn_c1tent = monoVar (N.kn_c1tent, Ty.T_Kernel(Ty.DiffConst 1))
461 :     val kn_c2ctmr = monoVar (N.kn_c2ctmr, Ty.T_Kernel(Ty.DiffConst 2))
462 : jhr 79
463 : jhr 1116 (***** internal variables *****)
464 : jhr 406
465 : jhr 1116 (* integer to real conversion *)
466 :     val i2r = monoVar (Atom.atom "$i2r", [Ty.T_Int] --> Ty.realTy)
467 :    
468 :     (* identity matrix *)
469 :     val identity = polyVar (Atom.atom "$id", allNK (fn dv => [] --> matrix(Ty.DimVar dv)))
470 :    
471 :     (* zero tensor *)
472 :     val zero = polyVar (Atom.atom "$zero", all ([SK],
473 :     fn [Ty.SHAPE dd] => [] --> Ty.T_Tensor(Ty.ShapeVar dd)))
474 :    
475 : jhr 1640 (* sequence subscript *)
476 :     val subscript = polyVar (Atom.atom "$sub", all ([TK, NK],
477 :     fn [Ty.TYPE tv, Ty.DIM d] =>
478 :     [Ty.T_Sequence(Ty.T_Var tv, Ty.DimVar d), Ty.T_Int] --> Ty.T_Var tv))
479 : jhr 1991
480 :     val dynSubscript = polyVar (Atom.atom "$dynsub", all ([TK],
481 :     fn [Ty.TYPE tv] => [Ty.T_DynSequence(Ty.T_Var tv), Ty.T_Int] --> Ty.T_Var tv))
482 :    
483 : jhr 79 end (* local *)
484 :     end

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