1 | LIB "tst.lib"; |
---|
2 | tst_init(); |
---|
3 | LIB "polybori.lib"; |
---|
4 | |
---|
5 | /////////////////////////////////////////////////////////////////////////////// |
---|
6 | |
---|
7 | //////////////// test for boolean_poly(poly,ring) and recursive_boolean_poly(poly,ring) |
---|
8 | |
---|
9 | "!!! Test: boolean_poly, recursive_boolean_poly !!!"; |
---|
10 | |
---|
11 | ring r=2,x(1..4),lp; |
---|
12 | def br0=boolean_poly_ring(r); |
---|
13 | poly f=x(1)^2+2*x(2)*(x(3))-x(4)^3; |
---|
14 | "Singular Poly in char=2, x(1..4):"; |
---|
15 | f; |
---|
16 | |
---|
17 | "Boolean Poly:"; |
---|
18 | boolean_poly(f,br0); |
---|
19 | |
---|
20 | "Recursive Boolean Poly:"; |
---|
21 | recursive_boolean_poly(f,br0); |
---|
22 | kill r; |
---|
23 | // -------------------------------------------------- |
---|
24 | |
---|
25 | ring r=0,x(1..7),Dp; |
---|
26 | def br1=boolean_poly_ring(r); |
---|
27 | poly f=x(4)^3+2*x(7)+23*x(2)^2*x(6)^3-1; |
---|
28 | "Singular Poly in char=0, x(1..7):"; |
---|
29 | f; |
---|
30 | |
---|
31 | "Boolean Poly:"; |
---|
32 | boolean_poly(f,br1); |
---|
33 | |
---|
34 | "Recursive Boolean Poly:"; |
---|
35 | recursive_boolean_poly(f,br1); |
---|
36 | kill r; |
---|
37 | |
---|
38 | // ------------------------------------------------- |
---|
39 | ring r=0,(w,x,y,z),Dp; |
---|
40 | def br2=boolean_poly_ring(r); |
---|
41 | poly f=xyz+20*x^2*y-3*xz+15*w-58699; |
---|
42 | "Singular Poly in char=0,(w,x,y,z) :"; |
---|
43 | f; |
---|
44 | |
---|
45 | "Boolean Poly:"; |
---|
46 | boolean_poly(f,br2); |
---|
47 | |
---|
48 | "Recursive Boolean Poly:"; |
---|
49 | recursive_boolean_poly(f,br2); |
---|
50 | kill r; |
---|
51 | // -------------------------------------------------- |
---|
52 | |
---|
53 | |
---|
54 | //////////////// test for from_boolean_poly(pyobject) and recursive_from_boolean_poly(pyobject) |
---|
55 | "!!! Test: from_boolean_poly, recursive_from_boolean_poly !!!"; |
---|
56 | |
---|
57 | python_run("ring = Ring(3)"); |
---|
58 | pyobject pp01 = python_eval("ring.variable(0)+ring.variable(1)"); |
---|
59 | "Boolean poly:"; |
---|
60 | pp01; |
---|
61 | |
---|
62 | ring r=0,(x,y,z),Dp; |
---|
63 | "Singular poly in char=0, (x,y,z):"; |
---|
64 | from_boolean_poly(pp01); |
---|
65 | |
---|
66 | "Recursive Singular Poly in char=0,(x,y,z) :"; |
---|
67 | recursive_from_boolean_poly(pp01); |
---|
68 | kill r; |
---|
69 | |
---|
70 | // -------------------------------------------------- |
---|
71 | python_run("ring1 = Ring(5)"); |
---|
72 | pyobject pp = python_eval("ring1.variable(0)*ring1.variable(3)+(ring1.variable(1)+ring1.variable(2)*ring1.variable(4))*ring1.variable(0)"); |
---|
73 | "Boolean poly:"; |
---|
74 | pp; |
---|
75 | |
---|
76 | ring r=5,(v,w,x,y,z),Dp; |
---|
77 | "Singular poly in char=5, (v,w,x,y,z):"; |
---|
78 | from_boolean_poly(pp); |
---|
79 | |
---|
80 | "Recursive Singular Poly in char=5, (v,w,x,y,z):"; |
---|
81 | recursive_from_boolean_poly(pp); |
---|
82 | kill r; |
---|
83 | |
---|
84 | // -------------------------------------------------- |
---|
85 | |
---|
86 | //////////////// test for poly2zdd(poly) and zdd2poly(zdd) |
---|
87 | "!!! Test: poly2zdd, zdd2poly !!!"; |
---|
88 | |
---|
89 | ring r=0,x,Dp; |
---|
90 | poly f=0; |
---|
91 | "Singular Poly:"; |
---|
92 | f; |
---|
93 | |
---|
94 | "poly2zdd:"; |
---|
95 | poly2zdd(f); |
---|
96 | |
---|
97 | "zdd2poly:"; |
---|
98 | zdd2poly(poly2zdd(f)); |
---|
99 | kill r; |
---|
100 | |
---|
101 | // -------------------------------------------------- |
---|
102 | ring r=0,x,Dp; |
---|
103 | poly f=1; |
---|
104 | "Singular Poly:"; |
---|
105 | f; |
---|
106 | |
---|
107 | "poly2zdd:"; |
---|
108 | poly2zdd(f); |
---|
109 | |
---|
110 | "zdd2poly:"; |
---|
111 | zdd2poly(poly2zdd(f)); |
---|
112 | kill r; |
---|
113 | |
---|
114 | // -------------------------------------------------- |
---|
115 | ring r=0,(v,w,x,y,z),Dp; |
---|
116 | poly f=(v+1)*(w+1)*(x+1)*y*z; |
---|
117 | "Singular Poly in char=0,(v,w,x,y,z):"; |
---|
118 | f; |
---|
119 | " "; |
---|
120 | "poly2zdd:"; |
---|
121 | poly2zdd(f); |
---|
122 | " "; |
---|
123 | "zdd2poly:"; |
---|
124 | zdd2poly(poly2zdd(f)); |
---|
125 | kill r; |
---|
126 | |
---|
127 | // -------------------------------------------------- |
---|
128 | ring r=0, x(1..5),Dp; |
---|
129 | poly g=x(3); |
---|
130 | "Singular Poly in char=0, x(1..5):"; |
---|
131 | g; |
---|
132 | |
---|
133 | "poly2zdd:"; |
---|
134 | poly2zdd(g); |
---|
135 | |
---|
136 | "zdd2poly:"; |
---|
137 | zdd2poly(poly2zdd(g)); |
---|
138 | |
---|
139 | kill r; |
---|
140 | // -------------------------------------------------- |
---|
141 | // -------------------------------------------------- |
---|
142 | |
---|
143 | |
---|
144 | //////////////// test for boolean_ideal(ideal,pyobject) |
---|
145 | "!!! Test: boolean_ideal !!!"; |
---|
146 | |
---|
147 | ring r=0,(x,y,z),Dp; |
---|
148 | def br10=boolean_poly_ring(r); |
---|
149 | poly f1=x3*y+2*x*z+2z-1; |
---|
150 | poly f2=x10*y^2*z^15-x5*z^2+2x*y; |
---|
151 | poly f3=19; |
---|
152 | ideal I2=f1,f2,f3; |
---|
153 | "Singular ideal in char=0,(x,y,z):"; |
---|
154 | I2; |
---|
155 | |
---|
156 | "Boolean ideal:"; |
---|
157 | boolean_ideal(I2,br10); |
---|
158 | kill r; |
---|
159 | |
---|
160 | // -------------------------------------------------- |
---|
161 | |
---|
162 | ring r=2,(x,y,z),Dp; |
---|
163 | def br200=boolean_poly_ring(r); |
---|
164 | poly f1=xyz+20*x^2*y-3*xz+15; |
---|
165 | poly f2=32001*xy+z2; |
---|
166 | poly f3=19; |
---|
167 | ideal I3=f1,f2,f3; |
---|
168 | "Singular ideal in char=2,(x,y,z):"; |
---|
169 | I3; |
---|
170 | |
---|
171 | "Boolean ideal:"; |
---|
172 | boolean_ideal(I3,br200); |
---|
173 | kill r; |
---|
174 | |
---|
175 | // -------------------------------------------------- |
---|
176 | |
---|
177 | |
---|
178 | //////////////// test for from_boolean_ideal(pyobject) |
---|
179 | "!!! Test: from_boolean_ideal !!!"; |
---|
180 | |
---|
181 | ring rs=0,(x,y,z),Dp; |
---|
182 | python_run("ring2 = Ring(3)"); |
---|
183 | pyobject pp5 = python_eval("ring2.variable(0)+ring2.variable(2)"); |
---|
184 | pyobject p5 = python_eval("ring2.variable(0)+ring2.variable(1)"); |
---|
185 | list I4=(p5,pp5); |
---|
186 | "Boolean ideal:"; |
---|
187 | I4; |
---|
188 | |
---|
189 | "Singular ideal in char=0,(x,y,z):"; |
---|
190 | from_boolean_ideal(I4); |
---|
191 | kill rs; |
---|
192 | // -------------------------------------------------- |
---|
193 | |
---|
194 | ring rs=5,(v,w,x,y,z),Dp; |
---|
195 | python_run("ring7 = Ring(5)"); |
---|
196 | pyobject p1 = python_eval("ring7.variable(0)*ring7.variable(3)+ring7.variable(1)+ring7.variable(2)*ring7.variable(4)"); |
---|
197 | pyobject pp1 = python_eval("ring7.variable(4)+ring7.variable(1)*ring7.variable(0)+ring7.variable(0)"); |
---|
198 | pyobject ppp1 = python_eval("ring7.variable(2)+ring7.variable(3)"); |
---|
199 | list I5=(p1,pp1,ppp1); |
---|
200 | "Boolean ideal:"; |
---|
201 | I5; |
---|
202 | |
---|
203 | "Singular ideal in char=5,(v,w,x,y,z):"; |
---|
204 | from_boolean_ideal(I5); |
---|
205 | kill rs; |
---|
206 | |
---|
207 | // -------------------------------------------------- |
---|
208 | // -------------------------------------------------- |
---|
209 | |
---|
210 | |
---|
211 | //////////////// test for boolean_std(ideal) |
---|
212 | "!!! Test: boolean_std !!!"; |
---|
213 | " "; |
---|
214 | ring r=2,x(1..4),lp; |
---|
215 | poly f1=x(1)^2+2*x(2)*(x(3))-x(4)^3; |
---|
216 | poly f2=x(1)^2-x(3)*x(1); |
---|
217 | poly f3=x(2)+5-2*x(1); |
---|
218 | poly f4=x(1)*x(2)-x(3); |
---|
219 | ideal I6=f1,f2,f3,f4; |
---|
220 | "Singular ideal:"; |
---|
221 | I6; |
---|
222 | |
---|
223 | "Boolean_std:"; |
---|
224 | boolean_std(I6); |
---|
225 | kill r; |
---|
226 | // -------------------------------------------------- |
---|
227 | |
---|
228 | ring r=0,x,Dp; |
---|
229 | poly f1=x3+2*x+1; |
---|
230 | poly f2=x10-x5+2x; |
---|
231 | poly f3=19; |
---|
232 | ideal I7=f1,f2,f3; |
---|
233 | "Singular ideal:"; |
---|
234 | I7; |
---|
235 | |
---|
236 | "Boolean_std:"; |
---|
237 | boolean_std(I7); |
---|
238 | kill r; |
---|
239 | |
---|
240 | // -------------------------------------------------- |
---|
241 | |
---|
242 | ring r=32003,(x,y,z),Dp; |
---|
243 | poly f1=xz+y+20*x^2*y; |
---|
244 | poly f2=32002*xy+xz2+y; |
---|
245 | ideal I8=f1,f2; |
---|
246 | "Singular ideal:"; |
---|
247 | I8; |
---|
248 | |
---|
249 | "Boolean_std:"; |
---|
250 | boolean_std(I8); |
---|
251 | kill r; |
---|
252 | |
---|
253 | // -------------------------------------------------- |
---|
254 | // -------------------------------------------------- |
---|
255 | //////////////// test for boolean_set(zdd,pyobject) and from_boolean_set(pyobject, def) |
---|
256 | "!!! Test: boolean_set, from_boolean_set !!!"; |
---|
257 | |
---|
258 | ring r=17,(x,y,z),Dp; |
---|
259 | poly f=25015x7+13689x3y4+21482x6z+18377x5z2+21142x4yz2+29755xy4z2+6632y4z3+644x3z4+15302x2yz4; |
---|
260 | def rb=boolean_poly_ring(r); |
---|
261 | def fb=boolean_poly(f,rb); |
---|
262 | "Boolean Polynomial:"; |
---|
263 | fb; |
---|
264 | |
---|
265 | def fs=fb.set(); |
---|
266 | zdd fz=from_boolean_set(fs,rb); |
---|
267 | "from_boolean_set visualized:"; |
---|
268 | disp_zdd(fz); |
---|
269 | |
---|
270 | |
---|
271 | "boolean_set:"; |
---|
272 | boolean_set(fz,rb); |
---|
273 | kill r; |
---|
274 | // -------------------------------------------------- |
---|
275 | |
---|
276 | ring r=2,x(1..6),Dp; |
---|
277 | def rb6=boolean_poly_ring(r); |
---|
278 | poly h=x(3)^3+x(2)^2*x(4)+x(3)^2*x(5)+x(1)*x(2)*x(6)+x(3)*x(4)*x(6)+x(4)^2*x(6)+x(5)^2*x(6)+x(2)*x(6)^2; |
---|
279 | def hb=boolean_poly(h,rb6); |
---|
280 | "Boolean Polynomial:"; |
---|
281 | hb; |
---|
282 | |
---|
283 | def hs=hb.set(); |
---|
284 | zdd hz=from_boolean_set(hs,rb6); |
---|
285 | "from_boolean_set visualized:"; |
---|
286 | disp_zdd(hz); |
---|
287 | |
---|
288 | "boolean_set:"; |
---|
289 | boolean_set(hz,rb6); |
---|
290 | kill r; |
---|
291 | // -------------------------------------------------- |
---|
292 | |
---|
293 | ring r=0,(a,b,c,d,e),Dp; |
---|
294 | def rb9=boolean_poly_ring(r); |
---|
295 | poly j=(a+1)*(b+1)*(c+1)*(d+1)*(e+1); |
---|
296 | def jb=boolean_poly(j,rb9); |
---|
297 | "Boolean Polynomial:"; |
---|
298 | jb; |
---|
299 | |
---|
300 | def js=jb.set(); |
---|
301 | zdd jz=from_boolean_set(js,rb9); |
---|
302 | "from_boolean_set visualized:"; |
---|
303 | disp_zdd(jz); |
---|
304 | |
---|
305 | "boolean_set:"; |
---|
306 | boolean_set(jz,rb9); |
---|
307 | kill r; |
---|
308 | // -------------------------------------------------- |
---|
309 | // -------------------------------------------------- |
---|
310 | |
---|
311 | |
---|
312 | //////////////// test for Typecasts |
---|
313 | "!!! Test: Typecasts !!!"; |
---|
314 | |
---|
315 | ring r=0,x(1..5),Dp; |
---|
316 | poly f=(x(1)-1)*(x(2)*x(3)-x(4))+x(5); |
---|
317 | "Poly f in Singular:"; |
---|
318 | f; |
---|
319 | |
---|
320 | bpoly lb=f; |
---|
321 | "bpoly lb=f;"; |
---|
322 | lb; |
---|
323 | |
---|
324 | poly ftest=poly(lb); |
---|
325 | "poly ftest=poly(lb);"; |
---|
326 | ftest; |
---|
327 | |
---|
328 | pyobject g=lb; |
---|
329 | "pyobject g=lb;"; |
---|
330 | g; |
---|
331 | |
---|
332 | bpoly lbtest=g; |
---|
333 | "bpoly lbtest=g;"; |
---|
334 | lbtest; |
---|
335 | |
---|
336 | zdd s=f; |
---|
337 | "zdd s=f;"; |
---|
338 | s; |
---|
339 | |
---|
340 | poly sbtest=poly(s); |
---|
341 | "poly sbtest=poly(s);"; |
---|
342 | sbtest; |
---|
343 | |
---|
344 | pyobject sb=s; |
---|
345 | "pyobject sb=s;"; |
---|
346 | sb; |
---|
347 | |
---|
348 | zdd stest=sb; |
---|
349 | "zdd stest=sb;"; |
---|
350 | stest; |
---|
351 | |
---|
352 | poly f2=f^2; |
---|
353 | ideal I=f,f2; |
---|
354 | "Ideal I in Singular:"; |
---|
355 | I; |
---|
356 | |
---|
357 | bideal Ib=I; |
---|
358 | "bideal Ib=I;"; |
---|
359 | Ib; |
---|
360 | |
---|
361 | ideal Itest=ideal(Ib); |
---|
362 | Itest; |
---|
363 | |
---|
364 | pyobject J=Ib; |
---|
365 | J; |
---|
366 | |
---|
367 | bideal Ibtest=J; |
---|
368 | Ibtest; |
---|
369 | |
---|
370 | // -------------------------------------------------- |
---|
371 | // -------------------------------------------------- |
---|
372 | |
---|
373 | // testing cached rings... |
---|
374 | ring r4=0,x(1..10),Dp; |
---|
375 | bring rb4 = r4; |
---|
376 | bpoly bp4_1 = x(1)*x(2)*x(6)*x(7)+1; |
---|
377 | bpoly bp4_2 = x(1)*x(2)*x(3)+1; |
---|
378 | lead(bp4_1) < lead(bp4_2); |
---|
379 | |
---|
380 | ring r5=0,x(1..10),(Dp(5),Dp(5)); |
---|
381 | bring rb5 = r5; |
---|
382 | bpoly bp5_1 = x(1)*x(2)*x(6)*x(7)+1; |
---|
383 | bpoly bp5_2 = x(1)*x(2)*x(3)+1; |
---|
384 | |
---|
385 | lead(bp5_1) < lead(bp5_2); |
---|
386 | |
---|
387 | ring r7=0,x(1..10),(Dp(3),Dp(3),Dp(6)); |
---|
388 | bring rb7 = r7; |
---|
389 | bpoly bp7_1 = x(1)*x(2)*x(6)*x(7)+1; |
---|
390 | bpoly bp7_2 = x(1)*x(2)*x(4)+1; |
---|
391 | |
---|
392 | lead(bp7_1) < lead(bp7_2); |
---|
393 | |
---|
394 | // Checking some more overloaded stuff |
---|
395 | ring r11=2,x,lp; |
---|
396 | bideal bI11 = ideal(x, x+1); |
---|
397 | std(bI11); |
---|
398 | |
---|
399 | bideal bI11 = list(x, x+1); |
---|
400 | |
---|
401 | bI11[1..2]; |
---|
402 | bring br11 = r11; |
---|
403 | nvars(br11); |
---|
404 | |
---|
405 | bpoly bp11 = bI11[1]; |
---|
406 | |
---|
407 | bideal(bp11); |
---|
408 | |
---|
409 | bp11 + 1; |
---|
410 | |
---|
411 | bI11 + bideal(bp11); |
---|
412 | bI11 + bp11; |
---|
413 | |
---|
414 | ring r12=2,(x,y),lp; |
---|
415 | bideal bI12_1 = ideal(x, x+1); |
---|
416 | bideal bI12_2 = ideal(y, y+1); |
---|
417 | |
---|
418 | bI12_1 + bI12_2; |
---|
419 | |
---|
420 | bI12_2 = ideal(x, y, y+1); |
---|
421 | bI12_1 + bI12_2; |
---|
422 | |
---|
423 | // -------------------------- |
---|
424 | // execute examples |
---|
425 | |
---|
426 | example bvar; |
---|
427 | example boolean_set; |
---|
428 | example from_boolean_set; |
---|
429 | example from_boolean_poly; |
---|
430 | example boolean_constant; |
---|
431 | example boolean_poly; |
---|
432 | example from_boolean_poly; |
---|
433 | example boolean_poly; |
---|
434 | example recursive_boolean_poly; |
---|
435 | example boolean_ideal; |
---|
436 | example from_boolean_ideal; |
---|
437 | example boolean_std; |
---|
438 | example from_boolean_constant; |
---|
439 | example recursive_from_boolean_poly; |
---|
440 | example poly2zdd; |
---|
441 | example poly2zdd; |
---|
442 | example disp_zdd; |
---|
443 | |
---|
444 | |
---|
445 | // Finally statistics... |
---|
446 | tst_status(1); |
---|
447 | |
---|