My Project  UNKNOWN_GIT_VERSION
hdegree.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT - dimension, multiplicity, HC, kbase
6 */
7 
8 #include "kernel/mod2.h"
9 
10 #include "omalloc/omalloc.h"
11 #include "misc/intvec.h"
12 #include "coeffs/numbers.h"
13 
14 #include "kernel/structs.h"
15 #include "kernel/ideals.h"
16 #include "kernel/polys.h"
17 
21 
22 int hCo, hMu, hMu2;
23 omBin indlist_bin = omGetSpecBin(sizeof(indlist));
24 
25 /*0 implementation*/
26 
27 // dimension
28 
29 void hDimSolve(scmon pure, int Npure, scfmon rad, int Nrad,
30  varset var, int Nvar)
31 {
32  int dn, iv, rad0, b, c, x;
33  scmon pn;
34  scfmon rn;
35  if (Nrad < 2)
36  {
37  dn = Npure + Nrad;
38  if (dn < hCo)
39  hCo = dn;
40  return;
41  }
42  if (Npure+1 >= hCo)
43  return;
44  iv = Nvar;
45  while(pure[var[iv]]) iv--;
46  hStepR(rad, Nrad, var, iv, &rad0);
47  if (rad0!=0)
48  {
49  iv--;
50  if (rad0 < Nrad)
51  {
52  pn = hGetpure(pure);
53  rn = hGetmem(Nrad, rad, radmem[iv]);
54  hDimSolve(pn, Npure + 1, rn, rad0, var, iv);
55  b = rad0;
56  c = Nrad;
57  hElimR(rn, &rad0, b, c, var, iv);
58  hPure(rn, b, &c, var, iv, pn, &x);
59  hLex2R(rn, rad0, b, c, var, iv, hwork);
60  rad0 += (c - b);
61  hDimSolve(pn, Npure + x, rn, rad0, var, iv);
62  }
63  else
64  {
65  hDimSolve(pure, Npure, rad, Nrad, var, iv);
66  }
67  }
68  else
69  hCo = Npure + 1;
70 }
71 
72 int scDimInt(ideal S, ideal Q)
73 {
74  id_Test(S, currRing);
75  if( Q!=NULL ) id_Test(Q, currRing);
76 
77  int mc;
78  hexist = hInit(S, Q, &hNexist, currRing);
79  if (!hNexist)
80  return (currRing->N);
81  hwork = (scfmon)omAlloc(hNexist * sizeof(scmon));
82  hvar = (varset)omAlloc(((currRing->N) + 1) * sizeof(int));
83  hpure = (scmon)omAlloc((1 + ((currRing->N) * (currRing->N))) * sizeof(int));
84  mc = hisModule;
85  if (!mc)
86  {
87  hrad = hexist;
88  hNrad = hNexist;
89  }
90  else
91  hrad = (scfmon)omAlloc(hNexist * sizeof(scmon));
92  radmem = hCreate((currRing->N) - 1);
93  hCo = (currRing->N) + 1;
94  loop
95  {
96  if (mc)
97  hComp(hexist, hNexist, mc, hrad, &hNrad);
98  if (hNrad)
99  {
100  hNvar = (currRing->N);
101  hRadical(hrad, &hNrad, hNvar);
102  hSupp(hrad, hNrad, hvar, &hNvar);
103  if (hNvar)
104  {
105  memset(hpure, 0, ((currRing->N) + 1) * sizeof(int));
106  hPure(hrad, 0, &hNrad, hvar, hNvar, hpure, &hNpure);
107  hLexR(hrad, hNrad, hvar, hNvar);
109  }
110  }
111  else
112  {
113  hCo = 0;
114  break;
115  }
116  mc--;
117  if (mc <= 0)
118  break;
119  }
120  hKill(radmem, (currRing->N) - 1);
121  omFreeSize((ADDRESS)hpure, (1 + ((currRing->N) * (currRing->N))) * sizeof(int));
122  omFreeSize((ADDRESS)hvar, ((currRing->N) + 1) * sizeof(int));
123  omFreeSize((ADDRESS)hwork, hNexist * sizeof(scmon));
125  if (hisModule)
126  omFreeSize((ADDRESS)hrad, hNexist * sizeof(scmon));
127  return (currRing->N) - hCo;
128 }
129 
130 // independent set
131 static scmon hInd;
132 
133 static void hIndSolve(scmon pure, int Npure, scfmon rad, int Nrad,
134  varset var, int Nvar)
135 {
136  int dn, iv, rad0, b, c, x;
137  scmon pn;
138  scfmon rn;
139  if (Nrad < 2)
140  {
141  dn = Npure + Nrad;
142  if (dn < hCo)
143  {
144  hCo = dn;
145  for (iv=(currRing->N); iv; iv--)
146  {
147  if (pure[iv])
148  hInd[iv] = 0;
149  else
150  hInd[iv] = 1;
151  }
152  if (Nrad)
153  {
154  pn = *rad;
155  iv = Nvar;
156  loop
157  {
158  x = var[iv];
159  if (pn[x])
160  {
161  hInd[x] = 0;
162  break;
163  }
164  iv--;
165  }
166  }
167  }
168  return;
169  }
170  if (Npure+1 >= hCo)
171  return;
172  iv = Nvar;
173  while(pure[var[iv]]) iv--;
174  hStepR(rad, Nrad, var, iv, &rad0);
175  if (rad0)
176  {
177  iv--;
178  if (rad0 < Nrad)
179  {
180  pn = hGetpure(pure);
181  rn = hGetmem(Nrad, rad, radmem[iv]);
182  pn[var[iv + 1]] = 1;
183  hIndSolve(pn, Npure + 1, rn, rad0, var, iv);
184  pn[var[iv + 1]] = 0;
185  b = rad0;
186  c = Nrad;
187  hElimR(rn, &rad0, b, c, var, iv);
188  hPure(rn, b, &c, var, iv, pn, &x);
189  hLex2R(rn, rad0, b, c, var, iv, hwork);
190  rad0 += (c - b);
191  hIndSolve(pn, Npure + x, rn, rad0, var, iv);
192  }
193  else
194  {
195  hIndSolve(pure, Npure, rad, Nrad, var, iv);
196  }
197  }
198  else
199  {
200  hCo = Npure + 1;
201  for (x=(currRing->N); x; x--)
202  {
203  if (pure[x])
204  hInd[x] = 0;
205  else
206  hInd[x] = 1;
207  }
208  hInd[var[iv]] = 0;
209  }
210 }
211 
212 intvec * scIndIntvec(ideal S, ideal Q)
213 {
214  id_Test(S, currRing);
215  if( Q!=NULL ) id_Test(Q, currRing);
216 
217  intvec *Set=new intvec((currRing->N));
218  int mc,i;
219  hexist = hInit(S, Q, &hNexist, currRing);
220  if (hNexist==0)
221  {
222  for(i=0; i<(currRing->N); i++)
223  (*Set)[i]=1;
224  return Set;
225  }
226  hwork = (scfmon)omAlloc(hNexist * sizeof(scmon));
227  hvar = (varset)omAlloc(((currRing->N) + 1) * sizeof(int));
228  hpure = (scmon)omAlloc((1 + ((currRing->N) * (currRing->N))) * sizeof(int));
229  hInd = (scmon)omAlloc0((1 + (currRing->N)) * sizeof(int));
230  mc = hisModule;
231  if (mc==0)
232  {
233  hrad = hexist;
234  hNrad = hNexist;
235  }
236  else
237  hrad = (scfmon)omAlloc(hNexist * sizeof(scmon));
238  radmem = hCreate((currRing->N) - 1);
239  hCo = (currRing->N) + 1;
240  loop
241  {
242  if (mc!=0)
243  hComp(hexist, hNexist, mc, hrad, &hNrad);
244  if (hNrad!=0)
245  {
246  hNvar = (currRing->N);
247  hRadical(hrad, &hNrad, hNvar);
248  hSupp(hrad, hNrad, hvar, &hNvar);
249  if (hNvar!=0)
250  {
251  memset(hpure, 0, ((currRing->N) + 1) * sizeof(int));
252  hPure(hrad, 0, &hNrad, hvar, hNvar, hpure, &hNpure);
253  hLexR(hrad, hNrad, hvar, hNvar);
255  }
256  }
257  else
258  {
259  hCo = 0;
260  break;
261  }
262  mc--;
263  if (mc <= 0)
264  break;
265  }
266  for(i=0; i<(currRing->N); i++)
267  (*Set)[i] = hInd[i+1];
268  hKill(radmem, (currRing->N) - 1);
269  omFreeSize((ADDRESS)hpure, (1 + ((currRing->N) * (currRing->N))) * sizeof(int));
270  omFreeSize((ADDRESS)hInd, (1 + (currRing->N)) * sizeof(int));
271  omFreeSize((ADDRESS)hvar, ((currRing->N) + 1) * sizeof(int));
272  omFreeSize((ADDRESS)hwork, hNexist * sizeof(scmon));
274  if (hisModule)
275  omFreeSize((ADDRESS)hrad, hNexist * sizeof(scmon));
276  return Set;
277 }
278 
280 
281 static BOOLEAN hNotZero(scfmon rad, int Nrad, varset var, int Nvar)
282 {
283  int k1, i;
284  k1 = var[Nvar];
285  i = 0;
286  loop
287  {
288  if (rad[i][k1]==0)
289  return FALSE;
290  i++;
291  if (i == Nrad)
292  return TRUE;
293  }
294 }
295 
296 static void hIndep(scmon pure)
297 {
298  int iv;
299  intvec *Set;
300 
301  Set = ISet->set = new intvec((currRing->N));
302  for (iv=(currRing->N); iv!=0 ; iv--)
303  {
304  if (pure[iv])
305  (*Set)[iv-1] = 0;
306  else
307  (*Set)[iv-1] = 1;
308  }
310  hMu++;
311 }
312 
313 void hIndMult(scmon pure, int Npure, scfmon rad, int Nrad,
314  varset var, int Nvar)
315 {
316  int dn, iv, rad0, b, c, x;
317  scmon pn;
318  scfmon rn;
319  if (Nrad < 2)
320  {
321  dn = Npure + Nrad;
322  if (dn == hCo)
323  {
324  if (Nrad==0)
325  hIndep(pure);
326  else
327  {
328  pn = *rad;
329  for (iv = Nvar; iv!=0; iv--)
330  {
331  x = var[iv];
332  if (pn[x])
333  {
334  pure[x] = 1;
335  hIndep(pure);
336  pure[x] = 0;
337  }
338  }
339  }
340  }
341  return;
342  }
343  iv = Nvar;
344  dn = Npure+1;
345  if (dn >= hCo)
346  {
347  if (dn > hCo)
348  return;
349  loop
350  {
351  if(!pure[var[iv]])
352  {
353  if(hNotZero(rad, Nrad, var, iv))
354  {
355  pure[var[iv]] = 1;
356  hIndep(pure);
357  pure[var[iv]] = 0;
358  }
359  }
360  iv--;
361  if (!iv)
362  return;
363  }
364  }
365  while(pure[var[iv]]) iv--;
366  hStepR(rad, Nrad, var, iv, &rad0);
367  iv--;
368  if (rad0 < Nrad)
369  {
370  pn = hGetpure(pure);
371  rn = hGetmem(Nrad, rad, radmem[iv]);
372  pn[var[iv + 1]] = 1;
373  hIndMult(pn, Npure + 1, rn, rad0, var, iv);
374  pn[var[iv + 1]] = 0;
375  b = rad0;
376  c = Nrad;
377  hElimR(rn, &rad0, b, c, var, iv);
378  hPure(rn, b, &c, var, iv, pn, &x);
379  hLex2R(rn, rad0, b, c, var, iv, hwork);
380  rad0 += (c - b);
381  hIndMult(pn, Npure + x, rn, rad0, var, iv);
382  }
383  else
384  {
385  hIndMult(pure, Npure, rad, Nrad, var, iv);
386  }
387 }
388 
389 /*3
390 * consider indset x := !pure
391 * (for all i) (if(sm(i) > x) return FALSE)
392 * else return TRUE
393 */
394 static BOOLEAN hCheck1(indset sm, scmon pure)
395 {
396  int iv;
397  intvec *Set;
398  while (sm->nx != NULL)
399  {
400  Set = sm->set;
401  iv=(currRing->N);
402  loop
403  {
404  if (((*Set)[iv-1] == 0) && (pure[iv] == 0))
405  break;
406  iv--;
407  if (iv == 0)
408  return FALSE;
409  }
410  sm = sm->nx;
411  }
412  return TRUE;
413 }
414 
415 /*3
416 * consider indset x := !pure
417 * (for all i) if(x > sm(i)) delete sm(i))
418 * return (place for x)
419 */
420 static indset hCheck2(indset sm, scmon pure)
421 {
422  int iv;
423  intvec *Set;
424  indset be, a1 = NULL;
425  while (sm->nx != NULL)
426  {
427  Set = sm->set;
428  iv=(currRing->N);
429  loop
430  {
431  if ((pure[iv] == 1) && ((*Set)[iv-1] == 1))
432  break;
433  iv--;
434  if (iv == 0)
435  {
436  if (a1 == NULL)
437  {
438  a1 = sm;
439  }
440  else
441  {
442  hMu2--;
443  be->nx = sm->nx;
444  delete Set;
446  sm = be;
447  }
448  break;
449  }
450  }
451  be = sm;
452  sm = sm->nx;
453  }
454  if (a1 != NULL)
455  {
456  return a1;
457  }
458  else
459  {
460  hMu2++;
461  sm->set = new intvec((currRing->N));
462  sm->nx = (indset)omAlloc0Bin(indlist_bin);
463  return sm;
464  }
465 }
466 
467 /*2
468 * definition x >= y
469 * x(i) == 0 => y(i) == 0
470 * > ex. j with x(j) == 1 and y(j) == 0
471 */
472 static void hCheckIndep(scmon pure)
473 {
474  intvec *Set;
475  indset res;
476  int iv;
477  if (hCheck1(ISet, pure))
478  {
479  if (hCheck1(JSet, pure))
480  {
481  res = hCheck2(JSet,pure);
482  if (res == NULL)
483  return;
484  Set = res->set;
485  for (iv=(currRing->N); iv; iv--)
486  {
487  if (pure[iv])
488  (*Set)[iv-1] = 0;
489  else
490  (*Set)[iv-1] = 1;
491  }
492  }
493  }
494 }
495 
496 void hIndAllMult(scmon pure, int Npure, scfmon rad, int Nrad,
497  varset var, int Nvar)
498 {
499  int dn, iv, rad0, b, c, x;
500  scmon pn;
501  scfmon rn;
502  if (Nrad < 2)
503  {
504  dn = Npure + Nrad;
505  if (dn > hCo)
506  {
507  if (!Nrad)
508  hCheckIndep(pure);
509  else
510  {
511  pn = *rad;
512  for (iv = Nvar; iv; iv--)
513  {
514  x = var[iv];
515  if (pn[x])
516  {
517  pure[x] = 1;
518  hCheckIndep(pure);
519  pure[x] = 0;
520  }
521  }
522  }
523  }
524  return;
525  }
526  iv = Nvar;
527  while(pure[var[iv]]) iv--;
528  hStepR(rad, Nrad, var, iv, &rad0);
529  iv--;
530  if (rad0 < Nrad)
531  {
532  pn = hGetpure(pure);
533  rn = hGetmem(Nrad, rad, radmem[iv]);
534  pn[var[iv + 1]] = 1;
535  hIndAllMult(pn, Npure + 1, rn, rad0, var, iv);
536  pn[var[iv + 1]] = 0;
537  b = rad0;
538  c = Nrad;
539  hElimR(rn, &rad0, b, c, var, iv);
540  hPure(rn, b, &c, var, iv, pn, &x);
541  hLex2R(rn, rad0, b, c, var, iv, hwork);
542  rad0 += (c - b);
543  hIndAllMult(pn, Npure + x, rn, rad0, var, iv);
544  }
545  else
546  {
547  hIndAllMult(pure, Npure, rad, Nrad, var, iv);
548  }
549 }
550 
551 // multiplicity
552 
553 static int hZeroMult(scmon pure, scfmon stc, int Nstc, varset var, int Nvar)
554 {
555  int iv = Nvar -1, sum, a, a0, a1, b, i;
556  int x, x0;
557  scmon pn;
558  scfmon sn;
559  if (!iv)
560  return pure[var[1]];
561  else if (!Nstc)
562  {
563  sum = 1;
564  for (i = Nvar; i; i--)
565  sum *= pure[var[i]];
566  return sum;
567  }
568  x = a = 0;
569  pn = hGetpure(pure);
570  sn = hGetmem(Nstc, stc, stcmem[iv]);
571  hStepS(sn, Nstc, var, Nvar, &a, &x);
572  if (a == Nstc)
573  return pure[var[Nvar]] * hZeroMult(pn, sn, a, var, iv);
574  else
575  sum = x * hZeroMult(pn, sn, a, var, iv);
576  b = a;
577  loop
578  {
579  a0 = a;
580  x0 = x;
581  hStepS(sn, Nstc, var, Nvar, &a, &x);
582  hElimS(sn, &b, a0, a, var, iv);
583  a1 = a;
584  hPure(sn, a0, &a1, var, iv, pn, &i);
585  hLex2S(sn, b, a0, a1, var, iv, hwork);
586  b += (a1 - a0);
587  if (a < Nstc)
588  {
589  sum += (x - x0) * hZeroMult(pn, sn, b, var, iv);
590  }
591  else
592  {
593  sum += (pure[var[Nvar]] - x0) * hZeroMult(pn, sn, b, var, iv);
594  return sum;
595  }
596  }
597 }
598 
599 static void hProject(scmon pure, varset sel)
600 {
601  int i, i0, k;
602  i0 = 0;
603  for (i = 1; i <= (currRing->N); i++)
604  {
605  if (pure[i])
606  {
607  i0++;
608  sel[i0] = i;
609  }
610  }
611  i = hNstc;
612  memcpy(hwork, hstc, i * sizeof(scmon));
613  hStaircase(hwork, &i, sel, i0);
614  if ((i0 > 2) && (i > 10))
615  hOrdSupp(hwork, i, sel, i0);
616  memset(hpur0, 0, ((currRing->N) + 1) * sizeof(int));
617  hPure(hwork, 0, &i, sel, i0, hpur0, &k);
618  hLexS(hwork, i, sel, i0);
619  hMu += hZeroMult(hpur0, hwork, i, sel, i0);
620 }
621 
622 static void hDimMult(scmon pure, int Npure, scfmon rad, int Nrad,
623  varset var, int Nvar)
624 {
625  int dn, iv, rad0, b, c, x;
626  scmon pn;
627  scfmon rn;
628  if (Nrad < 2)
629  {
630  dn = Npure + Nrad;
631  if (dn == hCo)
632  {
633  if (!Nrad)
634  hProject(pure, hsel);
635  else
636  {
637  pn = *rad;
638  for (iv = Nvar; iv; iv--)
639  {
640  x = var[iv];
641  if (pn[x])
642  {
643  pure[x] = 1;
644  hProject(pure, hsel);
645  pure[x] = 0;
646  }
647  }
648  }
649  }
650  return;
651  }
652  iv = Nvar;
653  dn = Npure+1;
654  if (dn >= hCo)
655  {
656  if (dn > hCo)
657  return;
658  loop
659  {
660  if(!pure[var[iv]])
661  {
662  if(hNotZero(rad, Nrad, var, iv))
663  {
664  pure[var[iv]] = 1;
665  hProject(pure, hsel);
666  pure[var[iv]] = 0;
667  }
668  }
669  iv--;
670  if (!iv)
671  return;
672  }
673  }
674  while(pure[var[iv]]) iv--;
675  hStepR(rad, Nrad, var, iv, &rad0);
676  iv--;
677  if (rad0 < Nrad)
678  {
679  pn = hGetpure(pure);
680  rn = hGetmem(Nrad, rad, radmem[iv]);
681  pn[var[iv + 1]] = 1;
682  hDimMult(pn, Npure + 1, rn, rad0, var, iv);
683  pn[var[iv + 1]] = 0;
684  b = rad0;
685  c = Nrad;
686  hElimR(rn, &rad0, b, c, var, iv);
687  hPure(rn, b, &c, var, iv, pn, &x);
688  hLex2R(rn, rad0, b, c, var, iv, hwork);
689  rad0 += (c - b);
690  hDimMult(pn, Npure + x, rn, rad0, var, iv);
691  }
692  else
693  {
694  hDimMult(pure, Npure, rad, Nrad, var, iv);
695  }
696 }
697 
698 static void hDegree(ideal S, ideal Q)
699 {
700  id_Test(S, currRing);
701  if( Q!=NULL ) id_Test(Q, currRing);
702 
703  int di;
704  int mc;
705  hexist = hInit(S, Q, &hNexist, currRing);
706  if (!hNexist)
707  {
708  hCo = 0;
709  hMu = 1;
710  return;
711  }
712  //hWeight();
713  hwork = (scfmon)omAlloc(hNexist * sizeof(scmon));
714  hvar = (varset)omAlloc(((currRing->N) + 1) * sizeof(int));
715  hsel = (varset)omAlloc(((currRing->N) + 1) * sizeof(int));
716  hpure = (scmon)omAlloc((1 + ((currRing->N) * (currRing->N))) * sizeof(int));
717  hpur0 = (scmon)omAlloc((1 + ((currRing->N) * (currRing->N))) * sizeof(int));
718  mc = hisModule;
719  hrad = (scfmon)omAlloc(hNexist * sizeof(scmon));
720  if (!mc)
721  {
722  memcpy(hrad, hexist, hNexist * sizeof(scmon));
723  hstc = hexist;
724  hNrad = hNstc = hNexist;
725  }
726  else
727  hstc = (scfmon)omAlloc(hNexist * sizeof(scmon));
728  radmem = hCreate((currRing->N) - 1);
729  stcmem = hCreate((currRing->N) - 1);
730  hCo = (currRing->N) + 1;
731  di = hCo + 1;
732  loop
733  {
734  if (mc)
735  {
736  hComp(hexist, hNexist, mc, hrad, &hNrad);
737  hNstc = hNrad;
738  memcpy(hstc, hrad, hNrad * sizeof(scmon));
739  }
740  if (hNrad)
741  {
742  hNvar = (currRing->N);
743  hRadical(hrad, &hNrad, hNvar);
744  hSupp(hrad, hNrad, hvar, &hNvar);
745  if (hNvar)
746  {
747  hCo = hNvar;
748  memset(hpure, 0, ((currRing->N) + 1) * sizeof(int));
749  hPure(hrad, 0, &hNrad, hvar, hNvar, hpure, &hNpure);
750  hLexR(hrad, hNrad, hvar, hNvar);
752  }
753  }
754  else
755  {
756  hNvar = 1;
757  hCo = 0;
758  }
759  if (hCo < di)
760  {
761  di = hCo;
762  hMu = 0;
763  }
764  if (hNvar && (hCo == di))
765  {
766  if (di && (di < (currRing->N)))
768  else if (!di)
769  hMu++;
770  else
771  {
773  if ((hNvar > 2) && (hNstc > 10))
775  memset(hpur0, 0, ((currRing->N) + 1) * sizeof(int));
776  hPure(hstc, 0, &hNstc, hvar, hNvar, hpur0, &hNpure);
777  hLexS(hstc, hNstc, hvar, hNvar);
779  }
780  }
781  mc--;
782  if (mc <= 0)
783  break;
784  }
785  hCo = di;
786  hKill(stcmem, (currRing->N) - 1);
787  hKill(radmem, (currRing->N) - 1);
788  omFreeSize((ADDRESS)hpur0, (1 + ((currRing->N) * (currRing->N))) * sizeof(int));
789  omFreeSize((ADDRESS)hpure, (1 + ((currRing->N) * (currRing->N))) * sizeof(int));
790  omFreeSize((ADDRESS)hsel, ((currRing->N) + 1) * sizeof(int));
791  omFreeSize((ADDRESS)hvar, ((currRing->N) + 1) * sizeof(int));
792  omFreeSize((ADDRESS)hwork, hNexist * sizeof(scmon));
793  omFreeSize((ADDRESS)hrad, hNexist * sizeof(scmon));
795  if (hisModule)
796  omFreeSize((ADDRESS)hstc, hNexist * sizeof(scmon));
797 }
798 
799 int scMultInt(ideal S, ideal Q)
800 {
801  id_Test(S, currRing);
802  if( Q!=NULL ) id_Test(Q, currRing);
803 
804  hDegree(S, Q);
805  return hMu;
806 }
807 
808 void scPrintDegree(int co, int mu)
809 {
810  int di = (currRing->N)-co;
811  if (currRing->OrdSgn == 1)
812  {
813  if (di>0)
814  Print("// dimension (proj.) = %d\n// degree (proj.) = %d\n", di-1, mu);
815  else
816  Print("// dimension (affine) = 0\n// degree (affine) = %d\n", mu);
817  }
818  else
819  Print("// dimension (local) = %d\n// multiplicity = %d\n", di, mu);
820 }
821 
822 void scDegree(ideal S, intvec *modulweight, ideal Q)
823 {
824  id_Test(S, currRing);
825  if( Q!=NULL ) id_Test(Q, currRing);
826 
827  int co, mu, l;
828  intvec *hseries2;
829  intvec *hseries1 = hFirstSeries(S, modulweight, Q);
830  l = hseries1->length()-1;
831  if (l > 1)
832  hseries2 = hSecondSeries(hseries1);
833  else
834  hseries2 = hseries1;
835  hDegreeSeries(hseries1, hseries2, &co, &mu);
836  if ((l == 1) &&(mu == 0))
837  scPrintDegree((currRing->N)+1, 0);
838  else
839  scPrintDegree(co, mu);
840  if (l>1)
841  delete hseries1;
842  delete hseries2;
843 }
844 
845 static void hDegree0(ideal S, ideal Q, const ring tailRing)
846 {
847  id_TestTail(S, currRing, tailRing);
848  if (Q!=NULL) id_TestTail(Q, currRing, tailRing);
849 
850  int mc;
851  hexist = hInit(S, Q, &hNexist, tailRing);
852  if (!hNexist)
853  {
854  hMu = -1;
855  return;
856  }
857  else
858  hMu = 0;
859 
860  const ring r = currRing;
861 
862  hwork = (scfmon)omAlloc(hNexist * sizeof(scmon));
863  hvar = (varset)omAlloc(((r->N) + 1) * sizeof(int));
864  hpur0 = (scmon)omAlloc((1 + ((r->N) * (r->N))) * sizeof(int));
865  mc = hisModule;
866  if (!mc)
867  {
868  hstc = hexist;
869  hNstc = hNexist;
870  }
871  else
872  hstc = (scfmon)omAlloc(hNexist * sizeof(scmon));
873  stcmem = hCreate((r->N) - 1);
874  loop
875  {
876  if (mc)
877  {
878  hComp(hexist, hNexist, mc, hstc, &hNstc);
879  if (!hNstc)
880  {
881  hMu = -1;
882  break;
883  }
884  }
885  hNvar = (r->N);
886  for (int i = hNvar; i; i--)
887  hvar[i] = i;
889  hSupp(hstc, hNstc, hvar, &hNvar);
890  if ((hNvar == (r->N)) && (hNstc >= (r->N)))
891  {
892  if ((hNvar > 2) && (hNstc > 10))
894  memset(hpur0, 0, ((r->N) + 1) * sizeof(int));
895  hPure(hstc, 0, &hNstc, hvar, hNvar, hpur0, &hNpure);
896  if (hNpure == hNvar)
897  {
898  hLexS(hstc, hNstc, hvar, hNvar);
900  }
901  else
902  hMu = -1;
903  }
904  else if (hNvar)
905  hMu = -1;
906  mc--;
907  if (mc <= 0 || hMu < 0)
908  break;
909  }
910  hKill(stcmem, (r->N) - 1);
911  omFreeSize((ADDRESS)hpur0, (1 + ((r->N) * (r->N))) * sizeof(int));
912  omFreeSize((ADDRESS)hvar, ((r->N) + 1) * sizeof(int));
913  omFreeSize((ADDRESS)hwork, hNexist * sizeof(scmon));
915  if (hisModule)
916  omFreeSize((ADDRESS)hstc, hNexist * sizeof(scmon));
917 }
918 
919 int scMult0Int(ideal S, ideal Q, const ring tailRing)
920 {
921  id_TestTail(S, currRing, tailRing);
922  if (Q!=NULL) id_TestTail(Q, currRing, tailRing);
923 
924  hDegree0(S, Q, tailRing);
925  return hMu;
926 }
927 
928 
929 // HC
930 
931 static poly pWork;
932 
933 static void hHedge(poly hEdge)
934 {
935  pSetm(pWork);
936  if (pLmCmp(pWork, hEdge) == currRing->OrdSgn)
937  {
938  for (int i = hNvar; i>0; i--)
939  pSetExp(hEdge,i, pGetExp(pWork,i));
940  pSetm(hEdge);
941  }
942 }
943 
944 
945 static void hHedgeStep(scmon pure, scfmon stc,
946  int Nstc, varset var, int Nvar,poly hEdge)
947 {
948  int iv = Nvar -1, k = var[Nvar], a, a0, a1, b, i;
949  int x/*, x0*/;
950  scmon pn;
951  scfmon sn;
952  if (iv==0)
953  {
954  pSetExp(pWork, k, pure[k]);
955  hHedge(hEdge);
956  return;
957  }
958  else if (Nstc==0)
959  {
960  for (i = Nvar; i>0; i--)
961  pSetExp(pWork, var[i], pure[var[i]]);
962  hHedge(hEdge);
963  return;
964  }
965  x = a = 0;
966  pn = hGetpure(pure);
967  sn = hGetmem(Nstc, stc, stcmem[iv]);
968  hStepS(sn, Nstc, var, Nvar, &a, &x);
969  if (a == Nstc)
970  {
971  pSetExp(pWork, k, pure[k]);
972  hHedgeStep(pn, sn, a, var, iv,hEdge);
973  return;
974  }
975  else
976  {
977  pSetExp(pWork, k, x);
978  hHedgeStep(pn, sn, a, var, iv,hEdge);
979  }
980  b = a;
981  loop
982  {
983  a0 = a;
984  // x0 = x;
985  hStepS(sn, Nstc, var, Nvar, &a, &x);
986  hElimS(sn, &b, a0, a, var, iv);
987  a1 = a;
988  hPure(sn, a0, &a1, var, iv, pn, &i);
989  hLex2S(sn, b, a0, a1, var, iv, hwork);
990  b += (a1 - a0);
991  if (a < Nstc)
992  {
993  pSetExp(pWork, k, x);
994  hHedgeStep(pn, sn, b, var, iv,hEdge);
995  }
996  else
997  {
998  pSetExp(pWork, k, pure[k]);
999  hHedgeStep(pn, sn, b, var, iv,hEdge);
1000  return;
1001  }
1002  }
1003 }
1004 
1005 void scComputeHC(ideal S, ideal Q, int ak, poly &hEdge, ring tailRing)
1006 {
1007  id_TestTail(S, currRing, tailRing);
1008  if (Q!=NULL) id_TestTail(Q, currRing, tailRing);
1009 
1010  int i;
1011  int k = ak;
1012  #if HAVE_RINGS
1013  if (rField_is_Ring(currRing) && (currRing->OrdSgn == -1))
1014  {
1015  //consider just monic generators (over rings with zero-divisors)
1016  ideal SS=id_Copy(S,tailRing);
1017  for(i=0;i<=idElem(S);i++)
1018  {
1019  if((SS->m[i]!=NULL)
1020  && ((p_IsPurePower(SS->m[i],tailRing)==0)
1021  ||(!n_IsUnit(pGetCoeff(SS->m[i]), tailRing->cf))))
1022  {
1023  p_Delete(&SS->m[i],tailRing);
1024  }
1025  }
1026  S=id_Copy(SS,tailRing);
1027  idSkipZeroes(S);
1028  }
1029  #if 0
1030  printf("\nThis is HC:\n");
1031  for(int ii=0;ii<=idElem(S);ii++)
1032  {
1033  pWrite(S->m[ii]);
1034  }
1035  //getchar();
1036  #endif
1037  #endif
1038  if(idElem(S) == 0)
1039  return;
1040  hNvar = (currRing->N);
1041  hexist = hInit(S, Q, &hNexist, tailRing); // tailRing?
1042  if (k!=0)
1043  hComp(hexist, hNexist, k, hexist, &hNstc);
1044  else
1045  hNstc = hNexist;
1046  assume(hNexist > 0);
1047  hwork = (scfmon)omAlloc(hNexist * sizeof(scmon));
1048  hvar = (varset)omAlloc((hNvar + 1) * sizeof(int));
1049  hpure = (scmon)omAlloc((1 + (hNvar * hNvar)) * sizeof(int));
1050  stcmem = hCreate(hNvar - 1);
1051  for (i = hNvar; i>0; i--)
1052  hvar[i] = i;
1054  if ((hNvar > 2) && (hNstc > 10))
1056  memset(hpure, 0, (hNvar + 1) * sizeof(int));
1057  hPure(hexist, 0, &hNstc, hvar, hNvar, hpure, &hNpure);
1058  hLexS(hexist, hNstc, hvar, hNvar);
1059  if (hEdge!=NULL)
1060  pLmFree(hEdge);
1061  hEdge = pInit();
1062  pWork = pInit();
1063  hHedgeStep(hpure, hexist, hNstc, hvar, hNvar,hEdge);
1064  pSetComp(hEdge,ak);
1065  hKill(stcmem, hNvar - 1);
1066  omFreeSize((ADDRESS)hwork, hNexist * sizeof(scmon));
1067  omFreeSize((ADDRESS)hvar, (hNvar + 1) * sizeof(int));
1068  omFreeSize((ADDRESS)hpure, (1 + (hNvar * hNvar)) * sizeof(int));
1070  pLmFree(pWork);
1071 }
1072 
1073 
1074 
1075 // kbase
1076 
1077 static poly last;
1078 static scmon act;
1079 
1080 static void scElKbase()
1081 {
1082  poly q = pInit();
1083  pSetCoeff0(q,nInit(1));
1084  pSetExpV(q,act);
1085  pNext(q) = NULL;
1086  last = pNext(last) = q;
1087 }
1088 
1089 static int scMax( int i, scfmon stc, int Nvar)
1090 {
1091  int x, y=stc[0][Nvar];
1092  for (; i;)
1093  {
1094  i--;
1095  x = stc[i][Nvar];
1096  if (x > y) y = x;
1097  }
1098  return y;
1099 }
1100 
1101 static int scMin( int i, scfmon stc, int Nvar)
1102 {
1103  int x, y=stc[0][Nvar];
1104  for (; i;)
1105  {
1106  i--;
1107  x = stc[i][Nvar];
1108  if (x < y) y = x;
1109  }
1110  return y;
1111 }
1112 
1113 static int scRestrict( int &Nstc, scfmon stc, int Nvar)
1114 {
1115  int x, y;
1116  int i, j, Istc = Nstc;
1117 
1118  y = MAX_INT_VAL;
1119  for (i=Nstc-1; i>=0; i--)
1120  {
1121  j = Nvar-1;
1122  loop
1123  {
1124  if(stc[i][j] != 0) break;
1125  j--;
1126  if (j == 0)
1127  {
1128  Istc--;
1129  x = stc[i][Nvar];
1130  if (x < y) y = x;
1131  stc[i] = NULL;
1132  break;
1133  }
1134  }
1135  }
1136  if (Istc < Nstc)
1137  {
1138  for (i=Nstc-1; i>=0; i--)
1139  {
1140  if (stc[i] && (stc[i][Nvar] >= y))
1141  {
1142  Istc--;
1143  stc[i] = NULL;
1144  }
1145  }
1146  j = 0;
1147  while (stc[j]) j++;
1148  i = j+1;
1149  for(; i<Nstc; i++)
1150  {
1151  if (stc[i])
1152  {
1153  stc[j] = stc[i];
1154  j++;
1155  }
1156  }
1157  Nstc = Istc;
1158  return y;
1159  }
1160  else
1161  return -1;
1162 }
1163 
1164 static void scAll( int Nvar, int deg)
1165 {
1166  int i;
1167  int d = deg;
1168  if (d == 0)
1169  {
1170  for (i=Nvar; i; i--) act[i] = 0;
1171  scElKbase();
1172  return;
1173  }
1174  if (Nvar == 1)
1175  {
1176  act[1] = d;
1177  scElKbase();
1178  return;
1179  }
1180  do
1181  {
1182  act[Nvar] = d;
1183  scAll(Nvar-1, deg-d);
1184  d--;
1185  } while (d >= 0);
1186 }
1187 
1188 static void scAllKbase( int Nvar, int ideg, int deg)
1189 {
1190  do
1191  {
1192  act[Nvar] = ideg;
1193  scAll(Nvar-1, deg-ideg);
1194  ideg--;
1195  } while (ideg >= 0);
1196 }
1197 
1198 static void scDegKbase( scfmon stc, int Nstc, int Nvar, int deg)
1199 {
1200  int Ivar, Istc, i, j;
1201  scfmon sn;
1202  int x, ideg;
1203 
1204  if (deg == 0)
1205  {
1206  for (i=Nstc-1; i>=0; i--)
1207  {
1208  for (j=Nvar;j;j--){ if(stc[i][j]) break; }
1209  if (j==0){return;}
1210  }
1211  for (i=Nvar; i; i--) act[i] = 0;
1212  scElKbase();
1213  return;
1214  }
1215  if (Nvar == 1)
1216  {
1217  for (i=Nstc-1; i>=0; i--) if(deg >= stc[i][1]) return;
1218  act[1] = deg;
1219  scElKbase();
1220  return;
1221  }
1222  Ivar = Nvar-1;
1223  sn = hGetmem(Nstc, stc, stcmem[Ivar]);
1224  x = scRestrict(Nstc, sn, Nvar);
1225  if (x <= 0)
1226  {
1227  if (x == 0) return;
1228  ideg = deg;
1229  }
1230  else
1231  {
1232  if (deg < x) ideg = deg;
1233  else ideg = x-1;
1234  if (Nstc == 0)
1235  {
1236  scAllKbase(Nvar, ideg, deg);
1237  return;
1238  }
1239  }
1240  loop
1241  {
1242  x = scMax(Nstc, sn, Nvar);
1243  while (ideg >= x)
1244  {
1245  act[Nvar] = ideg;
1246  scDegKbase(sn, Nstc, Ivar, deg-ideg);
1247  ideg--;
1248  }
1249  if (ideg < 0) return;
1250  Istc = Nstc;
1251  for (i=Nstc-1; i>=0; i--)
1252  {
1253  if (ideg < sn[i][Nvar])
1254  {
1255  Istc--;
1256  sn[i] = NULL;
1257  }
1258  }
1259  if (Istc == 0)
1260  {
1261  scAllKbase(Nvar, ideg, deg);
1262  return;
1263  }
1264  j = 0;
1265  while (sn[j]) j++;
1266  i = j+1;
1267  for (; i<Nstc; i++)
1268  {
1269  if (sn[i])
1270  {
1271  sn[j] = sn[i];
1272  j++;
1273  }
1274  }
1275  Nstc = Istc;
1276  }
1277 }
1278 
1279 static void scInKbase( scfmon stc, int Nstc, int Nvar)
1280 {
1281  int Ivar, Istc, i, j;
1282  scfmon sn;
1283  int x, ideg;
1284 
1285  if (Nvar == 1)
1286  {
1287  ideg = scMin(Nstc, stc, 1);
1288  while (ideg > 0)
1289  {
1290  ideg--;
1291  act[1] = ideg;
1292  scElKbase();
1293  }
1294  return;
1295  }
1296  Ivar = Nvar-1;
1297  sn = hGetmem(Nstc, stc, stcmem[Ivar]);
1298  x = scRestrict(Nstc, sn, Nvar);
1299  if (x == 0) return;
1300  ideg = x-1;
1301  loop
1302  {
1303  x = scMax(Nstc, sn, Nvar);
1304  while (ideg >= x)
1305  {
1306  act[Nvar] = ideg;
1307  scInKbase(sn, Nstc, Ivar);
1308  ideg--;
1309  }
1310  if (ideg < 0) return;
1311  Istc = Nstc;
1312  for (i=Nstc-1; i>=0; i--)
1313  {
1314  if (ideg < sn[i][Nvar])
1315  {
1316  Istc--;
1317  sn[i] = NULL;
1318  }
1319  }
1320  j = 0;
1321  while (sn[j]) j++;
1322  i = j+1;
1323  for (; i<Nstc; i++)
1324  {
1325  if (sn[i])
1326  {
1327  sn[j] = sn[i];
1328  j++;
1329  }
1330  }
1331  Nstc = Istc;
1332  }
1333 }
1334 
1335 static ideal scIdKbase(poly q, const int rank)
1336 {
1337  ideal res = idInit(pLength(q), rank);
1338  polyset mm = res->m;
1339  do
1340  {
1341  *mm = q; ++mm;
1342 
1343  const poly p = pNext(q);
1344  pNext(q) = NULL;
1345  q = p;
1346 
1347  } while (q!=NULL);
1348 
1349  id_Test(res, currRing); // WRONG RANK!!!???
1350  return res;
1351 }
1352 
1353 ideal scKBase(int deg, ideal s, ideal Q, intvec * mv)
1354 {
1355  if( Q!=NULL) id_Test(Q, currRing);
1356 
1357  int i, di;
1358  poly p;
1359 
1360  if (deg < 0)
1361  {
1362  di = scDimInt(s, Q);
1363  if (di != 0)
1364  {
1365  //Werror("KBase not finite");
1366  return idInit(1,s->rank);
1367  }
1368  }
1369  stcmem = hCreate((currRing->N) - 1);
1370  hexist = hInit(s, Q, &hNexist, currRing);
1371  p = last = pInit();
1372  /*pNext(p) = NULL;*/
1373  act = (scmon)omAlloc(((currRing->N) + 1) * sizeof(int));
1374  *act = 0;
1375  if (!hNexist)
1376  {
1377  scAll((currRing->N), deg);
1378  goto ende;
1379  }
1380  if (!hisModule)
1381  {
1382  if (deg < 0) scInKbase(hexist, hNexist, (currRing->N));
1383  else scDegKbase(hexist, hNexist, (currRing->N), deg);
1384  }
1385  else
1386  {
1387  hstc = (scfmon)omAlloc(hNexist * sizeof(scmon));
1388  for (i = 1; i <= hisModule; i++)
1389  {
1390  *act = i;
1391  hComp(hexist, hNexist, i, hstc, &hNstc);
1392  int deg_ei=deg;
1393  if (mv!=NULL) deg_ei -= (*mv)[i-1];
1394  if ((deg < 0) || (deg_ei>=0))
1395  {
1396  if (hNstc)
1397  {
1398  if (deg < 0) scInKbase(hstc, hNstc, (currRing->N));
1399  else scDegKbase(hstc, hNstc, (currRing->N), deg_ei);
1400  }
1401  else
1402  scAll((currRing->N), deg_ei);
1403  }
1404  }
1405  omFreeSize((ADDRESS)hstc, hNexist * sizeof(scmon));
1406  }
1407 ende:
1409  omFreeSize((ADDRESS)act, ((currRing->N) + 1) * sizeof(int));
1410  hKill(stcmem, (currRing->N) - 1);
1411  pLmFree(&p);
1412  if (p == NULL)
1413  return idInit(1,s->rank);
1414 
1415  last = p;
1416  return scIdKbase(p, s->rank);
1417 }
1418 
1419 #if 0 //-- alternative implementation of scComputeHC
1420 /*
1421 void scComputeHCw(ideal ss, ideal Q, int ak, poly &hEdge, ring tailRing)
1422 {
1423  id_TestTail(ss, currRing, tailRing);
1424  if (Q!=NULL) id_TestTail(Q, currRing, tailRing);
1425 
1426  int i, di;
1427  poly p;
1428 
1429  if (hEdge!=NULL)
1430  pLmFree(hEdge);
1431 
1432  ideal s=idInit(IDELEMS(ss),ak);
1433  for(i=IDELEMS(ss)-1;i>=0;i--)
1434  {
1435  if (ss->m[i]!=NULL) s->m[i]=pHead(ss->m[i]);
1436  }
1437  di = scDimInt(s, Q);
1438  stcmem = hCreate((currRing->N) - 1);
1439  hexist = hInit(s, Q, &hNexist, currRing);
1440  p = last = pInit();
1441  // pNext(p) = NULL;
1442  act = (scmon)omAlloc(((currRing->N) + 1) * sizeof(int));
1443  *act = 0;
1444  if (!hNexist)
1445  {
1446  scAll((currRing->N), -1);
1447  goto ende;
1448  }
1449  if (!hisModule)
1450  {
1451  scInKbase(hexist, hNexist, (currRing->N));
1452  }
1453  else
1454  {
1455  hstc = (scfmon)omAlloc(hNexist * sizeof(scmon));
1456  for (i = 1; i <= hisModule; i++)
1457  {
1458  *act = i;
1459  hComp(hexist, hNexist, i, hstc, &hNstc);
1460  if (hNstc)
1461  {
1462  scInKbase(hstc, hNstc, (currRing->N));
1463  }
1464  else
1465  scAll((currRing->N), -1);
1466  }
1467  omFreeSize((ADDRESS)hstc, hNexist * sizeof(scmon));
1468  }
1469 ende:
1470  hDelete(hexist, hNexist);
1471  omFreeSize((ADDRESS)act, ((currRing->N) + 1) * sizeof(int));
1472  hKill(stcmem, (currRing->N) - 1);
1473  pDeleteLm(&p);
1474  idDelete(&s);
1475  if (p == NULL)
1476  {
1477  return; // no HEdge
1478  }
1479  else
1480  {
1481  last = p;
1482  ideal res=scIdKbase(p, ss->rank);
1483  poly p_ind=res->m[0]; int ind=0;
1484  for(i=IDELEMS(res)-1;i>0;i--)
1485  {
1486  if (pCmp(res->m[i],p_ind)==-1) { p_ind=res->m[i]; ind=i; }
1487  }
1488  assume(p_ind!=NULL);
1489  assume(res->m[ind]==p_ind);
1490  hEdge=p_ind;
1491  res->m[ind]=NULL;
1492  nDelete(&pGetCoeff(hEdge));
1493  pGetCoeff(hEdge)=NULL;
1494  for(i=(currRing->N);i>0;i--)
1495  pIncrExp(hEdge,i);
1496  pSetm(hEdge);
1497 
1498  idDelete(&res);
1499  return;
1500  }
1501 }
1502  */
1503 #endif
ideal scKBase(int deg, ideal s, ideal Q, intvec *mv)
Definition: hdegree.cc:1353
int hMu2
Definition: hdegree.cc:22
#define id_TestTail(A, lR, tR)
Definition: simpleideals.h:79
int hNstc
Definition: hutil.cc:22
const CanonicalForm int s
Definition: facAbsFact.cc:55
void hLexS(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:512
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
int j
Definition: facHensel.cc:105
void hDimSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:29
#define pSetm(p)
Definition: polys.h:265
void hElimR(scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:748
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
Definition: coeffs.h:515
omBin_t * omBin
Definition: omStructs.h:12
#define Print
Definition: emacs.cc:80
scfmon hwork
Definition: hutil.cc:19
void mu(int **points, int sizePoints)
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1029
void hIndAllMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:496
int hNexist
Definition: hutil.cc:22
int * varset
Definition: hutil.h:16
int hCo
Definition: hdegree.cc:22
void hElimS(scfmon stc, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:678
void scPrintDegree(int co, int mu)
Definition: hdegree.cc:808
intvec * scIndIntvec(ideal S, ideal Q)
Definition: hdegree.cc:212
#define pSetExp(p, i, v)
Definition: polys.h:42
#define FALSE
Definition: auxiliary.h:94
Compatiblity layer for legacy polynomial operations (over currRing)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
scmon hGetpure(scmon p)
Definition: hutil.cc:1058
#define id_Test(A, lR)
Definition: simpleideals.h:80
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
scmon * scfmon
Definition: hutil.h:15
static void scDegKbase(scfmon stc, int Nstc, int Nvar, int deg)
Definition: hdegree.cc:1198
static poly last
Definition: hdegree.cc:1077
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
scfmon hexist
Definition: hutil.cc:19
static void hProject(scmon pure, varset sel)
Definition: hdegree.cc:599
static BOOLEAN hNotZero(scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:281
static void hDegree(ideal S, ideal Q)
Definition: hdegree.cc:698
static poly pWork
Definition: hdegree.cc:931
static void hCheckIndep(scmon pure)
Definition: hdegree.cc:472
static indset hCheck2(indset sm, scmon pure)
Definition: hdegree.cc:420
monf hCreate(int Nvar)
Definition: hutil.cc:1002
void scComputeHC(ideal S, ideal Q, int ak, poly &hEdge, ring tailRing)
Definition: hdegree.cc:1005
int hNvar
Definition: hutil.cc:22
#define TRUE
Definition: auxiliary.h:98
void * ADDRESS
Definition: auxiliary.h:133
int hNrad
Definition: hutil.cc:22
int hNpure
Definition: hutil.cc:22
static void scAllKbase(int Nvar, int ideg, int deg)
Definition: hdegree.cc:1188
void hDegreeSeries(intvec *s1, intvec *s2, int *co, int *mu)
Definition: hilb.cc:1381
void pWrite(poly p)
Definition: polys.h:302
const int MAX_INT_VAL
Definition: mylimits.h:12
scmon hpure
Definition: hutil.cc:20
int k
Definition: cfEzgcd.cc:92
void hStepR(scfmon rad, int Nrad, varset var, int Nvar, int *a)
Definition: hutil.cc:980
#define Q
Definition: sirandom.c:25
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:45
#define loop
Definition: structs.h:78
void hRadical(scfmon rad, int *Nrad, int Nvar)
Definition: hutil.cc:417
#define omAlloc(size)
Definition: omAllocDecl.h:210
scfmon hrad
Definition: hutil.cc:19
void hDelete(scfmon ev, int ev_length)
Definition: hutil.cc:146
int scMultInt(ideal S, ideal Q)
Definition: hdegree.cc:799
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
indset ISet
Definition: hdegree.cc:279
CanonicalForm b
Definition: cfModGcd.cc:4044
void hOrdSupp(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:208
Definition: intvec.h:17
CanonicalForm res
Definition: facAbsFact.cc:64
void hKill(monf xmem, int Nvar)
Definition: hutil.cc:1016
Variable var
Definition: int_poly.h:74
varset hvar
Definition: hutil.cc:21
static void hIndep(scmon pure)
Definition: hdegree.cc:296
static void hHedge(poly hEdge)
Definition: hdegree.cc:933
int scMult0Int(ideal S, ideal Q, const ring tailRing)
Definition: hdegree.cc:919
#define assume(x)
Definition: mod2.h:390
void hIndMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:313
void scDegree(ideal S, intvec *modulweight, ideal Q)
Definition: hdegree.cc:822
static void hDimMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:622
#define pSetExpV(p, e)
Definition: polys.h:97
int scDimInt(ideal S, ideal Q)
Definition: hdegree.cc:72
indlist * indset
Definition: hutil.h:28
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
void hStaircase(scfmon stc, int *Nstc, varset var, int Nvar)
Definition: hutil.cc:319
omBin indlist_bin
Definition: hdegree.cc:23
indset JSet
Definition: hdegree.cc:279
#define pSetComp(p, v)
Definition: polys.h:38
static void hHedgeStep(scmon pure, scfmon stc, int Nstc, varset var, int Nvar, poly hEdge)
Definition: hdegree.cc:945
int * scmon
Definition: hutil.h:14
poly * polyset
Definition: polys.h:254
int i
Definition: cfEzgcd.cc:125
void hLex2S(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:818
static BOOLEAN hCheck1(indset sm, scmon pure)
Definition: hdegree.cc:394
static unsigned pLength(poly a)
Definition: p_polys.h:193
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
void hLex2R(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:886
static int scRestrict(int &Nstc, scfmon stc, int Nvar)
Definition: hdegree.cc:1113
void hLexR(scfmon rad, int Nrad, varset var, int Nvar)
Definition: hutil.cc:571
static void scElKbase()
Definition: hdegree.cc:1080
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:858
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
#define omGetSpecBin(size)
Definition: omBin.h:11
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:37
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
Definition: p_polys.cc:1218
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:475
#define NULL
Definition: omList.c:10
varset hsel
Definition: hutil.cc:21
monf stcmem
Definition: hutil.cc:24
int length() const
Definition: intvec.h:92
void hStepS(scfmon stc, int Nstc, varset var, int Nvar, int *a, int *x)
Definition: hutil.cc:955
static ideal scIdKbase(poly q, const int rank)
Definition: hdegree.cc:1335
intvec * hSecondSeries(intvec *hseries1)
Definition: hilb.cc:1346
monf radmem
Definition: hutil.cc:24
#define pInit()
allocates a new monomial and initializes everything to 0
Definition: polys.h:61
Variable x
Definition: cfModGcd.cc:4023
#define pNext(p)
Definition: monomials.h:37
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
static void scInKbase(scfmon stc, int Nstc, int Nvar)
Definition: hdegree.cc:1279
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
Definition: polys.h:70
#define pSetCoeff0(p, n)
Definition: monomials.h:60
static int scMax(int i, scfmon stc, int Nvar)
Definition: hdegree.cc:1089
int idElem(const ideal F)
count non-zero elements
int hisModule
Definition: hutil.cc:23
static scmon act
Definition: hdegree.cc:1078
static void scAll(int Nvar, int deg)
Definition: hdegree.cc:1164
int p
Definition: cfModGcd.cc:4019
intvec * hFirstSeries(ideal S, intvec *modulweight, ideal Q, intvec *wdegree, ring tailRing)
Definition: hilb.cc:1336
static void hIndSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:133
static scmon hInd
Definition: hdegree.cc:131
static int scMin(int i, scfmon stc, int Nvar)
Definition: hdegree.cc:1101
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
scfmon hstc
Definition: hutil.cc:19
#define nInit(i)
Definition: numbers.h:25
scmon hpur0
Definition: hutil.cc:20
int BOOLEAN
Definition: auxiliary.h:85
void hComp(scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
Definition: hutil.cc:160
static void hDegree0(ideal S, ideal Q, const ring tailRing)
Definition: hdegree.cc:845
scfmon hInit(ideal S, ideal Q, int *Nexist, ring tailRing)
Definition: hutil.cc:34
int hMu
Definition: hdegree.cc:22
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int l
Definition: cfEzgcd.cc:93
static int hZeroMult(scmon pure, scfmon stc, int Nstc, varset var, int Nvar)
Definition: hdegree.cc:553
void hSupp(scfmon stc, int Nstc, varset var, int *Nvar)
Definition: hutil.cc:180