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