My Project  debian-1:4.1.2-p1+ds-2
Functions | Variables
hdegree.cc File Reference
#include "kernel/mod2.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

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

Function Documentation

◆ hCheck1()

static BOOLEAN hCheck1 ( indset  sm,
scmon  pure 
)
static

Definition at line 393 of file hdegree.cc.

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 }

◆ hCheck2()

static indset hCheck2 ( indset  sm,
scmon  pure 
)
static

Definition at line 419 of file hdegree.cc.

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 }

◆ hCheckIndep()

static void hCheckIndep ( scmon  pure)
static

Definition at line 471 of file hdegree.cc.

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 }

◆ hDegree()

static void hDegree ( ideal  S,
ideal  Q 
)
static

Definition at line 697 of file hdegree.cc.

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 }

◆ hDegree0()

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

Definition at line 844 of file hdegree.cc.

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 }

◆ hDimMult()

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

Definition at line 621 of file hdegree.cc.

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 }

◆ hDimSolve()

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

Definition at line 28 of file hdegree.cc.

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 }

◆ hHedge()

static void hHedge ( poly  hEdge)
static

Definition at line 932 of file hdegree.cc.

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 }

◆ hHedgeStep()

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

Definition at line 944 of file hdegree.cc.

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 }

◆ hIndAllMult()

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

Definition at line 495 of file hdegree.cc.

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 }

◆ hIndep()

static void hIndep ( scmon  pure)
static

Definition at line 295 of file hdegree.cc.

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  }
309  hMu++;
310 }

◆ hIndMult()

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

Definition at line 312 of file hdegree.cc.

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 }

◆ hIndSolve()

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

Definition at line 132 of file hdegree.cc.

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 }

◆ hNotZero()

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

Definition at line 280 of file hdegree.cc.

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 }

◆ hProject()

static void hProject ( scmon  pure,
varset  sel 
)
static

Definition at line 598 of file hdegree.cc.

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 }

◆ hZeroMult()

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

Definition at line 552 of file hdegree.cc.

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 }

◆ scAll()

static void scAll ( int  Nvar,
int  deg 
)
static

Definition at line 1163 of file hdegree.cc.

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 }

◆ scAllKbase()

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

Definition at line 1187 of file hdegree.cc.

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

◆ scComputeHC()

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

Definition at line 1004 of file hdegree.cc.

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;
1053  if ((hNvar > 2) && (hNstc > 10))
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 }

◆ scDegKbase()

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

Definition at line 1197 of file hdegree.cc.

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 }

◆ scDegree()

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

Definition at line 821 of file hdegree.cc.

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 }

◆ scDimInt()

int scDimInt ( ideal  S,
ideal  Q 
)

Definition at line 71 of file hdegree.cc.

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 }

◆ scElKbase()

static void scElKbase ( )
static

Definition at line 1079 of file hdegree.cc.

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

◆ scIdKbase()

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

Definition at line 1334 of file hdegree.cc.

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 }

◆ scIndIntvec()

intvec* scIndIntvec ( ideal  S,
ideal  Q 
)

Definition at line 211 of file hdegree.cc.

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 }

◆ scInKbase()

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

Definition at line 1278 of file hdegree.cc.

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 }

◆ scKBase()

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

Definition at line 1352 of file hdegree.cc.

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 }

◆ scMax()

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

Definition at line 1088 of file hdegree.cc.

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 }

◆ scMin()

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

Definition at line 1100 of file hdegree.cc.

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 }

◆ scMult0Int()

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

Definition at line 918 of file hdegree.cc.

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 }

◆ scMultInt()

int scMultInt ( ideal  S,
ideal  Q 
)

Definition at line 798 of file hdegree.cc.

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

◆ scPrintDegree()

void scPrintDegree ( int  co,
int  mu 
)

Definition at line 807 of file hdegree.cc.

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 }

◆ scRestrict()

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

Definition at line 1112 of file hdegree.cc.

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 }

Variable Documentation

◆ act

Definition at line 1077 of file hdegree.cc.

◆ hCo

VAR int hCo

Definition at line 21 of file hdegree.cc.

◆ hInd

Definition at line 130 of file hdegree.cc.

◆ hMu

VAR int hMu

Definition at line 21 of file hdegree.cc.

◆ hMu2

VAR int hMu2

Definition at line 21 of file hdegree.cc.

◆ indlist_bin

VAR omBin indlist_bin = omGetSpecBin(sizeof(indlist))

Definition at line 22 of file hdegree.cc.

◆ ISet

VAR indset ISet

Definition at line 278 of file hdegree.cc.

◆ JSet

VAR indset JSet

Definition at line 278 of file hdegree.cc.

◆ last

STATIC_VAR poly last

Definition at line 1076 of file hdegree.cc.

◆ pWork

STATIC_VAR poly pWork

Definition at line 930 of file hdegree.cc.

hStaircase
void hStaircase(scfmon stc, int *Nstc, varset var, int Nvar)
Definition: hutil.cc:315
indlist_bin
VAR omBin indlist_bin
Definition: hdegree.cc:22
FALSE
#define FALSE
Definition: auxiliary.h:96
idElem
int idElem(const ideal F)
count non-zero elements
Definition: simpleideals.cc:218
hIndMult
void hIndMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:312
hElimS
void hElimS(scfmon stc, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:674
hvar
VAR varset hvar
Definition: hutil.cc:17
hexist
VAR scfmon hexist
Definition: hutil.cc:15
hpur0
VAR scmon hpur0
Definition: hutil.cc:16
hNotZero
static BOOLEAN hNotZero(scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:280
j
int j
Definition: facHensel.cc:105
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:68
hHedgeStep
static void hHedgeStep(scmon pure, scfmon stc, int Nstc, varset var, int Nvar, poly hEdge)
Definition: hdegree.cc:944
hpure
VAR scmon hpure
Definition: hutil.cc:16
hNrad
VAR int hNrad
Definition: hutil.cc:18
hIndSolve
static void hIndSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:132
x
Variable x
Definition: cfModGcd.cc:4023
last
STATIC_VAR poly last
Definition: hdegree.cc:1076
y
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
hMu
VAR int hMu
Definition: hdegree.cc:21
scAllKbase
static void scAllKbase(int Nvar, int ideg, int deg)
Definition: hdegree.cc:1187
polyset
poly * polyset
Definition: polys.h:244
pGetExp
#define pGetExp(p, i)
Exponent.
Definition: polys.h:40
ADDRESS
void * ADDRESS
Definition: auxiliary.h:135
hRadical
void hRadical(scfmon rad, int *Nrad, int Nvar)
Definition: hutil.cc:413
scRestrict
static int scRestrict(int &Nstc, scfmon stc, int Nvar)
Definition: hdegree.cc:1112
hNexist
VAR int hNexist
Definition: hutil.cc:18
scIdKbase
static ideal scIdKbase(poly q, const int rank)
Definition: hdegree.cc:1334
indset
indlist * indset
Definition: hutil.h:27
omAlloc0Bin
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:204
hGetmem
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1025
scInKbase
static void scInKbase(scfmon stc, int Nstc, int Nvar)
Definition: hdegree.cc:1278
hDimSolve
void hDimSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:28
scfmon
scmon * scfmon
Definition: hutil.h:14
loop
#define loop
Definition: structs.h:79
pSetComp
#define pSetComp(p, v)
Definition: polys.h:37
b
CanonicalForm b
Definition: cfModGcd.cc:4044
scDimInt
int scDimInt(ideal S, ideal Q)
Definition: hdegree.cc:71
hHedge
static void hHedge(poly hEdge)
Definition: hdegree.cc:932
hNvar
VAR int hNvar
Definition: hutil.cc:18
mu
void mu(int **points, int sizePoints)
Definition: cfNewtonPolygon.cc:467
pLength
static unsigned pLength(poly a)
Definition: p_polys.h:182
hMu2
VAR int hMu2
Definition: hdegree.cc:21
pWork
STATIC_VAR poly pWork
Definition: hdegree.cc:930
hCo
VAR int hCo
Definition: hdegree.cc:21
scAll
static void scAll(int Nvar, int deg)
Definition: hdegree.cc:1163
hInd
STATIC_VAR scmon hInd
Definition: hdegree.cc:130
scMin
static int scMin(int i, scfmon stc, int Nvar)
Definition: hdegree.cc:1100
hNstc
VAR int hNstc
Definition: hutil.cc:18
TRUE
#define TRUE
Definition: auxiliary.h:100
i
int i
Definition: cfEzgcd.cc:125
res
CanonicalForm res
Definition: facAbsFact.cc:64
hZeroMult
static int hZeroMult(scmon pure, scfmon stc, int Nstc, varset var, int Nvar)
Definition: hdegree.cc:552
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:258
hCheckIndep
static void hCheckIndep(scmon pure)
Definition: hdegree.cc:471
hDegree0
static void hDegree0(ideal S, ideal Q, const ring tailRing)
Definition: hdegree.cc:844
idSkipZeroes
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
Definition: simpleideals.cc:180
rField_is_Ring
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:478
hsel
VAR varset hsel
Definition: hutil.cc:17
hComp
void hComp(scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
Definition: hutil.cc:156
hKill
void hKill(monf xmem, int Nvar)
Definition: hutil.cc:1012
pInit
#define pInit()
allocates a new monomial and initializes everything to 0
Definition: polys.h:59
hStepR
void hStepR(scfmon rad, int Nrad, varset var, int Nvar, int *a)
Definition: hutil.cc:976
intvec
Definition: intvec.h:18
Q
STATIC_VAR jList * Q
Definition: janet.cc:30
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
hDelete
void hDelete(scfmon ev, int ev_length)
Definition: hutil.cc:142
hStepS
void hStepS(scfmon stc, int Nstc, varset var, int Nvar, int *a, int *x)
Definition: hutil.cc:951
hrad
VAR scfmon hrad
Definition: hutil.cc:15
hIndAllMult
void hIndAllMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:495
scmon
int * scmon
Definition: hutil.h:13
hLex2R
void hLex2R(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:882
scDegKbase
static void scDegKbase(scfmon stc, int Nstc, int Nvar, int deg)
Definition: hdegree.cc:1197
radmem
VAR monf radmem
Definition: hutil.cc:20
JSet
VAR indset JSet
Definition: hdegree.cc:278
hstc
VAR scfmon hstc
Definition: hutil.cc:15
hSecondSeries
intvec * hSecondSeries(intvec *hseries1)
Definition: hilb.cc:1345
hisModule
VAR int hisModule
Definition: hutil.cc:19
scMax
static int scMax(int i, scfmon stc, int Nvar)
Definition: hdegree.cc:1088
hPure
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:623
hLex2S
void hLex2S(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:814
ISet
VAR indset ISet
Definition: hdegree.cc:278
p_IsPurePower
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
Definition: p_polys.cc:1213
varset
int * varset
Definition: hutil.h:15
p_Delete
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:845
hInit
scfmon hInit(ideal S, ideal Q, int *Nexist, ring tailRing)
Definition: hutil.cc:30
stcmem
VAR monf stcmem
Definition: hutil.cc:20
hFirstSeries
intvec * hFirstSeries(ideal S, intvec *modulweight, ideal Q, intvec *wdegree, ring tailRing)
Definition: hilb.cc:1335
hDegree
static void hDegree(ideal S, ideal Q)
Definition: hdegree.cc:697
hCheck2
static indset hCheck2(indset sm, scmon pure)
Definition: hdegree.cc:419
hOrdSupp
void hOrdSupp(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:204
Print
#define Print
Definition: emacs.cc:79
hSupp
void hSupp(scfmon stc, int Nstc, varset var, int *Nvar)
Definition: hutil.cc:176
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:34
id_TestTail
#define id_TestTail(A, lR, tR)
Definition: simpleideals.h:77
pSetCoeff0
#define pSetCoeff0(p, n)
Definition: monomials.h:56
act
STATIC_VAR scmon act
Definition: hdegree.cc:1077
hProject
static void hProject(scmon pure, varset sel)
Definition: hdegree.cc:598
assume
#define assume(x)
Definition: mod2.h:384
NULL
#define NULL
Definition: omList.c:11
pSetm
#define pSetm(p)
Definition: polys.h:256
hGetpure
scmon hGetpure(scmon p)
Definition: hutil.cc:1054
pSetExpV
#define pSetExpV(p, e)
Definition: polys.h:94
l
int l
Definition: cfEzgcd.cc:93
hCheck1
static BOOLEAN hCheck1(indset sm, scmon pure)
Definition: hdegree.cc:393
scElKbase
static void scElKbase()
Definition: hdegree.cc:1079
hwork
VAR scfmon hwork
Definition: hutil.cc:15
pSetExp
#define pSetExp(p, i, v)
Definition: polys.h:41
hElimR
void hElimR(scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:744
p
int p
Definition: cfModGcd.cc:4019
currRing
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
nInit
#define nInit(i)
Definition: numbers.h:23
pLmCmp
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:101
hDegreeSeries
void hDegreeSeries(intvec *s1, intvec *s2, int *co, int *mu)
Definition: hilb.cc:1380
id_Copy
ideal id_Copy(ideal h1, const ring r)
copy an ideal
Definition: simpleideals.cc:412
hNpure
VAR int hNpure
Definition: hutil.cc:18
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:41
intvec::length
int length() const
Definition: intvec.h:94
scPrintDegree
void scPrintDegree(int co, int mu)
Definition: hdegree.cc:807
id_Test
#define id_Test(A, lR)
Definition: simpleideals.h:78
omFreeBin
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:257
hLexR
void hLexR(scfmon rad, int Nrad, varset var, int Nvar)
Definition: hutil.cc:567
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:514
pNext
#define pNext(p)
Definition: monomials.h:33
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:209
MAX_INT_VAL
const int MAX_INT_VAL
Definition: mylimits.h:11
hLexS
void hLexS(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:508
hCreate
monf hCreate(int Nvar)
Definition: hutil.cc:998
pWrite
void pWrite(poly p)
Definition: polys.h:292
hDimMult
static void hDimMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:621
hIndep
static void hIndep(scmon pure)
Definition: hdegree.cc:295