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 4574 - (view) (download)

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

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