Diff of /branches/charisee/src/compiler/translate/translate-basis.sml

Parent Directory | Revision Log | Patch

	revision 2492, Tue Oct 22 15:25:50 2013 UTC	revision 2922, Tue Mar 3 03:55:09 2015 UTC
#	Line 23	Line 23
23	structure Op = HighOps	structure Op = HighOps
24	structure Ty = SimpleTypes	structure Ty = SimpleTypes
25	structure VTbl = Var.Tbl	structure VTbl = Var.Tbl
26	structure EinOp = Operators	structure mk= mkOperators
	structure S = Specialize
27
28	fun trType (Ty.TY ty) = TranslateTy.tr ty	fun trType (Ty.TY ty) = TranslateTy.tr ty
29	| trType _ = raise Fail "expected type"	| trType _ = raise Fail "expected type"
#	Line 51	Line 50
50
51	fun kernel h (y, [], []) = assign(y, Op.Kernel(h, 0), [])	fun kernel h (y, [], []) = assign(y, Op.Kernel(h, 0), [])
52
53		val cnt = ref 0
54		fun genName prefix = let
55		val n = !cnt
56		in
57		cnt := n+1;
58		String.concat[prefix, "_", Int.toString n]
59		end
60	(* utility functions for synthesizing eigenvector/eigenvalue code *)	(* utility functions for synthesizing eigenvector/eigenvalue code *)
61	fun eigenVec (rator, dim) = let	fun eigenVec (rator, dim) = let
62	val ty = DstTy.SeqTy(DstTy.realTy, dim)	val ty = DstTy.SeqTy(DstTy.realTy, dim)
#	Line 71	Line 77
77	end	end
78	end	end
79
80	fun assignEin (y, rator, xs) = [IL.ASSGN(y, IL.EINAPP(rator, xs))]	fun assignEin (y, rator, xs) = IL.ASSGN(y, IL.EINAPP(rator, xs))
	fun assignEin2 (y, rator, xs) = IL.ASSGN(y, IL.EINAPP(rator, xs))
81
82	fun simpleEinOp rator (y, _,xs) = assignEin(y, rator, xs)	fun  simpleEOp rator (y, _,xs) = [assignEin(y, rator, xs)]
	fun peelFieldSK SK = [2]  (*(case TU.pruneShape(MV.toShape SK)
	of Ty.Shape dd =>  List.map pruneDim dd
	| shp => raise Fail("unresolved shape " ^ TU.shapeToString shp)
	(* end case *))*)
	fun tensorEinOp einop (y, [shp], xs) = let
	val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
	val rator =S.transform(einop, [dd1], [])
	in
	assignEin(y, rator,xs)
	end
	fun scalarField (einop, paramarg, y, xs) = let
	val paramarg' = List.map dimVarToInt paramarg(*[2]*)
	val rator = S.transform(einop, [[]], paramarg')
	in
	assignEin(y, rator, xs)
	end
	fun singleField (SK, einop, paramarg, y, xs) = let
	val s=peelFieldSK SK
	val paramarg'= List.map dimVarToInt paramarg (*[2]*)
	val rator= S.transform(einop, [s], paramarg')
	in
	assignEin(y, rator, xs)
	end
	(****MV.toDim returns int, and DstTy.TensorTy returns intlist *)
	(*DK- SK-shape,NK-dim *)
83
84	(* shape is an int list, DIM is in int|variable, k-level of differntiation *)	(* shape is an int list, DIM is in int|variable, k-level of differntiation *)
85
#	Line 133	Line 106
106	(BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),	(BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),
107	(BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),	(BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),
108	(BV.add_ii,             simpleOp Op.IAdd),	(BV.add_ii,             simpleOp Op.IAdd),
109	(BV.add_tt,             tensorEinOp EinOp.addTensor),	(BV.add_tt,             fn (y, [shp], xs) => let
110	(BV.add_ff,             fn (y, [_,NK,SK], xs) => singleField(SK,EinOp.addField, [NK,NK], y, xs)),	val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
111	(BV.add_fr,             fn (y, [_,NK], xs) => scalarField(EinOp.addTenField,[NK],y, xs)),	val rator =mk.addTT(dd1)
112	(BV.add_rf,             fn (y, [_,NK], [s, f]) => scalarField(EinOp.addTenField,[NK],y,[f,s])),	in
113		[assignEin(y, rator,xs)]
114		end),
115		(BV.add_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
116		[assignEin(y, mk.addFF(d, dd),xs)]),
117
118		(BV.add_ft,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f,s]) =>
119		[assignEin(y, mk.addTF(d,dd),[s,f])]),
120
121		(BV.add_tf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
122		[assignEin(y, mk.addTF(d,dd),xs)]),
123	(BV.sub_ii,             simpleOp Op.ISub),	(BV.sub_ii,             simpleOp Op.ISub),
124	(BV.sub_tt,             tensorEinOp EinOp.subTensor),	(BV.sub_tt,             fn (y, [shp], xs) => let
125	(BV.sub_ff,             fn (y, [_,NK,SK], xs) => singleField(SK,EinOp.subField, [NK,NK],y,xs)),	val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
126	(BV.sub_fr,             fn (y, [_,NK], xs) => scalarField(EinOp.subField,[NK], y,xs)),	val rator =mk.subTT dd1
127	(BV.sub_rf,             fn (y, [_,NK], [s, f]) => scalarField(EinOp.subField,[NK], y,[f, s])),	in
128	(* CHANGE create negative subtraction*)	[assignEin(y, rator,xs)]
129		end),
130		(BV.sub_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
131		[assignEin(y, mk.subFF(d, dd),xs)]),
132		(BV.sub_ft,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [x1,x2]) =>
133		[assignEin(y, mk.subFT(d,dd),[x2,x1])]),
134		(BV.sub_tf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
135		[assignEin(y, mk.subTF(d,dd),xs)]),
136	(BV.mul_ii,             simpleOp Op.IMul),	(BV.mul_ii,             simpleOp Op.IMul),
137	(BV.mul_rr,             fn (y,_,args) => assignEin(y, EinOp.prodScalar,args)),	(BV.mul_rr,             fn (y,_,args) => [assignEin(y, mk.mulRR,args)]),
138	(BV.mul_rt,             tensorEinOp EinOp.scaleTensor),	(BV.mul_rt,             fn (y, [shp], xs) => let
139		val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
140		val rator =mk.mulRT(dd1)
141		in
142		[assignEin(y, rator,xs)]
143		end),
144	(BV.mul_tr,             fn (y, [shp], [t, r]) => let	(BV.mul_tr,             fn (y, [shp], [t, r]) => let
145	val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp	val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
146	val rator = S.transform(EinOp.scaleTensor, [dd1], [])	val rator = mk.mulRT dd1
147	in	in
148	assignEin(y, rator,[r,t])	[assignEin(y, rator,[r,t])]
149	end),	end),
150	(BV.mul_rf,             fn (y, [_,NK,SK], xs) => singleField(SK,EinOp.scaleField,[NK],y, xs)),	(BV.mul_rf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
151	(BV.mul_fr,             fn (y, [_,NK,SK], [f, s]) => singleField(SK,EinOp.scaleField, [NK],y,[s,f])),	[assignEin(y, mk.mulRF(d, dd),xs)]),
152		(BV.mul_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f, s]) =>
153		[assignEin(y, mk.mulRF(d, dd),[s,f])]),
154		(BV.mul_ss,             fn (y, [_,Ty.DIM d], xs) =>
155		[assignEin(y, mk.mulSS d,xs)]),
156		(BV.mul_sf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
157		[assignEin(y, mk.mulSF(d,dd),xs)]),
158		(BV.mul_fs,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [s,f]) =>
159		[assignEin(y, mk.mulSF(d,dd),[f,s])]),
160	(BV.div_ii,             simpleOp Op.IDiv),	(BV.div_ii,             simpleOp Op.IDiv),
161	(BV.div_rr,             fn (y,_,args) => assignEin(y, EinOp.divScalar,args)),	(BV.div_rr,             fn (y,_,args) => [assignEin(y, mk.divRR,args)]),
162	(BV.div_tr,             tensorEinOp EinOp.divideTensor),	(BV.div_tr,             fn (y, [shp], xs) => let
163	(BV.div_fr,             fn (y, [_,NK,SK], xs) => singleField(SK,EinOp.divideField, [NK],y, xs)),	val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
164		val rator =mk.divTR dd1
165		in
166		[assignEin(y, rator,xs)]
167		end),
168		(BV.div_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
169		[assignEin(y, mk.divFR(d, dd),xs)]),
170		(BV.div_fs,             fn (y, [_,_,Ty.DIM d, Ty.SHAPE dd], xs) =>
171		[assignEin(y, mk.divFS(d, dd),xs)]),
172		(BV.div_ss,             fn (y, [_,Ty.DIM d], xs) =>
173		[assignEin(y, mk.divSS d,xs)]),
174	(BV.exp_ri,             simpleOp(Op.Power)),	(BV.exp_ri,             simpleOp(Op.Power)),
175	(BV.exp_rr,             basisFn MathFuns.pow),	(BV.exp_rr,             basisFn MathFuns.pow),
176	(BV.curl2D,             simpleEinOp EinOp.Curl2d),	(BV.curl2D,              simpleEOp mk.curl2d),
177	(BV.curl3D,             simpleEinOp EinOp.Curl3d),	(BV.curl3D,              simpleEOp mk.curl3d),
178	(BV.convolve_vk,        fn (y, [_, NK, SK], xs) => singleField(SK,EinOp.conv, [NK],y,xs)),	(BV.convolve_vk,        fn (y, [_, Ty.DIM d,  Ty.SHAPE dd], xs) =>
179	(BV.convolve_kv,        fn (y, [_, NK, SK], [k, v]) => singleField(SK,EinOp.conv, [NK],y,[v,k])),	[assignEin(y, mk.conv(d, dd),xs)]),
180		(BV.convolve_kv,        fn (y, [_, Ty.DIM d,  Ty.SHAPE dd], [k, v]) =>
181		[assignEin(y, mk.conv(d, dd),[v,k])]),
182	(BV.neg_i,              simpleOp Op.INeg),	(BV.neg_i,              simpleOp Op.INeg),
183	(BV.neg_t,              tensorEinOp EinOp.negTensor),	(BV.neg_t,              fn (y, [shp], xs) => let
184	(BV.neg_f,              fn (y, [_,NK,SK], xs) => singleField(SK,EinOp.negField, [NK],y,xs)),	val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
185	(BV.op_probe,           fn (y, [_, NK, SK], xs) => let	val rator =mk.negTT dd1
186	val dv=dimVarToTensor NK  (*Field*)	in
187	val sv=shapeVarToTensor SK (*Position*)	[assignEin(y, rator,xs)]
188	val dv'=peelFieldSK dv	end),
189	val sv'=peelFieldSK sv	(BV.neg_f,              fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
190	val einop= S.transform(EinOp.probe,[sv',dv'],[2])	[assignEin(y, mk.negFF(d, dd),xs)]),
191	in	(BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
192	assignEin(y, einop,xs)	[assignEin(y, (mk.probe(dd,d)),xs)]),
193	end),	(BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>  (case d
194	(BV.op_D,               fn (y, [_, NK], xs) => scalarField(EinOp.Grad,[NK], y,xs)),	of 2=>[assignEin(y, mk.grad([d]),xs)]
195	(BV.op_Dotimes,         fn (y, [_, NK, SK, NK2], xs) => singleField(SK,EinOp.Divergence,[NK], y,xs)),	|  3=>[assignEin(y, mk.grad([d]),xs)]
196	(BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv	| _ => raise Fail "unsupported gradient"
197		(*end case*))),
198		(BV.op_Dotimes,         fn (y, [_, Ty.DIM d1, Ty.SHAPE dd, Ty.DIM d2], xs) =>
199		[assignEin(y, mk.dotimes(d1, dd@[d2]),xs)]),
200		(BV.op_Ddot,         fn (y, [_, Ty.DIM d1,  Ty.SHAPE dd, Ty.DIM d2], xs) =>
201		[assignEin(y, mk.divergence(d1, dd),xs)] ),
202		(BV.op_norm_tt,            fn (y, [sv], xs) => let
203		val ty=shapeVarToTensor sv
204		in (case shapeVarToTensor sv
205	of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)	of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)
206	| ty => assign(y, Op.Norm ty, xs)	| DstTy.TensorTy [_]    => assign(y, Op.Norm ty, xs)
207		| DstTy.TensorTy[_,_]   => assign(y, Op.Norm ty, xs)
208		| DstTy.TensorTy[_,_,_] => assign(y, Op.Norm ty, xs)
209		| _ => raise Fail"unsupported norm of TensorTy"
210		(* end case *))
211		end),
212		(BV.op_norm_ff,            fn (y, [ _,Ty.DIM d1, Ty.SHAPE dd], xs) => (case dd
213		of []  =>  [assignEin(y, mk.magnitudeFF(d1, dd),xs)]
214		| [i]  =>  [assignEin(y, mk.magnitudeFF(d1, dd),xs@xs)]
215		| _ => raise Fail"unsupported norm of fieldTy"
216	(* end case *))),	(* end case *))),
217	(BV.op_not,             simpleOp Op.Not),	(BV.op_not,             simpleOp Op.Not),
218	(BV.op_cross,           simpleEinOp EinOp.crossProduct),	(BV.op_cross3_tt,           simpleEOp mk.cross3TT),
219	(BV.op_outer,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>	(BV.op_cross2_tt,          simpleEOp mk.cross2TT),
220	(* CHECK: should it be [[d1], [d2]]? *)	(BV.op_cross2_ff,       simpleEOp mk.cross2FF),
221	assignEin(y, S.transform(EinOp.outerProduct, [[d1, d2]], []), xs)),	(BV.op_cross3_ff,       simpleEOp mk.cross3FF),
222	(BV.op_inner,           fn (y, [sh1, sh2, _], xs) => let	(BV.op_outer_tt,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
223		[assignEin(y, (mk.outerTT(d1, d2)), xs)]),
224		(BV.op_outer_ff,      fn (y, [_, Ty.DIM d1], xs)=>
225		[assignEin(y, mk.outerFF d1,   xs)]),
226		(BV.op_inner_tt,           fn (y, [sh1, sh2, _], xs) => let
227	val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1	val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
228	val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2	val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
	val alpha= List.take(dd1, length(dd1)-1)
	val beta=  tl(dd2)
	val i =hd(dd2)
	val ilist=  [alpha, beta, [i]]
229	in	in
230	assignEin(y, S.transform(EinOp.innerProduct, ilist,[]),xs)	[assignEin(y, (mk.innerTT(dd1,dd2)),xs)]
231	end),	end),
232	(BV.op_colon,           fn (y, [sh1, sh2, _], xs) => let
233		(BV.op_inner_ff,      fn (y,  [_,_,Ty.SHAPE dd1,Ty.DIM d,Ty.SHAPE dd2,_], xs) =>
234		[assignEin(y, mk.innerFF(dd1,d,dd2),xs)]),
235
236		(BV.op_inner_ft,      fn (y,  [_,Ty.DIM d,Ty.SHAPE dd1,_,_], xs) =>
237		[assignEin(y, mk.cross3FF,xs)]),
238
239		(BV.op_colon_tt,           fn (y, [sh1, sh2, _], xs) => let
240	val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1	val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
241	val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2	val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
	val i::j::beta = dd2
	val alpha = List.take(dd1, length(dd1)-2)
	val ilist = [alpha, beta, [i], [j]]
242	in	in
243	assignEin(y, S.transform(EinOp.doubleDot, ilist,[]),xs)	[assignEin(y, (mk.colonTT(dd1,dd2)),xs)]
244	end),	end),
245		(BV.op_colon_ff,       fn (y, [_,Ty.SHAPE dd1,_,Ty.SHAPE dd2, _], xs) =>
246		[assignEin(y, (mk.colonFF(dd1,dd2)),xs)]),
247	(BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) => assign(y, Op.Inside d, xs)),	(BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) => assign(y, Op.Inside d, xs)),
248	(BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),	(BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
249	(BV.clamp_vvv,          vectorOp Op.Clamp),	(BV.clamp_vvv,          vectorOp Op.Clamp),
250	(BV.lerp3,              tensorOp Op.Lerp),	(BV.lerp3,              tensorOp Op.Lerp),
251	(BV.lerp5,              fn (y, [sv], [a, b, x0, x, x1]) => let	(BV.lerp5,              fn (y, [sv], [a, b, x0, x, x1]) => let
	(*assignEin(y, EinOp.subScalar,[x,x0])),*)
252	val t1 = IL.Var.new("t1", DstTy.realTy)	val t1 = IL.Var.new("t1", DstTy.realTy)
253	val t2 = IL.Var.new("t2", DstTy.realTy)	val t2 = IL.Var.new("t2", DstTy.realTy)
254	val t3 = IL.Var.new("t3", DstTy.realTy)	val t3 = IL.Var.new("t3", DstTy.realTy)
255	in [	in [
256	assignEin2(t1, EinOp.subScalar,[x,x0]),	assignEin(t1, mk.subRR,[x,x0]),
257	assignEin2(t2, EinOp.subScalar,[x1,x0]),	assignEin(t2, mk.subRR,[x1,x0]),
258	assignEin2(t3, EinOp.divScalar,[t1,t2]),	assignEin(t3, mk.divRR,[t1,t2]),
259	IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))	IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))
260	] end),	] end),
261	(BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),	(BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),
262	(BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),	(BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),
263	(BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),	(BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),
264	(BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),	(BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),
265
266
267	(BV.fn_max,             simpleOp Op.Max),	(BV.fn_max,             simpleOp Op.Max),
268	(BV.fn_min,             simpleOp Op.Min),	(BV.fn_min,             simpleOp Op.Min),
269	(* FIXME: modulate is vector * vector pointwise multiplication *)
270	(BV.fn_modulate,        fn (y, _, xs) => assign (y, Op.IMul, xs)),	(*  modulate is vector * vector pointwise multiplication *)
271	(BV.fn_normalize,       vectorOp Op.Normalize),	(BV.fn_modulate,        fn (y,[Ty.DIM dd1], xs) =>
272		[assignEin(y, (mk.modulate dd1),xs)]),
273		(BV.fn_normalize_tt,   vectorOp Op.Normalize),
274		(BV.fn_normalize_ff,             fn (y, [ _,Ty.DIM d1, Ty.SHAPE dd], xs) =>
275		(case dd
276		of [] => [assignEin(y, mk.normalizeFF(d1, []),xs)]
277		| [i] => [assignEin(y, mk.normalizeFF(d1, [i]),xs@xs)]
278		| _ => raise Fail"unsupported normalized of fieldTy"
279		(* end case *))),
280	(BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),	(BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
281	(BV.fn_trace,           fn (y, [Ty.DIM d], xs) =>	(BV.fn_trace_t,           fn (y, [Ty.DIM d], xs) =>
282	assignEin(y,S.transform(EinOp.trace, [[d]],[]), xs)),	[assignEin(y,(mk.traceT d), xs)]),
283	(BV.fn_transpose,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>	(BV.fn_trace_f,           fn (y, [_,Ty.DIM d,Ty.SHAPE dd], xs) =>
284	assignEin(y, S.transform(EinOp.transpose, [[d1],[d2]],[]), xs)),	[assignEin(y,mk.traceF(d,dd), xs)]),
285		(BV.fn_transpose_t,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
286		[assignEin(y, (mk.transposeT [d1,d2]), xs)]),
287		(BV.fn_transpose_f,  fn (y, [_,Ty.DIM d1, Ty.DIM d2,Ty.DIM d3], xs) =>
288		[assignEin(y, (mk.transposeF (d1,d2,d3)), xs)]),
289	(BV.kn_bspln3,          kernel Kernel.bspln3),	(BV.kn_bspln3,          kernel Kernel.bspln3),
290	(BV.kn_bspln5,          kernel Kernel.bspln5),	(BV.kn_bspln5,          kernel Kernel.bspln5),
291	(BV.kn_ctmr,            kernel Kernel.ctmr),	(BV.kn_ctmr,            kernel Kernel.ctmr),
#	Line 244	Line 295
295	(BV.kn_c1tent,          kernel Kernel.tent),	(BV.kn_c1tent,          kernel Kernel.tent),
296	(BV.i2r,                simpleOp Op.IntToReal),	(BV.i2r,                simpleOp Op.IntToReal),
297	(BV.identity,           fn (y, [Ty.DIM d], xs) =>	(BV.identity,           fn (y, [Ty.DIM d], xs) =>
298	assignEin(y, S.transform(EinOp.identity, [[d],[d]],[]), xs)),	[assignEin(y, (mk.identity d), xs)]),
299	(*   (BV.zero,               fn (y, [sv], []) =>	(BV.zero,               fn (y, [sv], []) =>
300	assign(y, Op.Zero(shapeVarToTensor sv), [])),*)	assign(y, Op.Zero(shapeVarToTensor sv), [])),
301	(BV.subscript,          fn (y, [ty, Ty.DIM d], xs) =>	(BV.subscript,          fn (y, [ty, Ty.DIM d], xs) =>
302	assign (y, Op.SeqSub(DstTy.SeqTy(trType ty, d)), xs))	assign (y, Op.SeqSub(DstTy.SeqTy(trType ty, d)), xs))
303	(*,	(*,

---

Colored Diff Long Colored Diff Unidiff Context Diff Side by Side

Legend: Removed from v.2492   changed lines   Added in v.2922

---

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