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

SCM Repository

[diderot] Annotation of /branches/charisee/src/compiler/ein/mkoperators.sml
ViewVC logotype

Annotation of /branches/charisee/src/compiler/ein/mkoperators.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2906 - (view) (download)

1 : cchiw 2844 (* creates EIN operators
2 : cchiw 2499 *
3 :     * COPYRIGHT (c) 2012 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     * All rights reserved.
5 :     *)
6 :    
7 :     structure mkOperators = struct
8 :    
9 :     local
10 :    
11 :     structure E = Ein
12 :     structure P=Printer
13 :     in
14 :    
15 : cchiw 2844 fun specialize(alpha,inc)= List.tabulate(length(alpha), (fn(x)=>E.V (x+inc)))
16 : cchiw 2845 fun sumIds(n,i)=List.tabulate(n, (fn v=>(E.V v, 0, i)))
17 : cchiw 2499
18 : cchiw 2906
19 :     (******************************* Add *****************************************)
20 :     val addRR = E.EIN{
21 :     params = [E.TEN(1,[]), E.TEN(1,[])] ,
22 :     index = [],
23 :     body = E.Add[ E.Tensor(0, []), E.Tensor(1, [])]
24 :     }
25 :    
26 : cchiw 2499 (* Adding tensors : < X{\alpha} + Y_{\alpha}>_{\alpha} *)
27 : cchiw 2906 fun addTT alpha =let
28 : cchiw 2844 val expindex= specialize(alpha,0)
29 : cchiw 2499 in
30 :     E.EIN{
31 : cchiw 2845 params = [E.TEN(1,alpha), E.TEN(1,alpha)],
32 :     index = alpha,
33 :     body = E.Add[E.Tensor(0, expindex), E.Tensor(1, expindex)]
34 : cchiw 2499 }
35 :     end
36 :    
37 : cchiw 2906 (* mkField functions*)
38 :     (*Adding Fields : < F{\alpha} + G_{\alpha}>_{\alpha} *)
39 :     fun addFF(dim,shape) =let
40 :     val expindex= specialize(shape,0)
41 :     in E.EIN{
42 :     params = [E.FLD(dim),E.FLD(dim)],
43 :     index = shape,
44 :     body = E.Add[E.Field(0, expindex),E.Field(1, expindex)]
45 :     }
46 :     end
47 : cchiw 2502
48 : cchiw 2906 (*Tensor and Fields*)
49 :     fun addTF(dim,shape) =let
50 :     val expindex= specialize(shape,0)
51 :     in E.EIN{
52 :     params = [E.TEN(1,shape),E.FLD(dim)],
53 :     index = shape,
54 :     body = E.Add[E.Lift(E.Tensor(0, expindex)),E.Field(1, expindex)]
55 :     }
56 :     end
57 :     (********************************* Sub **************************************)
58 :     (* Subtract Scalars*)
59 :     val subRR = E.EIN{
60 :     params = [E.TEN(1,[]), E.TEN(1,[])],
61 :     index = [],
62 :     body = E.Sub( E.Tensor(0, []), E.Tensor(1, []))
63 :     }
64 :    
65 :     fun subTT alpha=let
66 : cchiw 2844 val expindex= specialize(alpha,0)
67 : cchiw 2499 in
68 :     E.EIN{
69 : cchiw 2845 params = [E.TEN(1,alpha), E.TEN(1,alpha)],
70 :     index = alpha,
71 :     body = E.Sub(E.Tensor(0, expindex), E.Tensor(1, expindex))
72 :     }
73 : cchiw 2499 end
74 : cchiw 2906
75 :     fun subTF(dim,shape) =let
76 :     val expindex= specialize(shape,0)
77 : cchiw 2845 in
78 :     E.EIN{
79 : cchiw 2906 params = [E.TEN(1,shape),E.FLD(dim)],
80 :     index = shape,
81 :     body = E.Add[E.Lift(E.Tensor(0, expindex)),E.Neg(E.Field(1, expindex))]
82 : cchiw 2845 }
83 : cchiw 2906 end
84 :    
85 :     fun subFT(dim,shape) = let
86 :     val expindex= specialize(shape,0)
87 :     in
88 :     E.EIN{
89 :     params = [E.TEN(1,[]),E.FLD(dim)],
90 :     index = shape,
91 :     body = E.Sub(E.Field(1, expindex),E.Lift(E.Tensor(0, expindex)))
92 :     }
93 : cchiw 2499 end
94 : cchiw 2906
95 :     fun subFF(dim,shape) =let
96 :     val expindex= specialize(shape,0)
97 :     in E.EIN{
98 :     params = [E.FLD(dim),E.FLD(dim)],
99 :     index = shape,
100 :     body = E.Sub(E.Field(0, expindex),E.Field(1, expindex))
101 :     }
102 :     end
103 :     (********************************** mul *************************************)
104 :     (* Product Scalars*)
105 :     val mulRR = E.EIN{
106 :     params =[E.TEN(1,[]), E.TEN(1,[])],
107 : cchiw 2845 index = [],
108 : cchiw 2906 body = E.Prod[ E.Tensor(0, []), E.Tensor(1, [])]
109 : cchiw 2845 }
110 : cchiw 2499
111 : cchiw 2906 (* scalar times tensor product: <s * T_{\alpha}>_{\alpha} *)
112 :     fun mulRT alpha = let
113 :     val expindex= specialize(alpha,0)
114 : cchiw 2845 in
115 :     E.EIN{
116 : cchiw 2906 params = [E.TEN(1,[]), E.TEN(1,alpha)],
117 : cchiw 2845 index = alpha,
118 : cchiw 2906 body = E.Prod[ E.Tensor(0, []), E.Tensor(1, expindex)]
119 : cchiw 2845 }
120 : cchiw 2499 end
121 : cchiw 2906
122 :     fun mulRF(dim,shape) =let
123 :     val expindex= specialize(shape,0)
124 :     in E.EIN{
125 :     params = [E.TEN(1,[]),E.FLD(dim)],
126 :     index = shape,
127 :     body = E.Prod[E.Lift( E.Tensor(0,[])), E.Field(1,expindex)]
128 :     }
129 :     end
130 :    
131 :     fun mulSS dim = E.EIN{
132 :     params = [E.FLD(dim),E.FLD(dim)],
133 :     index = [],
134 :     body = E.Prod[E.Field(0, []),E.Field(1, [])]
135 :     }
136 :    
137 :     fun mulSF(dim,shape) =let
138 :     val expindex= specialize(shape,0)
139 :     in E.EIN{
140 :     params = [E.FLD(dim),E.FLD(dim)],
141 :     index = shape,
142 :     body = E.Prod[E.Field(0, []),E.Field(1, expindex)]
143 :     }
144 :     end
145 :    
146 :     (************************************div ************************************)
147 :     (* Divide Scalars*)
148 :     val divRR = E.EIN{
149 :     params = [E.TEN(1,[]), E.TEN(1,[])],
150 :     index = [],
151 :     body = E.Div( E.Tensor(0, []), E.Tensor(1, []))
152 :     }
153 :    
154 :     fun divTR alpha =let
155 : cchiw 2844 val expindex= specialize(alpha,0)
156 : cchiw 2845 in
157 :     E.EIN{
158 : cchiw 2906 params = [E.TEN(1,alpha), E.TEN(1,[])],
159 : cchiw 2845 index = alpha,
160 : cchiw 2906 body = E.Div(E.Tensor(0, expindex), E.Tensor(1,[]))
161 : cchiw 2845 }
162 : cchiw 2906 end
163 :    
164 :     fun divFR(dim,shape) = let
165 :     val expindex= specialize(shape,0)
166 :     in E.EIN{
167 :     params = [E.FLD(dim),E.TEN(1,[])],
168 :     index = shape,
169 :     body = E.Div(E.Field(0, expindex),E.Lift( E.Tensor(1, [])))
170 :     }
171 :     end
172 :    
173 :     fun divSS dim = E.EIN{
174 :     params = [E.FLD(dim),E.FLD(dim)],
175 :     index = [],
176 :     body = E.Div(E.Field(0, []),E.Field(1, []))
177 :     }
178 :    
179 :     fun divFS(dim,shape) = let
180 :     val expindex= specialize(shape,0)
181 :     in E.EIN{
182 :     params = [E.FLD(dim),E.FLD(dim)],
183 :     index = shape,
184 :     body = E.Prod[E.Field(0, expindex),E.Div(E.Const 1,E.Field(1, []))]
185 :     }
186 :     end
187 :     (************************************* Neg **********************************)
188 :     fun negTT alpha=let
189 :     val expindex= specialize(alpha,0)
190 :     in
191 :     E.EIN{
192 :     params = [E.TEN(1,alpha)],index = alpha,
193 :     body = E.Neg(E.Tensor(0, expindex))
194 :     }
195 :     end
196 :    
197 :     fun negFF(dim,shape) = let
198 :     val expindex = specialize(shape,0)
199 :     in E.EIN{
200 :     params = [E.FLD(dim)],index = shape,
201 :     body = E.Neg(E.Field(0, expindex))
202 :     }
203 :     end
204 :    
205 :     (****************************** cross ***********************************)
206 :     (*crossProduct is on 3D vectors ..vec3 t8=t0 × t1; *)
207 :     val cross3TT = E.EIN{
208 :     params = [E.TEN(1,[3]), E.TEN(1,[3])],
209 :     index= [3],
210 :     body=E.Sum([(E. V 1,0,2),(E.V 2,0,2)],
211 :     E.Prod[ E.Epsilon(0, 1, 2),
212 :     E.Tensor(0, [E.V 1]), E.Tensor(1, [E.V 2 ]) ])
213 :     }
214 :    
215 :     (*2-d cross product Eps_{ij}U_i V_j*)
216 :     val cross2TT = E.EIN{
217 :     params = [E.TEN(1,[2]), E.TEN(1,[2])],
218 :     index= [],
219 :     body=E.Sum([(E. V 0,0,1),(E.V 1,0,1)],
220 :     E.Prod[ E.Eps2(0, 1), E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1])])
221 :     }
222 :    
223 :     (*Field Cross Product*)
224 :     val cross2FF = E.EIN{
225 :     params = [E.FLD(2), E.FLD(2)],index= [],
226 :     body=E.Sum([(E. V 0,0,1),(E.V 1,0,1)],
227 :     E.Prod[ E.Eps2(0, 1), E.Field(0, [E.V 0]), E.Field(1, [E.V 1]) ])
228 :     }
229 :    
230 :     (*Field Cross Product*)
231 :     val cross3FF = E.EIN{
232 :     params = [E.FLD(3), E.FLD(3)],index= [3],
233 :     body=E.Sum([(E. V 1,0,2),(E.V 2,0,2)],
234 :     E.Prod[ E.Epsilon(0, 1, 2),
235 :     E.Field(0, [E.V 1]), E.Field(1, [E.V 2 ]) ])
236 :     }
237 :     (******************** outerProduct ********************************)
238 :     (*Vector Examples : <T_i * T_j>_ij..t0⊗t1*)
239 :     fun outerTT(dimA,dimB) =
240 : cchiw 2845 E.EIN{
241 : cchiw 2906 params = [E.TEN(1,[dimA]), E.TEN(1,[dimB])],
242 :     index= [dimA,dimB],
243 :     body= E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1])]
244 :     }
245 :    
246 :     (*Assumes same dimension vector field *)
247 :     fun outerFF dim =
248 :     E.EIN{
249 :     params = [E.FLD(dim),E.FLD(dim)],
250 :     index = [dim, dim],
251 :     body = E.Prod[E.Field(0, [E.V 0]),E.Field(1, [E.V 1])]
252 :     }
253 : cchiw 2845
254 : cchiw 2906 (*************************** inner product **********************************)
255 : cchiw 2499 (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)
256 : cchiw 2906 fun innerTT(shape1,i::beta) = let
257 : cchiw 2499 val alpha= List.take(shape1,length(shape1)-1)
258 : cchiw 2844 val expindexA= specialize(alpha,0)
259 :     val expindexB= specialize(beta,(length(alpha)))
260 : cchiw 2499 val s'=E.V(length(alpha)+ length(beta))
261 : cchiw 2515 val s''=[(s',0,i-1)]
262 : cchiw 2845 in
263 :     E.EIN{
264 :     params = [E.TEN(1,shape1) ,E.TEN(1,i::beta)],
265 :     index = alpha@beta,
266 :     body = E.Sum(s'', E.Prod[
267 : cchiw 2906 E.Tensor(0, expindexA@[s']), (* T_{\alpha i} *)
268 :     E.Tensor(1, [s']@expindexB ) (* T'_{i \beta} *)])
269 : cchiw 2845 }
270 : cchiw 2605 end
271 : cchiw 2906 | innerTT _ = raise Fail "Wrong shape for inner product"
272 :    
273 :     (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)
274 :     fun innerFF(shape1,dim,i::beta) = let
275 :     val alpha= List.take(shape1,length(shape1)-1)
276 :     val expindexA= specialize(alpha,0)
277 :     val expindexB= specialize(beta,(length(alpha)))
278 :     val sid=E.V(length(alpha)+ length(beta))
279 :     in E.EIN{
280 :     params = [E.FLD(dim) ,E.FLD(dim)],index = alpha@beta,
281 :     body = E.Sum([(sid,0,i-1)],
282 :     E.Prod[
283 :     E.Field(0, expindexA@[sid]), (* F_{\alpha i} *)
284 :     E.Field(1, [sid]@expindexB ) (* F'_{i \beta} *)
285 :     ])}
286 :     end
287 :     | innerFF _ = raise Fail "Wrong shape for innerProductField"
288 : cchiw 2499
289 : cchiw 2906 (*************************** colon product **********************************)
290 : cchiw 2499 (*<T_{\alpha i j} * B{i j \beta }>_\alpha \beta*)
291 : cchiw 2906 fun colonTT(shape1,i::j::beta) = let
292 : cchiw 2499 val alpha= List.take(shape1,length(shape1)-2)
293 : cchiw 2844 val expindexA= specialize(alpha,0)
294 :     val expindexB= specialize(beta,(length(alpha)))
295 : cchiw 2499 val sumi=length(alpha)+ length(beta)
296 :     val s'=[E.V sumi,E.V(sumi+1)]
297 : cchiw 2906 val sx=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]
298 : cchiw 2845 in
299 :     E.EIN{
300 :     params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],
301 :     index = alpha@beta,
302 : cchiw 2906 body = E.Sum(sx,E.Prod[ E.Tensor(0, expindexA@s'), E.Tensor(1,s'@expindexB)])
303 : cchiw 2845 }
304 : cchiw 2499 end
305 : cchiw 2906
306 :     (*<F_{\alpha i j} * G{i j \beta }>_\alpha \beta*)
307 :     fun colonFF(shape1,i::j::beta) = let
308 :     val alpha= List.take(shape1,length(shape1)-2)
309 :     val expindexA= specialize(alpha,0)
310 :     val expindexB= specialize(beta,(length(alpha)))
311 :     val sumi=length(alpha)+ length(beta)
312 :     val s'=[E.V sumi,E.V(sumi+1)]
313 :     val sx=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]
314 :     in
315 :     E.EIN{
316 :     params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],
317 :     index = alpha@beta,
318 :     body = E.Sum(sx,E.Prod[E.Field(0, expindexA@s'), E.Field(1,s'@expindexB)])
319 :     }
320 :     end
321 :    
322 :     (******************** Norm ********************************)
323 : cchiw 2845 (*get norm, but without the sqrt
324 :     * implemented as a summation over a modulate
325 :     *)
326 : cchiw 2906 fun magnitudeTT alpha =let
327 :     val i=List.hd alpha
328 :     val expindex= specialize(alpha,0)
329 :     val sx= sumIds(length(alpha),i-1)
330 :     in E.EIN{
331 : cchiw 2845 params = [E.TEN(1,alpha), E.TEN(1,alpha)],
332 :     index = [],
333 :     body = E.Sum(sx,
334 : cchiw 2906 E.Prod[E.Tensor(0, expindex), E.Tensor(1, expindex)])
335 : cchiw 2845 }
336 :     end
337 :    
338 : cchiw 2906 fun magnitudeFF(dim,[]) =
339 :     E.EIN{params = [E.FLD(dim)],index = [],body = E.Field(0, [])}
340 :     | magnitudeFF(dim,shape1 as i::beta) = let
341 :     val alpha= List.take(shape1,(length(shape1))-1)
342 :     val alphan=length(alpha)
343 :     val betan=length(beta)
344 :     val expindexA= specialize(alpha,0)
345 :     val expindexB= specialize(beta,alphan)
346 :     val sid=E.V(alphan+ betan)
347 :     in
348 :     E.EIN{
349 :     params = [E.FLD(dim) ,E.FLD(dim)],
350 :     index = alpha@beta,
351 :     body = E.Sqrt(E.Sum([(sid,0,i-1)], E.Prod[
352 :     E.Field(0, expindexA@[sid]),
353 :     E.Field(1, [sid]@expindexB )
354 :     ]))
355 :     }
356 :     end
357 :    
358 :     fun normalizeFF(dim,[i]) = let
359 :     val sx=[(E.V 0,0,i-1)]
360 :     val f=E.Field(0, [E.V 0])
361 : cchiw 2845 in E.EIN{
362 : cchiw 2906 params = [E.FLD(dim) ,E.FLD(dim)],index = [dim],
363 :     body = E.Prod[f,
364 :     E.Div(E.Const 1,E.Sqrt(E.Sum(sx, E.Prod[f,f])))]
365 :     }
366 : cchiw 2845 end
367 : cchiw 2906 | normalizeFF(dim,_) =raise Fail"unsupported normalize"
368 : cchiw 2499
369 : cchiw 2906 (************************* trace *************************)
370 :     (* Trace: <M_{i, i}> This one Sx represents both i's*)
371 :     fun traceT dim = E.EIN{
372 :     params = [E.TEN(1,[dim,dim])],index = [],
373 :     body = E.Sum([(E.V 0,0,dim-1)],E.Tensor(0, [E.V 0, E.V 0]))
374 :     }
375 :    
376 :     (* Trace: <Sigma_i F_{\alpha i, i}> This one Sx represents both i's*)
377 :     fun traceF(dim,alpha) =let
378 :     val expindex= specialize(alpha,0)
379 :     val s=E.V(length(alpha))
380 :     in
381 :     E.EIN{
382 :     params = [E.FLD(dim)],
383 :     index = alpha,
384 :     body = E.Sum([(s,0,dim-1)],E.Field(0, expindex@[s,s]))
385 :     }
386 :     end
387 : cchiw 2499
388 : cchiw 2906 (************************* tranpose *************************)
389 :     fun transposeT alpha =E.EIN{
390 :     params = [E.TEN(1,alpha)],
391 :     index= List.rev alpha,
392 :     body= E.Tensor(0, [E.V 1,E.V 0])
393 :     }
394 : cchiw 2843
395 : cchiw 2906 (*Transpose Field F_{ji}*)
396 :     fun transposeF(dim,i,j) =E.EIN{
397 :     params = [E.FLD(dim)], index= [i,j],
398 :     body= E.Field(0, [E.V 1,E.V 0])
399 :     }
400 : cchiw 2843
401 : cchiw 2906 (************************* other tensor ops *************************)
402 :     fun modulate dim =E.EIN{
403 :     params = [E.TEN(1,[dim]), E.TEN(1,[dim])],
404 :     index = [dim],
405 :     body = E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 0])]
406 :     }
407 :    
408 : cchiw 2844 fun identity dim =E.EIN{
409 : cchiw 2906 params = [],index = [dim,dim], body = E.Delta(E.V(0), E.V(1))
410 :     }
411 : cchiw 2499
412 : cchiw 2906 fun slice (argTy,mask,const,rstTy) =let
413 :     fun iter ([],_,cnt)=[]
414 :     | iter(true::es,c::cs,cnt)=[E.C c]@iter(es,cs,cnt)
415 :     |iter(false::es,cs,cnt)=[E.V cnt]@iter(es,cs,cnt+1)
416 :     val ix=iter(mask,const,0)
417 :     in
418 :     E.EIN{ params = [E.TEN(1,argTy)],index = rstTy,body = E.Tensor(0, ix)}
419 : cchiw 2499 end
420 :    
421 : cchiw 2906 (******************** other field ops ********************************)
422 :     (*FLD here is bounded to image field, and dimension of h*)
423 :     fun conv(dim,shape) =let
424 :     val expindex= specialize(shape,0)
425 :     in E.EIN{
426 :     params = [E.IMG(dim,shape),E.KRN],
427 : cchiw 2844 index = shape,
428 : cchiw 2906 body= E.Conv(0,expindex,1,[])
429 :     }
430 :     end
431 :    
432 :     (* Probe: <F(x)>_{\alpha} *)
433 :     fun probe(alpha,dim) = let
434 :     val expindex= specialize(alpha,0)
435 : cchiw 2499 in E.EIN{
436 : cchiw 2906 params = [E.FLD(dim),E.TEN(0,[])], index= alpha,
437 :     body= E.Probe(E.Field(0, expindex), E.Tensor(1,[]))
438 :     }
439 : cchiw 2499 end
440 : cchiw 2906 (***************************** derivative ****************************)
441 :     (*\EinExp{\sum_{ij}\mathcal{E}_{ij} \frac{ F_j}{\partial x_i}*)
442 :     val curl2d=E.EIN{
443 :     params = [E.FLD 2],
444 :     index = [],
445 :     body = E.Sum([(E.V 0,0,1), (E.V 1,0,1)],
446 :     E.Prod[E.Eps2(0, 1),
447 :     E.Apply( E.Partial([E.V 0]), E.Field(0,[E.V 1]))])
448 : cchiw 2499 }
449 : cchiw 2906
450 :     val curl3d=E.EIN{
451 :     params = [E.TEN(1,[3])],
452 :     index = [3],
453 :     body = E.Sum([(E.V 1,0,2), (E.V 2,0,2)],E.Prod[E.Epsilon(0, 1, 2),
454 :     E.Apply( E.Partial([E.V 1]), E.Field(0,[E.V 2]))])
455 : cchiw 2499 }
456 : cchiw 2906
457 : cchiw 2509 (*< d F / d_i>_i *)
458 : cchiw 2845 fun grad alpha=let
459 : cchiw 2605 val a=List.hd(alpha)
460 : cchiw 2844 val expindex= specialize(alpha,0)
461 : cchiw 2499 in E.EIN{
462 :     params = [E.FLD(a)],
463 : cchiw 2844 index =alpha,
464 :     body = E.Apply(E.Partial(expindex),E.Field(0,[]))
465 : cchiw 2906 }
466 : cchiw 2499 end
467 : cchiw 2906
468 : cchiw 2845 (*< Sigma d F_alpha / d x_i>ALpha i CHANGE HERE *)
469 :     fun dotimes(dim,alpha)= let
470 :     val n=length(alpha)
471 :     fun expIndex(n,inc)=List.tabulate(n, (fn(x)=>E.V (x+inc)))
472 :     val i'=expIndex(n,0)
473 : cchiw 2515 in E.EIN{
474 : cchiw 2530 params = [E.FLD(dim)], index =alpha@[dim],
475 :     body = E.Apply(E.Partial [E.V n] ,E.Field(0,i'))
476 : cchiw 2906 }
477 : cchiw 2515 end
478 : cchiw 2906
479 :     (* <d F_i /d_i> *)
480 :     fun divergence(dim,alpha)=let
481 : cchiw 2845 val expindex= specialize(alpha,0)
482 :     val sumI=length(alpha)
483 :     val sumIndex=E.V(sumI)
484 :     val sumIndexL=[sumIndex]
485 :     val S=expindex@sumIndexL
486 : cchiw 2499 in E.EIN{
487 :     params = [E.FLD(dim)],
488 : cchiw 2844 index = alpha,
489 : cchiw 2906 body = E.Sum([(sumIndex,0,dim-1)],
490 :     E.Apply(E.Partial(sumIndexL),E.Field(0,S)))
491 : cchiw 2845 }
492 : cchiw 2576 end
493 : cchiw 2867
494 : cchiw 2499 end; (* local *)
495 :    
496 :     end (* local *)

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