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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3463 - (view) (download)

1 : jhr 3391 (* basis-vars.sml
2 :     *
3 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     *
5 :     * COPYRIGHT (c) 2015 The University of Chicago
6 :     * 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 :     fun --> (tys, ty) = Ty.T_Fun(tys, ty)
19 :     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 :     fun DK () : Ty.meta_var = Ty.DIFF(MV.newDiffVar 0)
27 :     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 :     val tvs = List.map (fn mk => mk()) kinds
33 :     in
34 :     (tvs, mkTy tvs)
35 :     end
36 :     fun allNK mkTy = let
37 :     val tv = MV.newDimVar()
38 :     in
39 :     ([Ty.DIM tv], mkTy tv)
40 :     end
41 :    
42 :     fun field (k, d, dd) = Ty.T_Field{diff=k, dim=d, shape=dd}
43 :     fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
44 :     fun tensor ds = Ty.T_Tensor(Ty.Shape ds)
45 :     fun matrix d = tensor[d,d]
46 : jhr 3398 fun dynSeq ty = Ty.T_Sequence(ty, NONE)
47 : jhr 3391
48 : jhr 3398 fun monoVar (name, ty) = Var.new (name, Error.UNKNOWN, AST.BasisVar, ty)
49 : jhr 3407 fun polyVar arg = Var.newBasis arg
50 : jhr 3391 in
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 3392 * I -- image(d)[shape]
59 : jhr 3391 * f -- field#k(d)[shape]
60 :     * s -- field#k(d)[]
61 :     * d -- ty{}
62 :     * T -- ty
63 :     *)
64 :    
65 :     (* concatenation of sequences *)
66 :     val at_dT = polyVar (N.op_at, all([TK],
67 :     fn [Ty.TYPE tv] => let
68 : jhr 3398 val seqTyc = dynSeq(Ty.T_Var tv)
69 : jhr 3391 in
70 :     [seqTyc, Ty.T_Var tv] --> seqTyc
71 :     end))
72 :     val at_Td = polyVar (N.op_at, all([TK],
73 :     fn [Ty.TYPE tv] => let
74 : jhr 3398 val seqTyc = dynSeq(Ty.T_Var tv)
75 : jhr 3391 in
76 :     [Ty.T_Var tv, seqTyc] --> seqTyc
77 :     end))
78 :     val at_dd = polyVar (N.op_at, all([TK],
79 :     fn [Ty.TYPE tv] => let
80 : jhr 3398 val seqTyc = dynSeq(Ty.T_Var tv)
81 : jhr 3391 in
82 :     [seqTyc, seqTyc] --> seqTyc
83 :     end))
84 :    
85 :     val add_ii = monoVar(N.op_add, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
86 :     val add_tt = polyVar(N.op_add, all([SK], fn [Ty.SHAPE dd] => let
87 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
88 :     in
89 :     [t, t] --> t
90 :     end))
91 :     val add_ff = polyVar(N.op_add, all([DK,NK,SK],
92 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
93 :     val f = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
94 :     in
95 :     [f, f] --> f
96 :     end))
97 :     val add_ft = polyVar(N.op_add, all([DK,NK,SK], (* field + scalar *)
98 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
99 :     val f = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
100 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
101 :     in
102 :     [f, t] --> f
103 :     end))
104 :     val add_tf = polyVar(N.op_add, all([DK,NK,SK], (* scalar + field *)
105 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
106 :     val f = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
107 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
108 :     in
109 :     [t, f] --> f
110 :     end))
111 :    
112 :     val sub_ii = monoVar(N.op_sub, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
113 :     val sub_tt = polyVar(N.op_sub, all([SK], fn [Ty.SHAPE dd] => let
114 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
115 :     in
116 :     [t, t] --> t
117 :     end))
118 :     val sub_ff = polyVar(N.op_sub, all([DK,NK,SK],
119 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
120 :     val f = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
121 :     in
122 :     [f, f] --> f
123 :     end))
124 :     val sub_ft = polyVar(N.op_sub, all([DK,NK,SK], (* field - scalar *)
125 :     fn [Ty.DIFF k, Ty.DIM d,Ty.SHAPE dd] => let
126 :     val f = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
127 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
128 :     in
129 :     [f, t] --> f
130 :     end))
131 :     val sub_tf = polyVar(N.op_sub, all([DK,NK,SK], (* scalar - field *)
132 :     fn [Ty.DIFF k, Ty.DIM d,Ty.SHAPE dd] => let
133 :     val f = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
134 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
135 :     in
136 :     [t, f] --> f
137 :     end))
138 :    
139 :     (* note that we assume that operators are tested in the order defined here, so that mul_rr
140 :     * takes precedence over mul_rt and mul_tr!
141 :     *)
142 :     val mul_ii = monoVar(N.op_mul, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
143 :     val mul_rr = monoVar(N.op_mul, [Ty.realTy, Ty.realTy] --> Ty.realTy)
144 :     val mul_rt = polyVar(N.op_mul, all([SK], fn [Ty.SHAPE dd] => let
145 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
146 :     in
147 :     [Ty.realTy, t] --> t
148 :     end))
149 :     val mul_tr = polyVar(N.op_mul, all([SK], fn [Ty.SHAPE dd] => let
150 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
151 :     in
152 :     [t, Ty.realTy] --> t
153 :     end))
154 :     val mul_rf = polyVar(N.op_mul, all([DK,NK,SK], fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
155 :     val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
156 :     in
157 :     [Ty.realTy, t] --> t
158 :     end))
159 :     val mul_fr = polyVar(N.op_mul, all([DK,NK,SK], fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
160 :     val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
161 :     in
162 :     [t, Ty.realTy] --> t
163 :     end))
164 :     val mul_st = polyVar(N.op_mul, all([DK,NK,SK], fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
165 : jhr 3392 val f = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
166 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
167 :     val g = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
168 :     in
169 :     [f, t] --> g
170 :     end))
171 : jhr 3391 val mul_ts = polyVar(N.op_mul, all([DK,NK,SK], fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
172 : jhr 3392 val f = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape[]}
173 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
174 :     val g = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
175 :     in
176 :     [t, f] --> g
177 :     end))
178 : jhr 3391 val mul_ss = polyVar(N.op_mul, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let
179 : jhr 3392 val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape []}
180 :     in
181 :     [t, t] --> t
182 :     end))
183 : jhr 3391 val mul_sf = polyVar(N.op_mul, all([DK,NK,SK], fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
184 : jhr 3392 val a = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape []}
185 :     val b = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
186 :     in
187 :     [a, b] --> b
188 :     end))
189 : jhr 3391 val mul_fs = polyVar(N.op_mul, all([DK,NK,SK], fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
190 : jhr 3392 val a = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape []}
191 :     val b = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
192 :     in
193 :     [b, a] --> b
194 :     end))
195 : jhr 3391
196 :     val div_ii = monoVar(N.op_div, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
197 :     val div_rr = monoVar(N.op_div, [Ty.realTy, Ty.realTy] --> Ty.realTy)
198 :     val div_tr = polyVar(N.op_div, all([SK], fn [Ty.SHAPE dd] => let
199 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
200 :     in
201 :     [t, Ty.realTy] --> t
202 :     end))
203 :     val div_fr = polyVar(N.op_div, all([DK,NK,SK], fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
204 :     val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
205 :     in
206 :     [t, Ty.realTy] --> t
207 :     end))
208 :     val div_ss = polyVar(N.op_mul, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let
209 :     val t = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.Shape []}
210 :     in
211 : jhr 3392 [t, t] --> t
212 : jhr 3391 end))
213 :     val div_fs = polyVar(N.op_div, all([DK,DK,NK,SK], fn [Ty.DIFF k, Ty.DIFF k2, Ty.DIM d, Ty.SHAPE dd] => let
214 :     val f = Ty.T_Field{diff = Ty.DiffVar(k, 0), dim = Ty.DimVar d, shape = Ty.ShapeVar dd}
215 :     val s = Ty.T_Field{diff = Ty.DiffVar(k2, 0), dim = Ty.DimVar d, shape = Ty.Shape []}
216 :     in
217 : jhr 3392 [f, s] --> f
218 : jhr 3391 end))
219 :    
220 : jhr 3392 (* vector distance function *)
221 :     local
222 :     val vec2Ty = let
223 :     val t = tensor[N2]
224 :     in
225 :     [t, t] --> Ty.realTy
226 :     end
227 :     val vec3Ty = let
228 :     val t = tensor[N3]
229 :     in
230 :     [t, t] --> Ty.realTy
231 :     end
232 :     in
233 :     val dist2_t = monoVar (N.fn_dist, vec2Ty)
234 :     val dist3_t = monoVar (N.fn_dist, vec3Ty)
235 : jhr 3398 end (* local *)
236 : jhr 3392
237 : jhr 3391 (* exponentiation; we distinguish between integer and real exponents to allow x^2 to be compiled
238 :     * as x*x.
239 :     *)
240 :     val exp_ri = monoVar(N.op_exp, [Ty.realTy, Ty.T_Int] --> Ty.realTy)
241 :     val exp_rr = monoVar(N.op_exp, [Ty.realTy, Ty.realTy] --> Ty.realTy)
242 :    
243 :     val convolve_vk = polyVar (N.op_convolve, all([DK, NK, SK], fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
244 :     val k = Ty.DiffVar(k, 0)
245 : jhr 3392 val d = Ty.DimVar d
246 :     val dd = Ty.ShapeVar dd
247 :     in
248 :     [Ty.T_Image{dim=d, shape=dd}, Ty.T_Kernel k] --> field(k, d, dd)
249 :     end))
250 : jhr 3391 val convolve_kv = polyVar (N.op_convolve, all([DK, NK, SK], fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
251 : jhr 3392 val k = Ty.DiffVar(k, 0)
252 :     val d = Ty.DimVar d
253 :     val dd = Ty.ShapeVar dd
254 :     in
255 :     [Ty.T_Kernel k, Ty.T_Image{dim=d, shape=dd}] --> field(k, d, dd)
256 :     end))
257 : jhr 3391
258 :     (* curl on 2d and 3d vector fields *)
259 :     local
260 :     val diff0 = Ty.DiffConst 0
261 :     fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
262 :     in
263 :     val curl2D = polyVar (N.op_curl, all([DK], fn [Ty.DIFF k] => let
264 : jhr 3392 val km1 = Ty.DiffVar(k, ~1)
265 :     in
266 :     [field' (Ty.DiffVar(k, 0), 2, [2])] --> field' (km1, 2, [])
267 :     end))
268 : jhr 3391 val curl3D = polyVar (N.op_curl, all([DK], fn [Ty.DIFF k] =>let
269 : jhr 3392 val km1 = Ty.DiffVar(k, ~1)
270 :     in
271 :     [field' (Ty.DiffVar(k, 0), 3, [3])] --> field' (km1, 3, [3])
272 :     end))
273 : jhr 3391 end (* local *)
274 :    
275 :     val lt_ii = monoVar(N.op_lt, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
276 :     val lt_rr = monoVar(N.op_lt, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
277 :     val lte_ii = monoVar(N.op_lte, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
278 :     val lte_rr = monoVar(N.op_lte, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
279 :     val gte_ii = monoVar(N.op_gte, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
280 :     val gte_rr = monoVar(N.op_gte, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
281 :     val gt_ii = monoVar(N.op_gt, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
282 :     val gt_rr = monoVar(N.op_gt, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
283 :    
284 :     val equ_bb = monoVar(N.op_equ, [Ty.T_Bool, Ty.T_Bool] --> Ty.T_Bool)
285 :     val equ_ii = monoVar(N.op_equ, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
286 :     val equ_ss = monoVar(N.op_equ, [Ty.T_String, Ty.T_String] --> Ty.T_Bool)
287 :     val equ_rr = monoVar(N.op_equ, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
288 :     val neq_bb = monoVar(N.op_neq, [Ty.T_Bool, Ty.T_Bool] --> Ty.T_Bool)
289 :     val neq_ii = monoVar(N.op_neq, [Ty.T_Int, Ty.T_Int] --> Ty.T_Bool)
290 :     val neq_ss = monoVar(N.op_neq, [Ty.T_String, Ty.T_String] --> Ty.T_Bool)
291 :     val neq_rr = monoVar(N.op_neq, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
292 :    
293 :     val neg_i = monoVar(N.op_neg, [Ty.T_Int] --> Ty.T_Int)
294 :     val neg_t = polyVar(N.op_neg, all([SK],
295 :     fn [Ty.SHAPE dd] => let
296 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
297 :     in
298 :     [t] --> t
299 :     end))
300 :     val neg_f = polyVar(N.op_neg, all([DK, NK, SK],
301 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
302 :     val k = Ty.DiffVar(k, 0)
303 :     val d = Ty.DimVar d
304 :     val dd = Ty.ShapeVar dd
305 :     in
306 :     [field(k, d, dd)] --> field(k, d, dd)
307 :     end))
308 :    
309 :     (* clamp is overloaded at scalars and vectors *)
310 :     val clamp_rrr = monoVar(N.fn_clamp, [Ty.realTy, Ty.realTy, Ty.realTy] --> Ty.realTy)
311 :     val clamp_vvv = polyVar (N.fn_clamp, allNK(fn tv => let
312 :     val t = tensor[Ty.DimVar tv]
313 :     in
314 :     [t, t, t] --> t
315 :     end))
316 :    
317 :     val lerp3 = polyVar(N.fn_lerp, all([SK],
318 :     fn [Ty.SHAPE dd] => let
319 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
320 :     in
321 :     [t, t, Ty.realTy] --> t
322 :     end))
323 :     val lerp5 = polyVar(N.fn_lerp, all([SK],
324 :     fn [Ty.SHAPE dd] => let
325 :     val t = Ty.T_Tensor(Ty.ShapeVar dd)
326 :     in
327 :     [t, t, Ty.realTy, Ty.realTy, Ty.realTy] --> t
328 :     end))
329 :    
330 :     (* Eigenvalues/vectors of a matrix; we only support this operation on 2x2 and 3x3 matrices, so
331 :     * we overload the function.
332 :     *)
333 :     local
334 : jhr 3398 fun evals d = monoVar (N.fn_evals, [matrix d] --> Ty.T_Sequence(Ty.realTy, SOME d))
335 :     fun evecs d = monoVar (N.fn_evecs, [matrix d] --> Ty.T_Sequence(tensor[d], SOME d))
336 : jhr 3391 in
337 :     val evals2x2 = evals(Ty.DimConst 2)
338 :     val evecs2x2 = evecs(Ty.DimConst 2)
339 :     val evals3x3 = evals(Ty.DimConst 3)
340 :     val evecs3x3 = evecs(Ty.DimConst 3)
341 : jhr 3398 end (* local *)
342 : jhr 3391
343 :     (***** non-overloaded operators, etc. *****)
344 :    
345 :     (* integer modulo *)
346 :     val op_mod = monoVar(N.op_mod, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
347 :    
348 :     (* pseudo-operator for probing a field *)
349 :     val op_probe = polyVar (N.op_at, all([DK, NK, SK],
350 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
351 : jhr 3392 val k = Ty.DiffVar(k, 0)
352 :     val d = Ty.DimVar d
353 :     val dd = Ty.ShapeVar dd
354 :     in
355 :     [field(k, d, dd), tensor[d]] --> Ty.T_Tensor dd
356 :     end))
357 : jhr 3391
358 :     (* differentiation of scalar fields *)
359 :     val op_D = polyVar (N.op_D, all([DK, NK],
360 :     fn [Ty.DIFF k, Ty.DIM d] => let
361 : jhr 3392 val k0 = Ty.DiffVar(k, 0)
362 :     val km1 = Ty.DiffVar(k, ~1)
363 :     val d = Ty.DimVar d
364 :     in
365 :     [field(k0, d, Ty.Shape[])] --> field(km1, d, Ty.Shape[d])
366 :     end))
367 : jhr 3391
368 :     (* differentiation of higher-order tensor fields *)
369 :     val op_Dotimes = polyVar (N.op_Dotimes, all([DK, NK, SK, NK],
370 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd, Ty.DIM d'] => let
371 : jhr 3392 val k0 = Ty.DiffVar(k, 0)
372 :     val km1 = Ty.DiffVar(k, ~1)
373 :     val d = Ty.DimVar d
374 :     val d' = Ty.DimVar d'
375 :     val dd = Ty.ShapeVar dd
376 :     in
377 :     [field(k0, d, Ty.ShapeExt(dd, d'))]
378 :     --> field(km1, d, Ty.ShapeExt(Ty.ShapeExt(dd, d'), d))
379 :     end))
380 : jhr 3391
381 :     (* divergence differentiation of higher-order tensor fields *)
382 :     val op_Ddot = polyVar (N.op_Ddot, all([DK, NK, SK, NK],
383 : jhr 3392 fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd, Ty.DIM d'] => let
384 :     val k0 = Ty.DiffVar(k, 0)
385 :     val km1 = Ty.DiffVar(k, ~1)
386 :     val d = Ty.DimVar d
387 :     val d' = Ty.DimVar d'
388 :     val dd' = Ty.ShapeVar dd
389 :     in
390 :     [field(k0, d, Ty.ShapeExt(dd', d'))] --> field(k0, d, dd')
391 :     end))
392 : jhr 3391
393 :     val op_norm_t = polyVar (N.op_norm, all([SK],
394 :     fn [Ty.SHAPE dd] => [Ty.T_Tensor(Ty.ShapeVar dd)] --> Ty.realTy))
395 :     val op_norm_f = polyVar (N.op_norm, all([DK, NK, SK], fn [Ty.DIFF k,Ty.DIM d, Ty.SHAPE dd1] => let
396 : jhr 3392 val k = Ty.DiffVar(k, 0)
397 :     val d = Ty.DimVar d
398 :     val f1 = Ty.T_Field{diff = k, dim = d, shape = Ty.ShapeVar dd1}
399 :     val f2 = Ty.T_Field{diff = k, dim = d, shape = Ty.Shape []}
400 :     in
401 :     [f1] --> f2
402 :     end))
403 : jhr 3391
404 :     val op_not = monoVar (N.op_not, [Ty.T_Bool] --> Ty.T_Bool)
405 :    
406 :     (* cross product *)
407 :     local
408 :     val crossTy = let
409 :     val t = tensor[N3]
410 :     in
411 :     [t, t] --> t
412 :     end
413 :     val crossTy2 = let
414 :     val t = tensor[N2]
415 :     in
416 :     [t, t] --> Ty.realTy
417 :     end
418 :     in
419 :     val op_cross2_tt = monoVar (N.op_cross, crossTy2)
420 :     val op_cross3_tt = monoVar (N.op_cross, crossTy)
421 : jhr 3398 end (* local *)
422 : jhr 3391
423 :     val op_cross2_ff = polyVar (N.op_cross, all([DK], fn [Ty.DIFF k] => let
424 : jhr 3392 fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
425 :     val k0 = Ty.DiffVar(k, 0)
426 :     val f = field' (k0, 2, [2])
427 :     val t1 = field' (k0, 2, [])
428 :     in
429 :     [f, f] --> t1
430 :     end))
431 : jhr 3391
432 :     val op_cross3_ff = polyVar (N.op_cross, all([DK], fn [Ty.DIFF k] => let
433 : jhr 3392 fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
434 :     val f = field' (Ty.DiffVar(k, 0), 3, [3])
435 :     in
436 :     [f, f] --> f
437 :     end))
438 : jhr 3391
439 :     (* the inner product operator (including dot product) is treated as a special case in the
440 :     * typechecker. It is not included in the basis environment, but we define its type scheme
441 :     * here. There is an implicit constraint on its type to have the following scheme:
442 :     *
443 :     * ALL[sigma1, d1, sigma2] . tensor[sigma1, d1] * tensor[d1, sigma2] -> tensor[sigma1, sigma2]
444 :     *)
445 :     val op_inner_tt = polyVar (N.op_dot, all([SK,SK,SK],
446 : jhr 3392 fn [Ty.SHAPE s1, Ty.SHAPE s2, Ty.SHAPE s3] =>
447 :     [Ty.T_Tensor(Ty.ShapeVar s1), Ty.T_Tensor(Ty.ShapeVar s2)]
448 :     --> Ty.T_Tensor(Ty.ShapeVar s3)))
449 : jhr 3391 val op_inner_tf = polyVar (N.op_dot, all([DK,NK,SK,SK,SK],
450 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd1, Ty.SHAPE dd2, Ty.SHAPE dd3] => let
451 :     val k = Ty.DiffVar(k, 0)
452 :     val d = Ty.DimVar d
453 :     val t1 = Ty.T_Tensor(Ty.ShapeVar dd1)
454 :     val t2 = Ty.T_Field{diff = k, dim = d, shape = Ty.ShapeVar dd2}
455 :     val t3 = Ty.T_Field{diff = k, dim = d, shape = Ty.ShapeVar dd3}
456 :     in
457 :     [t1, t2] --> t3
458 :     end))
459 :     val op_inner_ft = polyVar (N.op_dot, all([DK,NK,SK,SK,SK],
460 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd1, Ty.SHAPE dd2, Ty.SHAPE dd3] => let
461 :     val k = Ty.DiffVar(k, 0)
462 :     val d = Ty.DimVar d
463 :     val t1 = Ty.T_Field{diff = k, dim = d, shape = Ty.ShapeVar dd1}
464 :     val t2 = Ty.T_Tensor(Ty.ShapeVar dd2)
465 :     val t3 = Ty.T_Field{diff = k, dim = d, shape = Ty.ShapeVar dd3}
466 :     in
467 :     [t1, t2] --> t3
468 :     end))
469 :     val op_inner_ff = polyVar (N.op_dot, all([DK,DK, NK, SK, SK, SK],
470 :     fn [Ty.DIFF k1,Ty.DIFF k2, Ty.DIM d, Ty.SHAPE dd1, Ty.SHAPE dd2, Ty.SHAPE dd3] => let
471 :     val k1 = Ty.DiffVar(k1, 0)
472 :     val k2 = Ty.DiffVar(k2, 0)
473 :     val d = Ty.DimVar d
474 :     val t1 = Ty.T_Field{diff = k1, dim = d, shape = Ty.ShapeVar dd1}
475 :     val t2 = Ty.T_Field{diff = k2, dim = d, shape = Ty.ShapeVar dd2}
476 :     val t3 = Ty.T_Field{diff = k1, dim = d, shape = Ty.ShapeVar dd3}
477 :     in
478 :     [t1, t2] --> t3
479 :     end))
480 :    
481 :     (* the colon (or double-dot) product operator is treated as a special case in the
482 :     * typechecker. It is not included in the basis environment, but we define its type
483 :     * scheme here. There is an implicit constraint on its type to have the following scheme:
484 :     *
485 :     * ALL[sigma1, d1, d2, sigma2] .
486 :     * tensor[sigma1, d1, d2] * tensor[d1, d2, sigma2] -> tensor[sigma1, sigma2]
487 :     *)
488 :     val op_colon_tt = polyVar (N.op_colon, all([SK,SK,SK],
489 : jhr 3392 fn [Ty.SHAPE s1, Ty.SHAPE s2, Ty.SHAPE s3] =>
490 :     [Ty.T_Tensor(Ty.ShapeVar s1), Ty.T_Tensor(Ty.ShapeVar s2)]
491 :     --> Ty.T_Tensor(Ty.ShapeVar s3)))
492 : jhr 3391 val op_colon_ff = polyVar (N.op_colon, all([DK,SK,NK,SK,SK],
493 : jhr 3398 fn [Ty.DIFF k,Ty.SHAPE dd1, Ty.DIM d, Ty.SHAPE dd2,Ty.SHAPE dd3] => let
494 : jhr 3392 val k0 = Ty.DiffVar(k, 0)
495 :     val d' = Ty.DimVar d
496 :     val t1 = Ty.T_Field{diff = k0, dim = d', shape = Ty.ShapeVar dd1}
497 :     val t2 = Ty.T_Field{diff = k0, dim = d', shape = Ty.ShapeVar dd2}
498 :     val t3 = Ty.T_Field{diff = k0, dim = d', shape = Ty.ShapeVar dd3}
499 :     in
500 :     [t1,t2] --> t3
501 :     end))
502 : jhr 3391 val op_colon_ft = polyVar (N.op_colon, all([DK,SK,NK,SK,SK],
503 : jhr 3398 fn [Ty.DIFF k,Ty.SHAPE dd1, Ty.DIM d, Ty.SHAPE s2,Ty.SHAPE dd3] => let
504 : jhr 3392 val k0 = Ty.DiffVar(k, 0)
505 :     val d' = Ty.DimVar d
506 :     val t1 = Ty.T_Field{diff = k0, dim = d', shape = Ty.ShapeVar dd1}
507 :     val t2 = Ty.T_Tensor(Ty.ShapeVar s2)
508 :     val t3 = Ty.T_Field{diff = k0, dim = d', shape = Ty.ShapeVar dd3}
509 :     in
510 :     [t1, t2] --> t3
511 :     end))
512 : jhr 3391 val op_colon_tf = polyVar (N.op_colon, all([DK,SK,NK,SK,SK],
513 : jhr 3398 fn [Ty.DIFF k,Ty.SHAPE s1, Ty.DIM d, Ty.SHAPE dd2,Ty.SHAPE dd3] => let
514 : jhr 3392 val k0 = Ty.DiffVar(k, 0)
515 :     val d' = Ty.DimVar d
516 :     val t1 = Ty.T_Tensor(Ty.ShapeVar s1)
517 :     val t2 = Ty.T_Field{diff = k0, dim = d', shape = Ty.ShapeVar dd2}
518 :     val t3 = Ty.T_Field{diff = k0, dim = d', shape = Ty.ShapeVar dd3}
519 :     in
520 :     [t1,t2] --> t3
521 :     end))
522 : jhr 3391
523 :     (* image size operation *)
524 :     val fn_size = polyVar (N.fn_size, all([NK, SK],
525 : jhr 3392 fn [Ty.DIM d, Ty.SHAPE dd] => let
526 : jhr 3391 val d = Ty.DimVar d
527 :     val dd = Ty.ShapeVar dd
528 :     in
529 : jhr 3398 [Ty.T_Image{dim=d, shape=dd}] --> Ty.T_Sequence(Ty.T_Int, SOME d)
530 : jhr 3391 end))
531 :    
532 :     (* functions that handle the boundary behavior of an image *)
533 :     local
534 :     fun img2img f = polyVar (f, all([NK, SK],
535 : jhr 3392 fn [Ty.DIM d, Ty.SHAPE dd] => let
536 :     val imgTy = Ty.T_Image{dim=Ty.DimVar d, shape=Ty.ShapeVar dd}
537 : jhr 3391 in
538 :     [imgTy] --> imgTy
539 :     end))
540 :     in
541 :     val image_border = polyVar (N.fn_border, all([NK, SK],
542 : jhr 3392 fn [Ty.DIM d, Ty.SHAPE dd] => let
543 : jhr 3391 val d = Ty.DimVar d
544 :     val dd = Ty.ShapeVar dd
545 :     in
546 :     [Ty.T_Image{dim=d, shape=dd}, Ty.T_Tensor dd]
547 : jhr 3392 --> Ty.T_Image{dim=d, shape=dd}
548 : jhr 3391 end))
549 :     val image_clamp = img2img N.fn_clamp
550 :     val image_mirror = img2img N.fn_mirror
551 :     val image_wrap = img2img N.fn_wrap
552 :     end (* local *)
553 :    
554 :     (* is a point inside the domain of a field? *)
555 :     val fn_inside = polyVar (N.fn_inside, all([DK, NK, SK],
556 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
557 :     val k = Ty.DiffVar(k, 0)
558 :     val d = Ty.DimVar d
559 :     val dd = Ty.ShapeVar dd
560 :     in
561 :     [Ty.T_Tensor(Ty.Shape[d]), field(k, d, dd)]
562 :     --> Ty.T_Bool
563 :     end))
564 :    
565 :     (* load image from nrrd *)
566 :     val fn_image = polyVar (N.fn_image, all([NK, SK],
567 :     fn [Ty.DIM d, Ty.SHAPE dd] => let
568 :     val d = Ty.DimVar d
569 :     val dd = Ty.ShapeVar dd
570 :     in
571 :     [Ty.T_String] --> Ty.T_Image{dim=d, shape=dd}
572 :     end))
573 :    
574 :     (* load dynamic sequence from nrrd *)
575 :     val fn_load = polyVar (N.fn_load, all([TK],
576 : jhr 3398 fn [Ty.TYPE tv] => [Ty.T_String] --> dynSeq(Ty.T_Var tv)))
577 : jhr 3391
578 :     val fn_length = polyVar (N.fn_length, all([TK],
579 : jhr 3398 fn [Ty.TYPE tv] => [dynSeq(Ty.T_Var tv)] --> Ty.T_Int))
580 : jhr 3391
581 :     val fn_max = monoVar (N.fn_max, [Ty.realTy, Ty.realTy] --> Ty.realTy)
582 :     val fn_min = monoVar (N.fn_min, [Ty.realTy, Ty.realTy] --> Ty.realTy)
583 :    
584 :     val fn_modulate = polyVar (N.fn_modulate, all([NK],
585 : jhr 3392 fn [Ty.DIM d] => let
586 :     val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])
587 :     in
588 :     [t, t] --> t
589 :     end))
590 : jhr 3391
591 :     val fn_normalize_t = polyVar (N.fn_normalize, all([NK],
592 : jhr 3392 fn [Ty.DIM d] => let
593 :     val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])
594 :     in
595 :     [t] --> t
596 :     end))
597 : jhr 3391 val fn_normalize_f = polyVar (N.fn_normalize, all([DK,NK,SK],
598 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd1] => let
599 : jhr 3392 val k0 = Ty.DiffVar(k, 0)
600 :     val d' = Ty.DimVar d
601 :     val f1 = Ty.T_Field{diff = k0, dim = d', shape = Ty.ShapeVar dd1}
602 :     in
603 :     [f1] --> f1
604 :     end))
605 : jhr 3391
606 :     (* outer product *)
607 :     local
608 :     fun mkOuter [Ty.DIM d1, Ty.DIM d2] = let
609 :     val vt1 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1])
610 :     val vt2 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d2])
611 :     val mt = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1, Ty.DimVar d2])
612 :     in
613 :     [vt1, vt2] --> mt
614 :     end
615 :     in
616 :     val op_outer_tt = polyVar (N.op_outer, all([NK, NK], mkOuter))
617 : jhr 3398 end (* local *)
618 : jhr 3391
619 :     local
620 :     fun mkOuterField [Ty.DIFF k, Ty.DIM d,Ty.DIM a, Ty.DIM b] = let
621 :     val k0 = Ty.DiffVar(k, 0)
622 :     val d' = Ty.DimVar d
623 :     val a' = Ty.DimVar a
624 :     val b' = Ty.DimVar b
625 :     val f = field(k0, d', Ty.Shape[a'])
626 :     val g = field(k0, d', Ty.Shape[b'])
627 :     val h = field(k0, d', Ty.Shape[a', b'])
628 :     in
629 :     [f, g] --> h
630 :     end
631 :     in
632 :     val op_outer_ff = polyVar (N.op_outer, all([DK,NK,NK,NK], mkOuterField))
633 : jhr 3398 end (* local *)
634 : jhr 3391
635 :     val fn_principleEvec = polyVar (N.fn_principleEvec, all([NK],
636 :     fn [Ty.DIM d] => let
637 :     val d = Ty.DimVar d
638 :     in
639 :     [matrix d] --> tensor[d]
640 :     end))
641 :    
642 :     val fn_trace_t = polyVar (N.fn_trace, all([NK],
643 :     fn [Ty.DIM d] => [matrix(Ty.DimVar d)] --> Ty.realTy))
644 :     val fn_trace_f = polyVar (N.fn_trace, all([DK,NK,SK],
645 :     fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd1] => let
646 :     val k' = Ty.DiffVar(k, 0)
647 :     val d' = Ty.DimVar d
648 :     val d1 = Ty.ShapeVar dd1
649 :     val f = field(k', d', Ty.ShapeExt(Ty.ShapeExt(d1, d'), d'))
650 :     val h = field(k', d', d1)
651 :     in
652 :     [f] --> h
653 :     end))
654 :    
655 :     val fn_transpose_t = polyVar (N.fn_transpose, all([NK, NK],
656 :     fn [Ty.DIM d1, Ty.DIM d2] =>
657 :     [tensor[Ty.DimVar d1, Ty.DimVar d2]] --> tensor[Ty.DimVar d2, Ty.DimVar d1]))
658 :     val fn_transpose_f = polyVar (N.fn_transpose, all([DK,NK,NK,NK],
659 :     fn [Ty.DIFF k, Ty.DIM d,Ty.DIM a, Ty.DIM b] => let
660 :     val k0 = Ty.DiffVar(k, 0)
661 :     val d' = Ty.DimVar d
662 :     val a' = Ty.DimVar a
663 :     val b' = Ty.DimVar b
664 :     val f = field(k0, d', Ty.Shape[a',b'])
665 :     val h = field(k0, d', Ty.Shape[b',a'])
666 :     in
667 :     [f] --> h
668 :     end))
669 :    
670 :     (* determinant: restrict to 2x2 and 3x3*)
671 :     val fn_det2_t = monoVar (N.fn_det, [matrix N2] --> Ty.realTy)
672 :     val fn_det3_t = monoVar (N.fn_det, [matrix N3] --> Ty.realTy)
673 :     val fn_det2_f = polyVar (N.fn_det, all([DK], fn [Ty.DIFF k] => let
674 : jhr 3392 fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
675 :     val k0 = Ty.DiffVar(k, 0)
676 :     val f = field' (k0, 2, [2,2])
677 :     val s = field' (k0, 2, [])
678 :     in
679 :     [f] --> s
680 :     end))
681 : jhr 3391 val fn_det3_f = polyVar (N.fn_det, all([DK], fn [Ty.DIFF k] => let
682 : jhr 3392 fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
683 :     val k0 = Ty.DiffVar(k, 0)
684 :     val f = field' (k0, 3, [3,3])
685 :     val s = field' (k0, 3, [])
686 :     in
687 :     [f] --> s
688 :     end))
689 : jhr 3391
690 :     (* sqrt *)
691 :     val fn_sqrt_t = monoVar (N.fn_sqrt, [Ty.realTy] --> Ty.realTy)
692 :     val fn_sqrt_f = polyVar (N.fn_sqrt, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let
693 : jhr 3392 val k' = Ty.DiffVar(k, 0)
694 :     val d' = Ty.DimVar d
695 :     val f = field(k', d', Ty.Shape[])
696 :     in
697 :     [f] --> f
698 :     end))
699 : jhr 3391
700 :     (* cosine *)
701 :     val fn_cos_t = monoVar (N.fn_cos, [Ty.realTy] --> Ty.realTy)
702 :     val fn_cos_f = polyVar (N.fn_cos, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let
703 : jhr 3392 val k' = Ty.DiffVar(k, 0)
704 :     val d' = Ty.DimVar d
705 :     val f = field(k', d', Ty.Shape[])
706 :     in
707 :     [f] --> f
708 :     end))
709 : jhr 3391
710 :     (* arc cosine *)
711 :     val fn_acos_t = monoVar (N.fn_acos, [Ty.realTy] --> Ty.realTy)
712 :     val fn_acos_f = polyVar (N.fn_acos, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let
713 : jhr 3392 val k' = Ty.DiffVar(k, 0)
714 :     val d' = Ty.DimVar d
715 :     val f = field(k', d', Ty.Shape[])
716 :     in
717 :     [f] --> f
718 :     end))
719 : jhr 3391
720 :     (* sine *)
721 :     val fn_sin_t = monoVar (N.fn_sin, [Ty.realTy] --> Ty.realTy)
722 :     val fn_sin_f = polyVar (N.fn_sin, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let
723 :     val k' = Ty.DiffVar(k, 0)
724 :     val d' = Ty.DimVar d
725 :     val f = field(k', d', Ty.Shape[])
726 :     in
727 :     [f] --> f
728 :     end))
729 :    
730 :     (* arc sine *)
731 :     val fn_asin_t = monoVar (N.fn_asin, [Ty.realTy] --> Ty.realTy)
732 :     val fn_asin_f = polyVar (N.fn_asin, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let
733 :     val k' = Ty.DiffVar(k, 0)
734 :     val d' = Ty.DimVar d
735 :     val f = field(k', d', Ty.Shape[])
736 :     in
737 : jhr 3392 [f] --> f
738 : jhr 3391 end))
739 :    
740 : jhr 3398 (* Math functions that have not yet been lifted to work on fields *)
741 :     local
742 :     fun mk (name, n) =
743 :     monoVar(Atom.atom name, List.tabulate(n, fn _ => Ty.realTy) --> Ty.realTy)
744 :     in
745 :     val fn_atan_t = mk("atan", 1)
746 :     val fn_atan2_tt = mk("atan2", 2)
747 :     val fn_ceil_t = mk("ceil", 1)
748 :     val fn_floor_t = mk("floor", 1)
749 :     val fn_fmod_tt = mk("fmod", 2)
750 :     val fn_exp_t = mk("exp", 1)
751 :     val fn_erf_t = mk("erf", 1)
752 :     val fn_erfc_t = mk("erfc", 1)
753 :     val fn_log_t = mk("log", 1)
754 :     val fn_log10_t = mk("log10", 1)
755 :     val fn_log2_t = mk("log2", 1)
756 :     val fn_pow_tt = mk("pow", 2) (* also used to implement ^ operator *)
757 :     val fn_tan_t = mk("tan", 1)
758 :     end (* local *)
759 :    
760 : jhr 3392 (* Query functions *)
761 :     local
762 : jhr 3398 val implicit = fn [Ty.TYPE tv] => [Ty.realTy] --> dynSeq(Ty.T_Var tv)
763 :     val realTy = fn [Ty.TYPE tv] => [Ty.realTy, Ty.realTy] --> dynSeq(Ty.T_Var tv)
764 : jhr 3392 val vec2Ty = let
765 :     val t = tensor[N2]
766 :     in
767 : jhr 3398 fn [Ty.TYPE tv] => [t, Ty.realTy] --> dynSeq(Ty.T_Var tv)
768 : jhr 3392 end
769 :     val vec3Ty = let
770 :     val t = tensor[N3]
771 :     in
772 : jhr 3398 fn [Ty.TYPE tv] => [t, Ty.realTy] --> dynSeq(Ty.T_Var tv)
773 : jhr 3392 end
774 :     in
775 :     val fn_sphere_im = polyVar (N.fn_sphere, all([TK], implicit))
776 :     val fn_sphere1_r = polyVar (N.fn_sphere, all([TK], realTy))
777 :     val fn_sphere2_t = polyVar (N.fn_sphere, all([TK], vec2Ty))
778 :     val fn_sphere3_t = polyVar (N.fn_sphere, all([TK], vec3Ty))
779 :     end (* local *)
780 :    
781 : jhr 3431 (* Sets of strands *)
782 :     local
783 :     fun mkSetFn name = polyVar (name, all([TK], fn [Ty.TYPE tv] => [] --> dynSeq(Ty.T_Var tv)))
784 :     in
785 :     val set_active = mkSetFn N.set_active
786 : jhr 3463 val set_all = mkSetFn N.set_all
787 : jhr 3431 val set_stable = mkSetFn N.set_stable
788 :     end
789 :    
790 : jhr 3392 (* reduction operators *)
791 :     local
792 :     fun reduction (name, elemTy) =
793 : jhr 3398 monoVar (name, [dynSeq elemTy] --> elemTy)
794 : jhr 3392 in
795 : jhr 3398 val red_all = reduction (N.fn_all, Ty.T_Bool)
796 :     val red_exists = reduction (N.fn_exists, Ty.T_Bool)
797 :     val red_max = reduction (N.fn_max, Ty.realTy)
798 :     val red_mean = reduction (N.fn_mean, Ty.realTy)
799 :     val red_min = reduction (N.fn_min, Ty.realTy)
800 :     val red_product = reduction (N.fn_product, Ty.realTy)
801 :     val red_sum = reduction (N.fn_sum, Ty.realTy)
802 :     val red_variance = reduction (N.fn_variance, Ty.realTy)
803 : jhr 3392 end (* local *)
804 :    
805 : jhr 3391 (* kernels *)
806 :     (* FIXME: we should really get the continuity info from the kernels themselves *)
807 :     val kn_bspln3 = monoVar (N.kn_bspln3, Ty.T_Kernel(Ty.DiffConst 2))
808 :     val kn_bspln5 = monoVar (N.kn_bspln5, Ty.T_Kernel(Ty.DiffConst 4))
809 :     val kn_c4hexic = monoVar (N.kn_c4hexic, Ty.T_Kernel(Ty.DiffConst 4))
810 :     val kn_ctmr = monoVar (N.kn_ctmr, Ty.T_Kernel(Ty.DiffConst 1))
811 :     val kn_tent = monoVar (N.kn_tent, Ty.T_Kernel(Ty.DiffConst 0))
812 :    
813 :     (***** internal variables *****)
814 :    
815 :     (* integer to real conversion *)
816 :     val i2r = monoVar (Atom.atom "$i2r", [Ty.T_Int] --> Ty.realTy)
817 :    
818 :     (* identity matrix *)
819 :     val identity = polyVar (Atom.atom "$id", allNK (fn dv => [] --> matrix(Ty.DimVar dv)))
820 :    
821 :     (* zero tensor *)
822 :     val zero = polyVar (Atom.atom "$zero", all ([SK],
823 : jhr 3392 fn [Ty.SHAPE dd] => [] --> Ty.T_Tensor(Ty.ShapeVar dd)))
824 : jhr 3391
825 :     (* NaN tensor *)
826 :     val nan = polyVar (Atom.atom "$nan", all ([SK],
827 : jhr 3392 fn [Ty.SHAPE dd] => [] --> Ty.T_Tensor(Ty.ShapeVar dd)))
828 : jhr 3391
829 :     (* sequence subscript *)
830 :     val subscript = polyVar (Atom.atom "$sub", all ([TK, NK],
831 : jhr 3392 fn [Ty.TYPE tv, Ty.DIM d] =>
832 : jhr 3398 [Ty.T_Sequence(Ty.T_Var tv, SOME(Ty.DimVar d)), Ty.T_Int] --> Ty.T_Var tv))
833 : jhr 3391
834 :     val dynSubscript = polyVar (Atom.atom "$dynsub", all ([TK],
835 : jhr 3398 fn [Ty.TYPE tv] => [dynSeq(Ty.T_Var tv), Ty.T_Int] --> Ty.T_Var tv))
836 : jhr 3391
837 :     (* range expressions *)
838 : jhr 3398 val range = monoVar (Atom.atom "$range", [Ty.T_Int, Ty.T_Int] --> dynSeq Ty.T_Int)
839 : jhr 3391
840 :     end (* local *)
841 :     end

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