My Project  UNKNOWN_GIT_VERSION
Functions | Variables
hdegree.cc File Reference
#include "kernel/mod2.h"
#include "omalloc/omalloc.h"
#include "misc/intvec.h"
#include "coeffs/numbers.h"
#include "kernel/structs.h"
#include "kernel/ideals.h"
#include "kernel/polys.h"
#include "kernel/combinatorics/hutil.h"
#include "kernel/combinatorics/hilb.h"
#include "kernel/combinatorics/stairc.h"

Go to the source code of this file.

Functions

void hDimSolve (scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
 
int scDimInt (ideal S, ideal Q)
 
static void hIndSolve (scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
 
intvecscIndIntvec (ideal S, ideal Q)
 
static BOOLEAN hNotZero (scfmon rad, int Nrad, varset var, int Nvar)
 
static void hIndep (scmon pure)
 
void hIndMult (scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
 
static BOOLEAN hCheck1 (indset sm, scmon pure)
 
static indset hCheck2 (indset sm, scmon pure)
 
static void hCheckIndep (scmon pure)
 
void hIndAllMult (scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
 
static int hZeroMult (scmon pure, scfmon stc, int Nstc, varset var, int Nvar)
 
static void hProject (scmon pure, varset sel)
 
static void hDimMult (scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
 
static void hDegree (ideal S, ideal Q)
 
int scMultInt (ideal S, ideal Q)
 
void scPrintDegree (int co, int mu)
 
void scDegree (ideal S, intvec *modulweight, ideal Q)
 
static void hDegree0 (ideal S, ideal Q, const ring tailRing)
 
int scMult0Int (ideal S, ideal Q, const ring tailRing)
 
static void hHedge (poly hEdge)
 
static void hHedgeStep (scmon pure, scfmon stc, int Nstc, varset var, int Nvar, poly hEdge)
 
void scComputeHC (ideal S, ideal Q, int ak, poly &hEdge, ring tailRing)
 
static void scElKbase ()
 
static int scMax (int i, scfmon stc, int Nvar)
 
static int scMin (int i, scfmon stc, int Nvar)
 
static int scRestrict (int &Nstc, scfmon stc, int Nvar)
 
static void scAll (int Nvar, int deg)
 
static void scAllKbase (int Nvar, int ideg, int deg)
 
static void scDegKbase (scfmon stc, int Nstc, int Nvar, int deg)
 
static void scInKbase (scfmon stc, int Nstc, int Nvar)
 
static ideal scIdKbase (poly q, const int rank)
 
ideal scKBase (int deg, ideal s, ideal Q, intvec *mv)
 

Variables

int hCo
 
int hMu
 
int hMu2
 
omBin indlist_bin = omGetSpecBin(sizeof(indlist))
 
static scmon hInd
 
indset ISet
 
indset JSet
 
static poly pWork
 
static poly last
 
static scmon act
 

Function Documentation

◆ hCheck1()

static BOOLEAN hCheck1 ( indset  sm,
scmon  pure 
)
static

Definition at line 394 of file hdegree.cc.

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 }

◆ hCheck2()

static indset hCheck2 ( indset  sm,
scmon  pure 
)
static

Definition at line 420 of file hdegree.cc.

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 }

◆ hCheckIndep()

static void hCheckIndep ( scmon  pure)
static

Definition at line 472 of file hdegree.cc.

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 }

◆ hDegree()

static void hDegree ( ideal  S,
ideal  Q 
)
static

Definition at line 698 of file hdegree.cc.

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 }

◆ hDegree0()

static void hDegree0 ( ideal  S,
ideal  Q,
const ring  tailRing 
)
static

Definition at line 845 of file hdegree.cc.

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 }

◆ hDimMult()

static void hDimMult ( scmon  pure,
int  Npure,
scfmon  rad,
int  Nrad,
varset  var,
int  Nvar 
)
static

Definition at line 622 of file hdegree.cc.

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 }

◆ hDimSolve()

void hDimSolve ( scmon  pure,
int  Npure,
scfmon  rad,
int  Nrad,
varset  var,
int  Nvar 
)

Definition at line 29 of file hdegree.cc.

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 }

◆ hHedge()

static void hHedge ( poly  hEdge)
static

Definition at line 933 of file hdegree.cc.

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 }

◆ hHedgeStep()

static void hHedgeStep ( scmon  pure,
scfmon  stc,
int  Nstc,
varset  var,
int  Nvar,
poly  hEdge 
)
static

Definition at line 945 of file hdegree.cc.

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 }

◆ hIndAllMult()

void hIndAllMult ( scmon  pure,
int  Npure,
scfmon  rad,
int  Nrad,
varset  var,
int  Nvar 
)

Definition at line 496 of file hdegree.cc.

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 }

◆ hIndep()

static void hIndep ( scmon  pure)
static

Definition at line 296 of file hdegree.cc.

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 }

◆ hIndMult()

void hIndMult ( scmon  pure,
int  Npure,
scfmon  rad,
int  Nrad,
varset  var,
int  Nvar 
)

Definition at line 313 of file hdegree.cc.

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 }

◆ hIndSolve()

static void hIndSolve ( scmon  pure,
int  Npure,
scfmon  rad,
int  Nrad,
varset  var,
int  Nvar 
)
static

Definition at line 133 of file hdegree.cc.

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 }

◆ hNotZero()

static BOOLEAN hNotZero ( scfmon  rad,
int  Nrad,
varset  var,
int  Nvar 
)
static

Definition at line 281 of file hdegree.cc.

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 }

◆ hProject()

static void hProject ( scmon  pure,
varset  sel 
)
static

Definition at line 599 of file hdegree.cc.

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 }

◆ hZeroMult()

static int hZeroMult ( scmon  pure,
scfmon  stc,
int  Nstc,
varset  var,
int  Nvar 
)
static

Definition at line 553 of file hdegree.cc.

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 }

◆ scAll()

static void scAll ( int  Nvar,
int  deg 
)
static

Definition at line 1164 of file hdegree.cc.

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 }

◆ scAllKbase()

static void scAllKbase ( int  Nvar,
int  ideg,
int  deg 
)
static

Definition at line 1188 of file hdegree.cc.

1189 {
1190  do
1191  {
1192  act[Nvar] = ideg;
1193  scAll(Nvar-1, deg-ideg);
1194  ideg--;
1195  } while (ideg >= 0);
1196 }

◆ scComputeHC()

void scComputeHC ( ideal  S,
ideal  Q,
int  ak,
poly &  hEdge,
ring  tailRing 
)

Definition at line 1005 of file hdegree.cc.

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 }

◆ scDegKbase()

static void scDegKbase ( scfmon  stc,
int  Nstc,
int  Nvar,
int  deg 
)
static

Definition at line 1198 of file hdegree.cc.

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 }

◆ scDegree()

void scDegree ( ideal  S,
intvec modulweight,
ideal  Q 
)

Definition at line 822 of file hdegree.cc.

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 }

◆ scDimInt()

int scDimInt ( ideal  S,
ideal  Q 
)

Definition at line 72 of file hdegree.cc.

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 }

◆ scElKbase()

static void scElKbase ( )
static

Definition at line 1080 of file hdegree.cc.

1081 {
1082  poly q = pInit();
1083  pSetCoeff0(q,nInit(1));
1084  pSetExpV(q,act);
1085  pNext(q) = NULL;
1086  last = pNext(last) = q;
1087 }

◆ scIdKbase()

static ideal scIdKbase ( poly  q,
const int  rank 
)
static

Definition at line 1335 of file hdegree.cc.

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 }

◆ scIndIntvec()

intvec* scIndIntvec ( ideal  S,
ideal  Q 
)

Definition at line 212 of file hdegree.cc.

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 }

◆ scInKbase()

static void scInKbase ( scfmon  stc,
int  Nstc,
int  Nvar 
)
static

Definition at line 1279 of file hdegree.cc.

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 }

◆ scKBase()

ideal scKBase ( int  deg,
ideal  s,
ideal  Q,
intvec mv 
)

Definition at line 1353 of file hdegree.cc.

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 }

◆ scMax()

static int scMax ( int  i,
scfmon  stc,
int  Nvar 
)
static

Definition at line 1089 of file hdegree.cc.

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 }

◆ scMin()

static int scMin ( int  i,
scfmon  stc,
int  Nvar 
)
static

Definition at line 1101 of file hdegree.cc.

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 }

◆ scMult0Int()

int scMult0Int ( ideal  S,
ideal  Q,
const ring  tailRing 
)

Definition at line 919 of file hdegree.cc.

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 }

◆ scMultInt()

int scMultInt ( ideal  S,
ideal  Q 
)

Definition at line 799 of file hdegree.cc.

800 {
801  id_Test(S, currRing);
802  if( Q!=NULL ) id_Test(Q, currRing);
803 
804  hDegree(S, Q);
805  return hMu;
806 }

◆ scPrintDegree()

void scPrintDegree ( int  co,
int  mu 
)

Definition at line 808 of file hdegree.cc.

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 }

◆ scRestrict()

static int scRestrict ( int &  Nstc,
scfmon  stc,
int  Nvar 
)
static

Definition at line 1113 of file hdegree.cc.

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 }

Variable Documentation

◆ act

scmon act
static

Definition at line 1078 of file hdegree.cc.

◆ hCo

int hCo

Definition at line 22 of file hdegree.cc.

◆ hInd

scmon hInd
static

Definition at line 131 of file hdegree.cc.

◆ hMu

int hMu

Definition at line 22 of file hdegree.cc.

◆ hMu2

int hMu2

Definition at line 22 of file hdegree.cc.

◆ indlist_bin

omBin indlist_bin = omGetSpecBin(sizeof(indlist))

Definition at line 23 of file hdegree.cc.

◆ ISet

indset ISet

Definition at line 279 of file hdegree.cc.

◆ JSet

indset JSet

Definition at line 279 of file hdegree.cc.

◆ last

poly last
static

Definition at line 1077 of file hdegree.cc.

◆ pWork

poly pWork
static

Definition at line 931 of file hdegree.cc.

hStaircase
void hStaircase(scfmon stc, int *Nstc, varset var, int Nvar)
Definition: hutil.cc:319
FALSE
#define FALSE
Definition: auxiliary.h:94
idElem
int idElem(const ideal F)
count non-zero elements
Definition: simpleideals.cc:210
hIndMult
void hIndMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:313
hElimS
void hElimS(scfmon stc, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:678
hNotZero
static BOOLEAN hNotZero(scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:281
j
int j
Definition: facHensel.cc:105
hpur0
scmon hpur0
Definition: hutil.cc:20
k
int k
Definition: cfEzgcd.cc:92
pLmFree
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
hHedgeStep
static void hHedgeStep(scmon pure, scfmon stc, int Nstc, varset var, int Nvar, poly hEdge)
Definition: hdegree.cc:945
hIndSolve
static void hIndSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:133
x
Variable x
Definition: cfModGcd.cc:4023
y
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
scAllKbase
static void scAllKbase(int Nvar, int ideg, int deg)
Definition: hdegree.cc:1188
polyset
poly * polyset
Definition: polys.h:254
pGetExp
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
hRadical
void hRadical(scfmon rad, int *Nrad, int Nvar)
Definition: hutil.cc:417
scRestrict
static int scRestrict(int &Nstc, scfmon stc, int Nvar)
Definition: hdegree.cc:1113
hMu
int hMu
Definition: hdegree.cc:22
hNrad
int hNrad
Definition: hutil.cc:22
scIdKbase
static ideal scIdKbase(poly q, const int rank)
Definition: hdegree.cc:1335
indset
indlist * indset
Definition: hutil.h:28
omAlloc0Bin
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
hGetmem
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1029
scInKbase
static void scInKbase(scfmon stc, int Nstc, int Nvar)
Definition: hdegree.cc:1279
hDimSolve
void hDimSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:29
hexist
scfmon hexist
Definition: hutil.cc:19
scfmon
scmon * scfmon
Definition: hutil.h:15
loop
#define loop
Definition: structs.h:78
pSetComp
#define pSetComp(p, v)
Definition: polys.h:38
b
CanonicalForm b
Definition: cfModGcd.cc:4044
scDimInt
int scDimInt(ideal S, ideal Q)
Definition: hdegree.cc:72
hHedge
static void hHedge(poly hEdge)
Definition: hdegree.cc:933
mu
void mu(int **points, int sizePoints)
Definition: cfNewtonPolygon.cc:467
pLength
static unsigned pLength(poly a)
Definition: p_polys.h:193
hNexist
int hNexist
Definition: hutil.cc:22
scAll
static void scAll(int Nvar, int deg)
Definition: hdegree.cc:1164
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
hInd
static scmon hInd
Definition: hdegree.cc:131
scMin
static int scMin(int i, scfmon stc, int Nvar)
Definition: hdegree.cc:1101
TRUE
#define TRUE
Definition: auxiliary.h:98
i
int i
Definition: cfEzgcd.cc:125
res
CanonicalForm res
Definition: facAbsFact.cc:64
act
static scmon act
Definition: hdegree.cc:1078
indlist_bin
omBin indlist_bin
Definition: hdegree.cc:23
hZeroMult
static int hZeroMult(scmon pure, scfmon stc, int Nstc, varset var, int Nvar)
Definition: hdegree.cc:553
hpure
scmon hpure
Definition: hutil.cc:20
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
hCheckIndep
static void hCheckIndep(scmon pure)
Definition: hdegree.cc:472
hwork
scfmon hwork
Definition: hutil.cc:19
hvar
varset hvar
Definition: hutil.cc:21
hMu2
int hMu2
Definition: hdegree.cc:22
hDegree0
static void hDegree0(ideal S, ideal Q, const ring tailRing)
Definition: hdegree.cc:845
idSkipZeroes
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
Definition: simpleideals.cc:172
rField_is_Ring
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:475
hrad
scfmon hrad
Definition: hutil.cc:19
hComp
void hComp(scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
Definition: hutil.cc:160
hKill
void hKill(monf xmem, int Nvar)
Definition: hutil.cc:1016
pInit
#define pInit()
allocates a new monomial and initializes everything to 0
Definition: polys.h:61
hStepR
void hStepR(scfmon rad, int Nrad, varset var, int Nvar, int *a)
Definition: hutil.cc:980
intvec
Definition: intvec.h:17
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210
hDelete
void hDelete(scfmon ev, int ev_length)
Definition: hutil.cc:146
hStepS
void hStepS(scfmon stc, int Nstc, varset var, int Nvar, int *a, int *x)
Definition: hutil.cc:955
hCo
int hCo
Definition: hdegree.cc:22
hIndAllMult
void hIndAllMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:496
scmon
int * scmon
Definition: hutil.h:14
hLex2R
void hLex2R(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:886
scDegKbase
static void scDegKbase(scfmon stc, int Nstc, int Nvar, int deg)
Definition: hdegree.cc:1198
stcmem
monf stcmem
Definition: hutil.cc:24
last
static poly last
Definition: hdegree.cc:1077
hNpure
int hNpure
Definition: hutil.cc:22
hSecondSeries
intvec * hSecondSeries(intvec *hseries1)
Definition: hilb.cc:1346
scMax
static int scMax(int i, scfmon stc, int Nvar)
Definition: hdegree.cc:1089
hPure
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
hLex2S
void hLex2S(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:818
hstc
scfmon hstc
Definition: hutil.cc:19
p_IsPurePower
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
Definition: p_polys.cc:1218
varset
int * varset
Definition: hutil.h:16
p_Delete
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:858
hInit
scfmon hInit(ideal S, ideal Q, int *Nexist, ring tailRing)
Definition: hutil.cc:34
hFirstSeries
intvec * hFirstSeries(ideal S, intvec *modulweight, ideal Q, intvec *wdegree, ring tailRing)
Definition: hilb.cc:1336
hNvar
int hNvar
Definition: hutil.cc:22
hDegree
static void hDegree(ideal S, ideal Q)
Definition: hdegree.cc:698
hCheck2
static indset hCheck2(indset sm, scmon pure)
Definition: hdegree.cc:420
hOrdSupp
void hOrdSupp(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:208
Print
#define Print
Definition: emacs.cc:80
hSupp
void hSupp(scfmon stc, int Nstc, varset var, int *Nvar)
Definition: hutil.cc:180
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:37
id_TestTail
#define id_TestTail(A, lR, tR)
Definition: simpleideals.h:79
pSetCoeff0
#define pSetCoeff0(p, n)
Definition: monomials.h:60
JSet
indset JSet
Definition: hdegree.cc:279
hProject
static void hProject(scmon pure, varset sel)
Definition: hdegree.cc:599
assume
#define assume(x)
Definition: mod2.h:390
hisModule
int hisModule
Definition: hutil.cc:23
NULL
#define NULL
Definition: omList.c:10
pSetm
#define pSetm(p)
Definition: polys.h:265
pWork
static poly pWork
Definition: hdegree.cc:931
hGetpure
scmon hGetpure(scmon p)
Definition: hutil.cc:1058
pSetExpV
#define pSetExpV(p, e)
Definition: polys.h:97
l
int l
Definition: cfEzgcd.cc:93
hCheck1
static BOOLEAN hCheck1(indset sm, scmon pure)
Definition: hdegree.cc:394
scElKbase
static void scElKbase()
Definition: hdegree.cc:1080
pSetExp
#define pSetExp(p, i, v)
Definition: polys.h:42
ISet
indset ISet
Definition: hdegree.cc:279
hElimR
void hElimR(scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:748
p
int p
Definition: cfModGcd.cc:4019
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
nInit
#define nInit(i)
Definition: numbers.h:25
pLmCmp
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
hDegreeSeries
void hDegreeSeries(intvec *s1, intvec *s2, int *co, int *mu)
Definition: hilb.cc:1381
Q
#define Q
Definition: sirandom.c:25
id_Copy
ideal id_Copy(ideal h1, const ring r)
copy an ideal
Definition: simpleideals.cc:404
radmem
monf radmem
Definition: hutil.cc:24
pGetCoeff
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
hNstc
int hNstc
Definition: hutil.cc:22
hsel
varset hsel
Definition: hutil.cc:21
intvec::length
int length() const
Definition: intvec.h:94
scPrintDegree
void scPrintDegree(int co, int mu)
Definition: hdegree.cc:808
id_Test
#define id_Test(A, lR)
Definition: simpleideals.h:80
omFreeBin
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
hLexR
void hLexR(scfmon rad, int Nrad, varset var, int Nvar)
Definition: hutil.cc:571
n_IsUnit
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
pNext
#define pNext(p)
Definition: monomials.h:37
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:211
MAX_INT_VAL
const int MAX_INT_VAL
Definition: mylimits.h:12
hLexS
void hLexS(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:512
hCreate
monf hCreate(int Nvar)
Definition: hutil.cc:1002
pWrite
void pWrite(poly p)
Definition: polys.h:302
hDimMult
static void hDimMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:622
hIndep
static void hIndep(scmon pure)
Definition: hdegree.cc:296