source: git/kernel/test.cc @ 5417ff

jengelh-datetimespielwiese
Last change on this file since 5417ff was 5417ff, checked in by Oleksandr Motsak <motsak@…>, 10 years ago
Added automake BuildSystem
  • Property mode set to 100644
File size: 12.5 KB
Line 
1#include "config.h"
2#include "mod2.h"
3
4#include <omalloc/omalloc.h>
5#include <misc/auxiliary.h>
6#ifdef HAVE_FACTORY
7#include <factory/factory.h> // :(
8#endif
9
10#include <misc/intvec.h>
11#include <misc/int64vec.h>
12#include <misc/mylimits.h>
13#include <misc/options.h>
14
15#include <reporter/reporter.h>
16
17#include <findexec/feFopen.h>
18#include <findexec/feResource.h>
19
20#include <coeffs/coeffs.h>
21
22#include <coeffs/si_gmp.h>
23
24#include <polys/kbuckets.h>
25#include <polys/matpol.h>
26#include <polys/mod_raw.h>
27#include <polys/prCopy.h>
28#include <polys/sbuckets.h>
29#include <polys/simpleideals.h>
30#include <polys/weight.h>
31
32#include <polys/monomials/maps.h>
33#include <polys/monomials/monomials.h>
34#include <polys/monomials/p_polys.h>
35#include <polys/monomials/ring.h>
36
37#include <polys/nc/nc.h>
38#include <polys/nc/ncSACache.h>
39#include <polys/nc/ncSAFormula.h>
40#include <polys/nc/ncSAMult.h>
41#include <polys/nc/sca.h>
42#include <polys/nc/summator.h>
43
44
45#include <polys/templates/p_MemAdd.h>
46#include <polys/templates/p_Procs.h>
47
48#include <polys/operations/pShallowCopyDelete.h>
49
50#include <polys/clapsing.h>
51
52
53#ifdef HAVE_FACTORY
54// The following are needed due to FACTORY (e.g. initCanonicalForm)
55int initializeGMP(){ return 1; }
56int mmInit(void) {return 1; }
57#endif
58
59// // TODO: DUE to the use of HALT in npolygon.cc :(((
60extern "C" {void m2_end(int i){exit(i);}}
61
62// // TODO: DUE to its use in kutil.cc :(((
63char * showOption(){return NULL;}
64
65// // TODO: DUE to its use in feread.cc :(((
66char *iiArithGetCmd(int nPos){return NULL; }
67
68
69#include <coeffs/numbers.h>
70
71#include "structs.h"
72
73
74// HEADERS:
75#include "hutil.h"
76//#include "idrec.h" // moved to Singular
77#include "stairc.h"
78#include "ideals.h"
79#include "syz.h"
80#include "fast_maps.h"
81#include "febase.h"
82#include "walkProc.h"
83#include "walkMain.h"
84#include "walkSupport.h"
85#include "khstd.h"
86/// #include "sparsmat.h" // TODO: install polys/this!
87//+
88
89#include "fglm.h"
90#include "kstd1.h"
91#include "fglmgauss.h"
92#include "fglmvec.h"
93#include "kstdfac.h"
94#include "kmatrix.h"
95#include "GMPrat.h"
96#include "multicnt.h"
97#include "npolygon.h"
98#include "semic.h"
99#include "spectrum.h"
100#include "splist.h"
101#include "multicnt.h"
102#include "eigenval.h"
103#include "units.h"
104#include "ratgring.h"
105#include "shiftgb.h"
106// #include "mmalloc.h" // move to Singular!?
107
108#include "kutil.h"
109
110// #include "dbm_sl.h" // TODO: needs si_link// already moved to Singular/!
111
112// #include "CCRing.h" // Too old!
113#include "digitech.h"
114#include "eigenval.h"
115#include "fast_maps.h"
116#include "fast_mult.h"
117#include "febase.h"
118
119#include "fglmgauss.h"
120#include "fglm.h"
121#include "fglmvec.h"
122
123////////#include "F5cData.h"
124#include "f5c.h"
125#include "f5data.h"
126#include "f5gb.h"
127#include "f5lists.h"
128////////#include "F5cLists.h"
129
130
131#include "GMPrat.h"
132
133// #include "htmlhelp.h" // For Windows //
134#include "hutil.h"
135// #include "Ideal.h" // Too old?
136
137
138#include "ideals.h"
139
140#include "kmatrix.h"
141#include "kstd1.h"
142#include "kstdfac.h"
143#include "khstd.h"
144
145#include "linearAlgebra.h"
146
147
148
149// #include "lplist.h" // Too old!
150#include "multicnt.h"
151#include "npolygon.h"
152// #include "Number.h" // Too old?
153// #include "Poly.h" // Too old?
154// #include "PowerSeries.h" // Too old?
155
156#include "preimage.h"
157
158#include "nc.h"
159
160#include "ratgring.h"
161#include "ringgb.h"
162// #include "run.h" // moved to Singular
163#include "semic.h"
164#include "shiftgb.h"
165// #include "si_gmp.h" // remove it...
166#include "spectrum.h"
167#include "splist.h"
168#include "stairc.h"
169#include "structs.h"
170#include "syz.h"
171// #include "testpoly.h" // Too old?
172
173#include "tgbgauss.h"
174#include "tgb.h"
175
176#include "timer.h"
177
178#include "units.h"
179#include "walkMain.h"
180#include "walkProc.h"
181#include "walkSupport.h"
182
183
184// #include <polys/clapconv.h> // due to factory? :(
185// #include "tgb_internal.h" // :(
186// #include "F4.h" // uses tgb_internal // :(
187// #include "IIntvec.h" // :(
188
189
190
191
192// #include "fglmzero.cc" // looks like <factory/templates/ftmpl_list.h> must be installed!
193// TODO: looks like <coeffs/mpr_complex.h> must be installed!
194
195
196
197#include "polys.h"
198
199void TestGBEngine()
200{
201
202  //  R = MPolynomialRing_polydict(QQ,5,'w,x,y,z,C', order='degrevlex')
203  //  J = (w*w - x*z, w*x - y*z, x*x - w*y, x*y - z*z, y*y - w*z)
204
205  const short w = 1;
206  const short x = 2;
207  const short y = 3;
208  const short z = 4;
209
210  const short N = (z - w + 1);
211
212  char **n=(char**)omalloc(N*sizeof(char*));
213
214
215  n[w-1]=omStrDup("w");
216  n[x-1]=omStrDup("x");
217  n[y-1]=omStrDup("y");
218  n[z-1]=omStrDup("z");
219
220
221  const int D = 3;
222  int *order = (int *) omAlloc0(D* sizeof(int));
223  int *block0 = (int *)omAlloc0(D * sizeof(int));
224  int *block1 = (int *)omAlloc0(D * sizeof(int));
225
226  order[0]  = ringorder_dp;
227  block0[0] = 1;
228  block1[0] = N;
229
230  order[1]  = ringorder_C;
231  block0[1] = 1;
232  block1[1] = N;
233
234  ring R = rDefault(0, N, n, D, order, block0, block1);
235
236//   ring R = rDefault(0, N, n);
237
238  rWrite(R); PrintLn();
239
240#ifdef RDEBUG
241  rDebugPrint(R);
242#endif
243
244  ideal I = idInit(5, 1);
245
246  int gen = 0;
247
248  {
249    // -xz
250    poly p = p_ISet(-1,R);
251
252    p_SetExp(p, x, 1, R);
253    p_SetExp(p, z, 1, R);
254    p_Setm(p, R);
255
256    assume( p_GetExp(p, x, R) == 1 );
257    assume( p_GetExp(p, z, R) == 1 );
258    assume( p_GetExp(p, w, R) == 0 );
259    assume( p_GetExp(p, y, R) == 0 );
260
261    // +w2
262    poly lp = p_ISet(1,R);
263    p_SetExp(lp, w, 2, R);
264    p_Setm(lp, R);
265
266    assume( p_GetExp(lp, w, R) == 2 );
267    assume( p_GetExp(lp, x, R) == 0 );
268    assume( p_GetExp(lp, y, R) == 0 );
269    assume( p_GetExp(lp, z, R) == 0 );
270
271    MATELEM(I, 1, ++gen) = p_Add_q(lp, p, R); // w2 - xz
272  }
273
274  {
275    // -yz
276    poly p = p_ISet(-1,R);
277
278    p_SetExp(p, y, 1, R);
279    p_SetExp(p, z, 1, R);
280    p_Setm(p, R);
281
282    assume( p_GetExp(p, y, R) == 1 );
283    assume( p_GetExp(p, z, R) == 1 );
284    assume( p_GetExp(p, w, R) == 0 );
285    assume( p_GetExp(p, x, R) == 0 );
286
287    // +wx
288    poly lp = p_ISet(1,R);
289    p_SetExp(lp, w, 1, R);
290    p_SetExp(lp, x, 1, R);
291    p_Setm(lp, R);
292
293    assume( p_GetExp(lp, w, R) == 1 );
294    assume( p_GetExp(lp, x, R) == 1 );
295    assume( p_GetExp(lp, y, R) == 0 );
296    assume( p_GetExp(lp, z, R) == 0 );
297
298    MATELEM(I, 1, ++gen) = p_Add_q(lp, p, R); // wx - yz
299  }
300
301
302  {
303    // -wy
304    poly p = p_ISet(-1,R);
305
306    p_SetExp(p, y, 1, R);
307    p_SetExp(p, w, 1, R);
308    p_Setm(p, R);
309
310    assume( p_GetExp(p, y, R) == 1 );
311    assume( p_GetExp(p, w, R) == 1 );
312    assume( p_GetExp(p, z, R) == 0 );
313    assume( p_GetExp(p, x, R) == 0 );
314
315    // +x2
316    poly lp = p_ISet(1,R);
317    p_SetExp(lp, x, 2, R);
318    p_Setm(lp, R);
319
320    assume( p_GetExp(lp, w, R) == 0 );
321    assume( p_GetExp(lp, x, R) == 2 );
322    assume( p_GetExp(lp, y, R) == 0 );
323    assume( p_GetExp(lp, z, R) == 0 );
324
325    MATELEM(I, 1, ++gen) = p_Add_q(lp, p, R); // x2 - wy
326  }
327
328
329  {
330    // -z2
331    poly p = p_ISet(-1,R);
332
333    p_SetExp(p, z, 2, R);
334    p_Setm(p, R);
335
336    assume( p_GetExp(p, y, R) == 0 );
337    assume( p_GetExp(p, w, R) == 0 );
338    assume( p_GetExp(p, z, R) == 2 );
339    assume( p_GetExp(p, x, R) == 0 );
340
341    // +xy
342    poly lp = p_ISet(1,R);
343    p_SetExp(lp, x, 1, R);
344    p_SetExp(lp, y, 1, R);
345    p_Setm(lp, R);
346
347    assume( p_GetExp(lp, w, R) == 0 );
348    assume( p_GetExp(lp, x, R) == 1 );
349    assume( p_GetExp(lp, y, R) == 1 );
350    assume( p_GetExp(lp, z, R) == 0 );
351
352    MATELEM(I, 1, ++gen) = p_Add_q(lp, p, R); // xy - z2
353  }
354
355
356  {
357    // -wz
358    poly p = p_ISet(-1,R);
359
360    p_SetExp(p, w, 1, R);
361    p_SetExp(p, z, 1, R);
362    p_Setm(p, R);
363
364    assume( p_GetExp(p, y, R) == 0 );
365    assume( p_GetExp(p, w, R) == 1 );
366    assume( p_GetExp(p, z, R) == 1 );
367    assume( p_GetExp(p, x, R) == 0 );
368
369    // +y2
370    poly lp = p_ISet(1,R);
371    p_SetExp(lp, y, 2, R);
372    p_Setm(lp, R);
373
374    assume( p_GetExp(lp, w, R) == 0 );
375    assume( p_GetExp(lp, x, R) == 0 );
376    assume( p_GetExp(lp, y, R) == 2 );
377    assume( p_GetExp(lp, z, R) == 0 );
378
379    MATELEM(I, 1, ++gen) = p_Add_q(lp, p, R); // y2 - wz
380  }
381#ifdef PDEBUG
382  PrintS("I: ");
383  idShow(I, R, R, 0);
384#endif
385
386
387//  ideal kStd(ideal F, ideal Q, tHomog h, intvec ** mw,intvec *hilb=NULL,
388//             int syzComp=0,int newIdeal=0, intvec *vw=NULL);
389  // make R the default ring:
390  rChangeCurrRing(R);
391
392  {
393    ideal G = kStd(I, currQuotient, testHomog, NULL);
394
395#ifdef PDEBUG
396    PrintS("GB: ");
397    idShow(G, R, R, 0);
398#endif
399
400    idDelete( &G, R);
401  }
402
403  {
404    intvec *weights = NULL;
405    ideal SYZ = idSyzygies(I, testHomog, &weights);
406
407#ifdef PDEBUG
408    PrintS("SYZ: ");
409    idShow(SYZ, R, R, 0);
410#endif
411
412    idDelete(&SYZ, R);
413    if (weights!=NULL) { PrintS("weights: "); weights->show(); delete weights; }
414  }
415
416
417  {
418    PrintS("\n**********************************\n");
419    PrintS("lres: \n");
420    int dummy;
421    syStrategy r = syLaScala3(I,&dummy);
422
423    intvec *b = syBettiOfComputation(r, FALSE);
424    PrintS("non-min. betti: \n");    b->show();    PrintLn();
425    delete b;
426
427    Print("length: %d\n", sySize(r));
428
429    syPrint(r, "R");
430
431    r =  syMinimize(r); // syzstr->references ++ ==> memory leak :(((
432
433    b = syBettiOfComputation(r, TRUE);
434    PrintS("min. betti: \n");    b->show();    PrintLn();
435    delete b;
436
437    Print("length: %d\n", sySize(r));
438
439    syPrint(r, "R");
440
441    syKillComputation(r, R);
442  }
443
444  {
445    PrintS("\n**********************************\n");
446    PrintS("sres: \n");
447    const int maxl = rVar(R)-1; // +2*(1);
448
449    syStrategy r = sySchreyer(I, rVar(R));
450
451    intvec *b = syBettiOfComputation(r, FALSE);
452    PrintS("non-min. betti: \n");    b->show();    PrintLn();
453    delete b;
454
455    Print("length: %d\n", sySize(r));
456
457    syPrint(r, "R");
458
459    r =  syMinimize(r); // syzstr->references ++ ==> memory leak :(((
460
461    b = syBettiOfComputation(r, TRUE);
462    PrintS("min. betti: \n");    b->show();    PrintLn();
463    delete b;
464
465    Print("length: %d\n", sySize(r));
466
467    syPrint(r, "R");
468
469    syKillComputation(r, R);
470  }
471
472
473
474  {
475    PrintS("\n**********************************\n");
476    PrintS("nres: \n");
477    intvec *weights=NULL;
478//    const int maxl = rVar(R)-1 + 2*(1);
479    syStrategy r = syResolution(I, rVar(R)-1, weights, FALSE/*iiOp==MRES_CMD*/);
480
481    intvec *b = syBettiOfComputation(r, FALSE);
482    PrintS("non-min. betti: \n");    b->show();    PrintLn();
483    delete b;
484
485    Print("length: %d\n", sySize(r));
486
487    syPrint(r, "R");
488
489    r =  syMinimize(r); // syzstr->references ++ ==> memory leak :(((
490
491    b = syBettiOfComputation(r, TRUE);
492    PrintS("min. betti: \n");    b->show();    PrintLn();
493    delete b;
494
495    Print("length: %d\n", sySize(r));
496
497    syPrint(r, "R");
498
499    syKillComputation(r, R);
500  }
501
502
503  {
504    PrintS("\n**********************************\n");
505    PrintS("mres: \n");
506    intvec *weights=NULL;
507//    const int maxl = rVar(R)-1 + 2*(1);
508    syStrategy r = syResolution(I, rVar(R)+1, weights, TRUE/*iiOp==MRES_CMD*/);
509
510    intvec *b = syBettiOfComputation(r, FALSE);
511    PrintS("non-min. betti: \n");    b->show();    PrintLn();
512    delete b;
513
514    Print("length: %d\n", sySize(r));
515
516    syPrint(r, "R");
517
518    r =  syMinimize(r); // syzstr->references ++ ==> memory leak :(((
519
520    b = syBettiOfComputation(r, TRUE);
521    PrintS("min. betti: \n");    b->show();    PrintLn();
522    delete b;
523
524    Print("length: %d\n", sySize(r));
525
526    syPrint(r, "R");
527
528    syKillComputation(r, R);
529  }
530
531
532
533
534  idDelete( &I, R);
535  rDelete(R); // should cleanup every belonging polynomial, right!?
536
537}
538
539
540
541void TestSimpleRingArithmetcs()
542{
543  // Libpolys tests:
544
545  // construct the ring Z/32003[x,y,z]
546  // the variable names
547  char **n=(char**)omalloc(3*sizeof(char*));
548  n[0]=omStrDup("x");
549  n[1]=omStrDup("y");
550  n[2]=omStrDup("z2");
551
552  ring R = rDefault(32003,3,n); //  ring R = rDefault(0,3,n);
553
554  rWrite(R); PrintLn();
555
556#ifdef RDEBUG
557  rDebugPrint(R);
558#endif
559
560
561  poly p = p_ISet(1,R); p_SetExp(p,1,1, R); p_Setm(p, R);
562
563  assume( p_GetExp(p,1, R) == 1 );
564
565  poly pp = pp_Mult_qq( p, p, R);
566
567  Print("p: "); p_Write0(p, R); Print(", deg(p): %d", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
568
569  Print("; p*p : "); p_Write0(pp, R); Print("deg(pp): %d\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
570
571
572  p_Delete(&p, R);
573
574  assume( p_GetExp(pp,1, R) == 2 );
575
576  p_Delete(&pp, R);
577
578
579//  rDelete(R);
580
581  // make R the default ring:
582  rChangeCurrRing(R);
583
584  // create the polynomial 1
585  poly p1=pISet(1);
586
587  // create tthe polynomial 2*x^3*z^2
588  poly p2=p_ISet(2,R);
589  pSetExp(p2,1,3);
590  pSetExp(p2,3,2);
591  pSetm(p2);
592
593  // print p1 + p2
594  Print("p1: "); pWrite0(p1);
595  Print(" + p2: "); pWrite0(p2);
596  Print("  ---- >>>> ");
597
598  // compute p1+p2
599  p1=p_Add_q(p1,p2,R); p2=NULL;
600  pWrite(p1);
601
602  // clean up:
603//  pDelete(&p1);
604
605  rDelete(R); // should cleanup every belonging polynomial, right!?
606}
607
608
609int main( int, char *argv[] )
610{
611  feInitResources(argv[0]);
612
613  StringSetS("ressources in use (as reported by feStringAppendResources(0):\n");
614  feStringAppendResources(0);
615
616  PrintLn();
617  { char* s = StringEndS(); PrintS(s); omFree(s); }
618
619  TestGBEngine();
620  TestSimpleRingArithmetcs();
621
622  return 0;
623}
Note: See TracBrowser for help on using the repository browser.