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

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 }
loop
Definition: myNF.cc:98
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
Definition: intvec.h:16
#define NULL
Definition: omList.c:10
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 }
int hMu2
Definition: hdegree.cc:22
loop
Definition: myNF.cc:98
void * ADDRESS
Definition: auxiliary.h:161
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
Definition: intvec.h:16
indlist * indset
Definition: hutil.h:35
omBin indlist_bin
Definition: hdegree.cc:23
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
#define NULL
Definition: omList.c:10
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
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 }
static indset hCheck2(indset sm, scmon pure)
Definition: hdegree.cc:420
poly res
Definition: myNF.cc:322
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
indset ISet
Definition: hdegree.cc:279
Definition: intvec.h:16
indlist * indset
Definition: hutil.h:35
indset JSet
Definition: hdegree.cc:279
static BOOLEAN hCheck1(indset sm, scmon pure)
Definition: hdegree.cc:394
#define NULL
Definition: omList.c:10
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 }
int hNstc
Definition: hutil.cc:22
void hLexS(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:512
void hDimSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:29
scfmon hwork
Definition: hutil.cc:19
int hNexist
Definition: hutil.cc:22
int * varset
Definition: hutil.h:23
int hCo
Definition: hdegree.cc:22
loop
Definition: myNF.cc:98
#define id_Test(A, lR)
Definition: simpleideals.h:80
scmon * scfmon
Definition: hutil.h:22
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
scfmon hexist
Definition: hutil.cc:19
monf hCreate(int Nvar)
Definition: hutil.cc:1002
int hNvar
Definition: hutil.cc:22
void * ADDRESS
Definition: auxiliary.h:161
int hNrad
Definition: hutil.cc:22
int hNpure
Definition: hutil.cc:22
scmon hpure
Definition: hutil.cc:20
#define Q
Definition: sirandom.c:25
void hRadical(scfmon rad, int *Nrad, int Nvar)
Definition: hutil.cc:417
#define omAlloc(size)
Definition: omAllocDecl.h:210
scfmon hrad
Definition: hutil.cc:19
void hDelete(scfmon ev, int ev_length)
Definition: hutil.cc:146
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
void hOrdSupp(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:208
void hKill(monf xmem, int Nvar)
Definition: hutil.cc:1016
varset hvar
Definition: hutil.cc:21
static void hDimMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:622
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
void hStaircase(scfmon stc, int *Nstc, varset var, int Nvar)
Definition: hutil.cc:319
int * scmon
Definition: hutil.h:21
void hLexR(scfmon rad, int Nrad, varset var, int Nvar)
Definition: hutil.cc:571
#define NULL
Definition: omList.c:10
varset hsel
Definition: hutil.cc:21
monf stcmem
Definition: hutil.cc:24
monf radmem
Definition: hutil.cc:24
int hisModule
Definition: hutil.cc:23
scfmon hstc
Definition: hutil.cc:19
scmon hpur0
Definition: hutil.cc:20
void hComp(scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
Definition: hutil.cc:160
scfmon hInit(ideal S, ideal Q, int *Nexist, ring tailRing)
Definition: hutil.cc:34
int hMu
Definition: hdegree.cc:22
static int hZeroMult(scmon pure, scfmon stc, int Nstc, varset var, int Nvar)
Definition: hdegree.cc:553
void hSupp(scfmon stc, int Nstc, varset var, int *Nvar)
Definition: hutil.cc:180
static void hDegree0 ( ideal  S,
ideal  Q,
const ring  tailRing 
)
static

Definition at line 845 of file hdegree.cc.

846 {
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 }
#define id_TestTail(A, lR, tR)
Definition: simpleideals.h:79
int hNstc
Definition: hutil.cc:22
void hLexS(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:512
scfmon hwork
Definition: hutil.cc:19
int hNexist
Definition: hutil.cc:22
int * varset
Definition: hutil.h:23
loop
Definition: myNF.cc:98
scmon * scfmon
Definition: hutil.h:22
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
scfmon hexist
Definition: hutil.cc:19
monf hCreate(int Nvar)
Definition: hutil.cc:1002
int hNvar
Definition: hutil.cc:22
void * ADDRESS
Definition: auxiliary.h:161
int hNpure
Definition: hutil.cc:22
#define Q
Definition: sirandom.c:25
#define omAlloc(size)
Definition: omAllocDecl.h:210
void hDelete(scfmon ev, int ev_length)
Definition: hutil.cc:146
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
const ring r
Definition: syzextra.cc:208
void hOrdSupp(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:208
void hKill(monf xmem, int Nvar)
Definition: hutil.cc:1016
varset hvar
Definition: hutil.cc:21
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
void hStaircase(scfmon stc, int *Nstc, varset var, int Nvar)
Definition: hutil.cc:319
int * scmon
Definition: hutil.h:21
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
monf stcmem
Definition: hutil.cc:24
int hisModule
Definition: hutil.cc:23
scfmon hstc
Definition: hutil.cc:19
scmon hpur0
Definition: hutil.cc:20
void hComp(scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
Definition: hutil.cc:160
scfmon hInit(ideal S, ideal Q, int *Nexist, ring tailRing)
Definition: hutil.cc:34
int hMu
Definition: hdegree.cc:22
static int hZeroMult(scmon pure, scfmon stc, int Nstc, varset var, int Nvar)
Definition: hdegree.cc:553
void hSupp(scfmon stc, int Nstc, varset var, int *Nvar)
Definition: hutil.cc:180
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 }
void hElimR(scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:748
scfmon hwork
Definition: hutil.cc:19
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1029
int hCo
Definition: hdegree.cc:22
loop
Definition: myNF.cc:98
scmon hGetpure(scmon p)
Definition: hutil.cc:1058
scmon * scfmon
Definition: hutil.h:22
static void hProject(scmon pure, varset sel)
Definition: hdegree.cc:599
static BOOLEAN hNotZero(scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:281
void hStepR(scfmon rad, int Nrad, varset var, int Nvar, int *a)
Definition: hutil.cc:980
static void hDimMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:622
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
int * scmon
Definition: hutil.h:21
void hLex2R(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:886
varset hsel
Definition: hutil.cc:21
monf radmem
Definition: hutil.cc:24
Variable x
Definition: cfModGcd.cc:4023
const poly b
Definition: syzextra.cc:213
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 }
void hDimSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:29
void hElimR(scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:748
scfmon hwork
Definition: hutil.cc:19
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1029
int hCo
Definition: hdegree.cc:22
scmon hGetpure(scmon p)
Definition: hutil.cc:1058
scmon * scfmon
Definition: hutil.h:22
void hStepR(scfmon rad, int Nrad, varset var, int Nvar, int *a)
Definition: hutil.cc:980
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
int * scmon
Definition: hutil.h:21
void hLex2R(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:886
monf radmem
Definition: hutil.cc:24
Variable x
Definition: cfModGcd.cc:4023
const poly b
Definition: syzextra.cc:213
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 }
#define pSetm(p)
Definition: polys.h:241
#define pSetExp(p, i, v)
Definition: polys.h:42
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p
Definition: polys.h:105
static poly pWork
Definition: hdegree.cc:931
int hNvar
Definition: hutil.cc:22
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
int i
Definition: cfEzgcd.cc:123
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 }
const poly a
Definition: syzextra.cc:212
scfmon hwork
Definition: hutil.cc:19
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1029
void hElimS(scfmon stc, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:678
loop
Definition: myNF.cc:98
#define pSetExp(p, i, v)
Definition: polys.h:42
scmon hGetpure(scmon p)
Definition: hutil.cc:1058
scmon * scfmon
Definition: hutil.h:22
static poly pWork
Definition: hdegree.cc:931
int k
Definition: cfEzgcd.cc:93
static void hHedge(poly hEdge)
Definition: hdegree.cc:933
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
static void hHedgeStep(scmon pure, scfmon stc, int Nstc, varset var, int Nvar, poly hEdge)
Definition: hdegree.cc:945
int * scmon
Definition: hutil.h:21
int i
Definition: cfEzgcd.cc:123
void hLex2S(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:818
monf stcmem
Definition: hutil.cc:24
void hStepS(scfmon stc, int Nstc, varset var, int Nvar, int *a, int *x)
Definition: hutil.cc:955
Variable x
Definition: cfModGcd.cc:4023
const poly b
Definition: syzextra.cc:213
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 }
void hElimR(scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:748
scfmon hwork
Definition: hutil.cc:19
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1029
void hIndAllMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:496
int hCo
Definition: hdegree.cc:22
scmon hGetpure(scmon p)
Definition: hutil.cc:1058
scmon * scfmon
Definition: hutil.h:22
static void hCheckIndep(scmon pure)
Definition: hdegree.cc:472
void hStepR(scfmon rad, int Nrad, varset var, int Nvar, int *a)
Definition: hutil.cc:980
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
int * scmon
Definition: hutil.h:21
void hLex2R(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:886
monf radmem
Definition: hutil.cc:24
Variable x
Definition: cfModGcd.cc:4023
const poly b
Definition: syzextra.cc:213
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 }
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
indset ISet
Definition: hdegree.cc:279
Definition: intvec.h:16
indlist * indset
Definition: hutil.h:35
omBin indlist_bin
Definition: hdegree.cc:23
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
int hMu
Definition: hdegree.cc:22
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 }
void hElimR(scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:748
scfmon hwork
Definition: hutil.cc:19
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1029
int hCo
Definition: hdegree.cc:22
loop
Definition: myNF.cc:98
scmon hGetpure(scmon p)
Definition: hutil.cc:1058
scmon * scfmon
Definition: hutil.h:22
static BOOLEAN hNotZero(scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:281
void hStepR(scfmon rad, int Nrad, varset var, int Nvar, int *a)
Definition: hutil.cc:980
static void hIndep(scmon pure)
Definition: hdegree.cc:296
void hIndMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:313
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
int * scmon
Definition: hutil.h:21
void hLex2R(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:886
monf radmem
Definition: hutil.cc:24
Variable x
Definition: cfModGcd.cc:4023
const poly b
Definition: syzextra.cc:213
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 }
void hElimR(scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:748
scfmon hwork
Definition: hutil.cc:19
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1029
int hCo
Definition: hdegree.cc:22
loop
Definition: myNF.cc:98
scmon hGetpure(scmon p)
Definition: hutil.cc:1058
scmon * scfmon
Definition: hutil.h:22
void hStepR(scfmon rad, int Nrad, varset var, int Nvar, int *a)
Definition: hutil.cc:980
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
int * scmon
Definition: hutil.h:21
void hLex2R(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:886
monf radmem
Definition: hutil.cc:24
Variable x
Definition: cfModGcd.cc:4023
static void hIndSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:133
static scmon hInd
Definition: hdegree.cc:131
const poly b
Definition: syzextra.cc:213
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 }
loop
Definition: myNF.cc:98
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
int i
Definition: cfEzgcd.cc:123
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 }
int hNstc
Definition: hutil.cc:22
void hLexS(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:512
scfmon hwork
Definition: hutil.cc:19
int k
Definition: cfEzgcd.cc:93
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
void hOrdSupp(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:208
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
void hStaircase(scfmon stc, int *Nstc, varset var, int Nvar)
Definition: hutil.cc:319
int * scmon
Definition: hutil.h:21
int i
Definition: cfEzgcd.cc:123
scfmon hstc
Definition: hutil.cc:19
scmon hpur0
Definition: hutil.cc:20
int hMu
Definition: hdegree.cc:22
static int hZeroMult(scmon pure, scfmon stc, int Nstc, varset var, int Nvar)
Definition: hdegree.cc:553
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 }
const poly a
Definition: syzextra.cc:212
scfmon hwork
Definition: hutil.cc:19
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1029
void hElimS(scfmon stc, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:678
loop
Definition: myNF.cc:98
scmon hGetpure(scmon p)
Definition: hutil.cc:1058
scmon * scfmon
Definition: hutil.h:22
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
int * scmon
Definition: hutil.h:21
int i
Definition: cfEzgcd.cc:123
void hLex2S(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:818
monf stcmem
Definition: hutil.cc:24
void hStepS(scfmon stc, int Nstc, varset var, int Nvar, int *a, int *x)
Definition: hutil.cc:955
Variable x
Definition: cfModGcd.cc:4023
const poly b
Definition: syzextra.cc:213
static int hZeroMult(scmon pure, scfmon stc, int Nstc, varset var, int Nvar)
Definition: hdegree.cc:553
static void scAll ( int  Nvar,
int  deg 
)
static

Definition at line 1162 of file hdegree.cc.

1163 {
1164  int i;
1165  int d = deg;
1166  if (d == 0)
1167  {
1168  for (i=Nvar; i; i--) act[i] = 0;
1169  scElKbase();
1170  return;
1171  }
1172  if (Nvar == 1)
1173  {
1174  act[1] = d;
1175  scElKbase();
1176  return;
1177  }
1178  do
1179  {
1180  act[Nvar] = d;
1181  scAll(Nvar-1, deg-d);
1182  d--;
1183  } while (d >= 0);
1184 }
int i
Definition: cfEzgcd.cc:123
static void scElKbase()
Definition: hdegree.cc:1078
static scmon act
Definition: hdegree.cc:1076
static void scAll(int Nvar, int deg)
Definition: hdegree.cc:1162
static void scAllKbase ( int  Nvar,
int  ideg,
int  deg 
)
static

Definition at line 1186 of file hdegree.cc.

1187 {
1188  do
1189  {
1190  act[Nvar] = ideg;
1191  scAll(Nvar-1, deg-ideg);
1192  ideg--;
1193  } while (ideg >= 0);
1194 }
static scmon act
Definition: hdegree.cc:1076
static void scAll(int Nvar, int deg)
Definition: hdegree.cc:1162
void scComputeHC ( ideal  S,
ideal  Q,
int  ak,
poly hEdge,
ring  tailRing 
)

Definition at line 1005 of file hdegree.cc.

1006 {
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(p_IsPurePower(SS->m[i],tailRing)==0)
1020  {
1021  p_Delete(&SS->m[i],tailRing);
1022  }
1023  }
1024  S=id_Copy(SS,tailRing);
1025  idSkipZeroes(S);
1026  }
1027  #if 0
1028  printf("\nThis is HC:\n");
1029  for(int ii=0;ii<=idElem(S);ii++)
1030  {
1031  pWrite(S->m[ii]);
1032  }
1033  //getchar();
1034  #endif
1035  #endif
1036  if(idElem(S) == 0)
1037  return;
1038  hNvar = (currRing->N);
1039  hexist = hInit(S, Q, &hNexist, tailRing); // tailRing?
1040  if (k!=0)
1041  hComp(hexist, hNexist, k, hexist, &hNstc);
1042  else
1043  hNstc = hNexist;
1044  assume(hNexist > 0);
1045  hwork = (scfmon)omAlloc(hNexist * sizeof(scmon));
1046  hvar = (varset)omAlloc((hNvar + 1) * sizeof(int));
1047  hpure = (scmon)omAlloc((1 + (hNvar * hNvar)) * sizeof(int));
1048  stcmem = hCreate(hNvar - 1);
1049  for (i = hNvar; i>0; i--)
1050  hvar[i] = i;
1051  hStaircase(hexist, &hNstc, hvar, hNvar);
1052  if ((hNvar > 2) && (hNstc > 10))
1053  hOrdSupp(hexist, hNstc, hvar, hNvar);
1054  memset(hpure, 0, (hNvar + 1) * sizeof(int));
1055  hPure(hexist, 0, &hNstc, hvar, hNvar, hpure, &hNpure);
1056  hLexS(hexist, hNstc, hvar, hNvar);
1057  if (hEdge!=NULL)
1058  pLmFree(hEdge);
1059  hEdge = pInit();
1060  pWork = pInit();
1061  hHedgeStep(hpure, hexist, hNstc, hvar, hNvar,hEdge);
1062  pSetComp(hEdge,ak);
1063  hKill(stcmem, hNvar - 1);
1064  omFreeSize((ADDRESS)hwork, hNexist * sizeof(scmon));
1065  omFreeSize((ADDRESS)hvar, (hNvar + 1) * sizeof(int));
1066  omFreeSize((ADDRESS)hpure, (1 + (hNvar * hNvar)) * sizeof(int));
1068  pLmFree(pWork);
1069 }
#define id_TestTail(A, lR, tR)
Definition: simpleideals.h:79
int hNstc
Definition: hutil.cc:22
void hLexS(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:512
scfmon hwork
Definition: hutil.cc:19
int hNexist
Definition: hutil.cc:22
int * varset
Definition: hutil.h:23
ideal id_Copy(ideal h1, const ring r)
copy an ideal
scmon * scfmon
Definition: hutil.h:22
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
scfmon hexist
Definition: hutil.cc:19
static poly pWork
Definition: hdegree.cc:931
monf hCreate(int Nvar)
Definition: hutil.cc:1002
int hNvar
Definition: hutil.cc:22
void * ADDRESS
Definition: auxiliary.h:161
int hNpure
Definition: hutil.cc:22
void pWrite(poly p)
Definition: polys.h:279
scmon hpure
Definition: hutil.cc:20
int k
Definition: cfEzgcd.cc:93
#define Q
Definition: sirandom.c:25
#define omAlloc(size)
Definition: omAllocDecl.h:210
void hDelete(scfmon ev, int ev_length)
Definition: hutil.cc:146
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
void hOrdSupp(scfmon stc, int Nstc, varset var, int Nvar)
Definition: hutil.cc:208
void hKill(monf xmem, int Nvar)
Definition: hutil.cc:1016
varset hvar
Definition: hutil.cc:21
#define assume(x)
Definition: mod2.h:405
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
void hStaircase(scfmon stc, int *Nstc, varset var, int Nvar)
Definition: hutil.cc:319
#define pSetComp(p, v)
Definition: polys.h:38
static void hHedgeStep(scmon pure, scfmon stc, int Nstc, varset var, int Nvar, poly hEdge)
Definition: hdegree.cc:945
int * scmon
Definition: hutil.h:21
int i
Definition: cfEzgcd.cc:123
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:850
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
Definition: p_polys.cc:1224
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:437
#define NULL
Definition: omList.c:10
monf stcmem
Definition: hutil.cc:24
#define pInit()
allocates a new monomial and initializes everything to 0
Definition: polys.h:61
strat ak
Definition: myNF.cc:321
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
int idElem(const ideal F)
count non-zero elements
void hComp(scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
Definition: hutil.cc:160
scfmon hInit(ideal S, ideal Q, int *Nexist, ring tailRing)
Definition: hutil.cc:34
static void scDegKbase ( scfmon  stc,
int  Nstc,
int  Nvar,
int  deg 
)
static

Definition at line 1196 of file hdegree.cc.

1197 {
1198  int Ivar, Istc, i, j;
1199  scfmon sn;
1200  int x, ideg;
1201 
1202  if (deg == 0)
1203  {
1204  for (i=Nstc-1; i>=0; i--)
1205  {
1206  for (j=Nvar;j;j--){ if(stc[i][j]) break; }
1207  if (j==0){return;}
1208  }
1209  for (i=Nvar; i; i--) act[i] = 0;
1210  scElKbase();
1211  return;
1212  }
1213  if (Nvar == 1)
1214  {
1215  for (i=Nstc-1; i>=0; i--) if(deg >= stc[i][1]) return;
1216  act[1] = deg;
1217  scElKbase();
1218  return;
1219  }
1220  Ivar = Nvar-1;
1221  sn = hGetmem(Nstc, stc, stcmem[Ivar]);
1222  x = scRestrict(Nstc, sn, Nvar);
1223  if (x <= 0)
1224  {
1225  if (x == 0) return;
1226  ideg = deg;
1227  }
1228  else
1229  {
1230  if (deg < x) ideg = deg;
1231  else ideg = x-1;
1232  if (Nstc == 0)
1233  {
1234  scAllKbase(Nvar, ideg, deg);
1235  return;
1236  }
1237  }
1238  loop
1239  {
1240  x = scMax(Nstc, sn, Nvar);
1241  while (ideg >= x)
1242  {
1243  act[Nvar] = ideg;
1244  scDegKbase(sn, Nstc, Ivar, deg-ideg);
1245  ideg--;
1246  }
1247  if (ideg < 0) return;
1248  Istc = Nstc;
1249  for (i=Nstc-1; i>=0; i--)
1250  {
1251  if (ideg < sn[i][Nvar])
1252  {
1253  Istc--;
1254  sn[i] = NULL;
1255  }
1256  }
1257  if (Istc == 0)
1258  {
1259  scAllKbase(Nvar, ideg, deg);
1260  return;
1261  }
1262  j = 0;
1263  while (sn[j]) j++;
1264  i = j+1;
1265  for (; i<Nstc; i++)
1266  {
1267  if (sn[i])
1268  {
1269  sn[j] = sn[i];
1270  j++;
1271  }
1272  }
1273  Nstc = Istc;
1274  }
1275 }
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1029
loop
Definition: myNF.cc:98
scmon * scfmon
Definition: hutil.h:22
static void scDegKbase(scfmon stc, int Nstc, int Nvar, int deg)
Definition: hdegree.cc:1196
static void scAllKbase(int Nvar, int ideg, int deg)
Definition: hdegree.cc:1186
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
static int scRestrict(int &Nstc, scfmon stc, int Nvar)
Definition: hdegree.cc:1111
static void scElKbase()
Definition: hdegree.cc:1078
#define NULL
Definition: omList.c:10
monf stcmem
Definition: hutil.cc:24
Variable x
Definition: cfModGcd.cc:4023
static int scMax(int i, scfmon stc, int Nvar)
Definition: hdegree.cc:1087
static scmon act
Definition: hdegree.cc:1076
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 }
void mu(int **points, int sizePoints)
void scPrintDegree(int co, int mu)
Definition: hdegree.cc:808
#define id_Test(A, lR)
Definition: simpleideals.h:80
int length() const
Definition: intvec.h:86
void hDegreeSeries(intvec *s1, intvec *s2, int *co, int *mu)
Definition: hilb.cc:1341
#define Q
Definition: sirandom.c:25
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
Definition: intvec.h:16
#define NULL
Definition: omList.c:10
intvec * hSecondSeries(intvec *hseries1)
Definition: hilb.cc:1307
intvec * hFirstSeries(ideal S, intvec *modulweight, ideal Q, intvec *wdegree, ring tailRing)
Definition: hilb.cc:1299
int l
Definition: cfEzgcd.cc:94
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 }
void hDimSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:29
scfmon hwork
Definition: hutil.cc:19
int hNexist
Definition: hutil.cc:22
int * varset
Definition: hutil.h:23
int hCo
Definition: hdegree.cc:22
loop
Definition: myNF.cc:98
#define id_Test(A, lR)
Definition: simpleideals.h:80
scmon * scfmon
Definition: hutil.h:22
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
scfmon hexist
Definition: hutil.cc:19
monf hCreate(int Nvar)
Definition: hutil.cc:1002
int hNvar
Definition: hutil.cc:22
void * ADDRESS
Definition: auxiliary.h:161
int hNrad
Definition: hutil.cc:22
int hNpure
Definition: hutil.cc:22
scmon hpure
Definition: hutil.cc:20
#define Q
Definition: sirandom.c:25
void hRadical(scfmon rad, int *Nrad, int Nvar)
Definition: hutil.cc:417
#define omAlloc(size)
Definition: omAllocDecl.h:210
scfmon hrad
Definition: hutil.cc:19
void hDelete(scfmon ev, int ev_length)
Definition: hutil.cc:146
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
void hKill(monf xmem, int Nvar)
Definition: hutil.cc:1016
varset hvar
Definition: hutil.cc:21
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
int * scmon
Definition: hutil.h:21
void hLexR(scfmon rad, int Nrad, varset var, int Nvar)
Definition: hutil.cc:571
#define NULL
Definition: omList.c:10
monf radmem
Definition: hutil.cc:24
int hisModule
Definition: hutil.cc:23
void hComp(scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
Definition: hutil.cc:160
scfmon hInit(ideal S, ideal Q, int *Nexist, ring tailRing)
Definition: hutil.cc:34
void hSupp(scfmon stc, int Nstc, varset var, int *Nvar)
Definition: hutil.cc:180
static void scElKbase ( )
static

Definition at line 1078 of file hdegree.cc.

1079 {
1080  poly q = pInit();
1081  pSetCoeff0(q,nInit(1));
1082  pSetExpV(q,act);
1083  pNext(q) = NULL;
1084  last = pNext(last) = q;
1085 }
static poly last
Definition: hdegree.cc:1075
#define pSetExpV(p, e)
Definition: polys.h:97
#define NULL
Definition: omList.c:10
#define pInit()
allocates a new monomial and initializes everything to 0
Definition: polys.h:61
#define pNext(p)
Definition: monomials.h:43
#define pSetCoeff0(p, n)
Definition: monomials.h:67
static scmon act
Definition: hdegree.cc:1076
polyrec * poly
Definition: hilb.h:10
#define nInit(i)
Definition: numbers.h:24
static ideal scIdKbase ( poly  q,
const int  rank 
)
static

Definition at line 1333 of file hdegree.cc.

1334 {
1335  ideal res = idInit(pLength(q), rank);
1336  polyset mm = res->m;
1337  int i = 0;
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 }
return P p
Definition: myNF.cc:203
#define id_Test(A, lR)
Definition: simpleideals.h:80
static int pLength(poly a)
Definition: p_polys.h:189
poly res
Definition: myNF.cc:322
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
int i
Definition: cfEzgcd.cc:123
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
#define NULL
Definition: omList.c:10
poly * polyset
Definition: hutil.h:17
#define pNext(p)
Definition: monomials.h:43
polyrec * poly
Definition: hilb.h:10
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 }
scfmon hwork
Definition: hutil.cc:19
int hNexist
Definition: hutil.cc:22
int * varset
Definition: hutil.h:23
int hCo
Definition: hdegree.cc:22
loop
Definition: myNF.cc:98
#define id_Test(A, lR)
Definition: simpleideals.h:80
scmon * scfmon
Definition: hutil.h:22
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
scfmon hexist
Definition: hutil.cc:19
monf hCreate(int Nvar)
Definition: hutil.cc:1002
int hNvar
Definition: hutil.cc:22
void * ADDRESS
Definition: auxiliary.h:161
int hNrad
Definition: hutil.cc:22
int hNpure
Definition: hutil.cc:22
scmon hpure
Definition: hutil.cc:20
#define Q
Definition: sirandom.c:25
void hRadical(scfmon rad, int *Nrad, int Nvar)
Definition: hutil.cc:417
#define omAlloc(size)
Definition: omAllocDecl.h:210
scfmon hrad
Definition: hutil.cc:19
void hDelete(scfmon ev, int ev_length)
Definition: hutil.cc:146
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
Definition: intvec.h:16
void hKill(monf xmem, int Nvar)
Definition: hutil.cc:1016
varset hvar
Definition: hutil.cc:21
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:627
int * scmon
Definition: hutil.h:21
int i
Definition: cfEzgcd.cc:123
void hLexR(scfmon rad, int Nrad, varset var, int Nvar)
Definition: hutil.cc:571
#define NULL
Definition: omList.c:10
monf radmem
Definition: hutil.cc:24
int hisModule
Definition: hutil.cc:23
static void hIndSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:133
static scmon hInd
Definition: hdegree.cc:131
void hComp(scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
Definition: hutil.cc:160
scfmon hInit(ideal S, ideal Q, int *Nexist, ring tailRing)
Definition: hutil.cc:34
#define omAlloc0(size)
Definition: omAllocDecl.h:211
void hSupp(scfmon stc, int Nstc, varset var, int *Nvar)
Definition: hutil.cc:180
static void scInKbase ( scfmon  stc,
int  Nstc,
int  Nvar 
)
static

Definition at line 1277 of file hdegree.cc.

1278 {
1279  int Ivar, Istc, i, j;
1280  scfmon sn;
1281  int x, ideg;
1282 
1283  if (Nvar == 1)
1284  {
1285  ideg = scMin(Nstc, stc, 1);
1286  while (ideg > 0)
1287  {
1288  ideg--;
1289  act[1] = ideg;
1290  scElKbase();
1291  }
1292  return;
1293  }
1294  Ivar = Nvar-1;
1295  sn = hGetmem(Nstc, stc, stcmem[Ivar]);
1296  x = scRestrict(Nstc, sn, Nvar);
1297  if (x == 0) return;
1298  ideg = x-1;
1299  loop
1300  {
1301  x = scMax(Nstc, sn, Nvar);
1302  while (ideg >= x)
1303  {
1304  act[Nvar] = ideg;
1305  scInKbase(sn, Nstc, Ivar);
1306  ideg--;
1307  }
1308  if (ideg < 0) return;
1309  Istc = Nstc;
1310  for (i=Nstc-1; i>=0; i--)
1311  {
1312  if (ideg < sn[i][Nvar])
1313  {
1314  Istc--;
1315  sn[i] = NULL;
1316  }
1317  }
1318  j = 0;
1319  while (sn[j]) j++;
1320  i = j+1;
1321  for (; i<Nstc; i++)
1322  {
1323  if (sn[i])
1324  {
1325  sn[j] = sn[i];
1326  j++;
1327  }
1328  }
1329  Nstc = Istc;
1330  }
1331 }
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1029
loop
Definition: myNF.cc:98
scmon * scfmon
Definition: hutil.h:22
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
static int scRestrict(int &Nstc, scfmon stc, int Nvar)
Definition: hdegree.cc:1111
static void scElKbase()
Definition: hdegree.cc:1078
#define NULL
Definition: omList.c:10
monf stcmem
Definition: hutil.cc:24
Variable x
Definition: cfModGcd.cc:4023
static void scInKbase(scfmon stc, int Nstc, int Nvar)
Definition: hdegree.cc:1277
static int scMax(int i, scfmon stc, int Nvar)
Definition: hdegree.cc:1087
static scmon act
Definition: hdegree.cc:1076
static int scMin(int i, scfmon stc, int Nvar)
Definition: hdegree.cc:1099
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  pLmDelete(&p);
1411  if (p == NULL)
1412  return idInit(1,s->rank);
1413 
1414  last = p;
1415  return scIdKbase(p, s->rank);
1416 }
int hNstc
Definition: hutil.cc:22
const CanonicalForm int s
Definition: facAbsFact.cc:55
int hNexist
Definition: hutil.cc:22
return P p
Definition: myNF.cc:203
#define id_Test(A, lR)
Definition: simpleideals.h:80
scmon * scfmon
Definition: hutil.h:22
static void scDegKbase(scfmon stc, int Nstc, int Nvar, int deg)
Definition: hdegree.cc:1196
static poly last
Definition: hdegree.cc:1075
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
scfmon hexist
Definition: hutil.cc:19
monf hCreate(int Nvar)
Definition: hutil.cc:1002
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
void * ADDRESS
Definition: auxiliary.h:161
#define Q
Definition: sirandom.c:25
#define omAlloc(size)
Definition: omAllocDecl.h:210
void hDelete(scfmon ev, int ev_length)
Definition: hutil.cc:146
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
void hKill(monf xmem, int Nvar)
Definition: hutil.cc:1016
int scDimInt(ideal S, ideal Q)
Definition: hdegree.cc:72
int * scmon
Definition: hutil.h:21
int i
Definition: cfEzgcd.cc:123
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
#define NULL
Definition: omList.c:10
monf stcmem
Definition: hutil.cc:24
static ideal scIdKbase(poly q, const int rank)
Definition: hdegree.cc:1333
#define pInit()
allocates a new monomial and initializes everything to 0
Definition: polys.h:61
static void scInKbase(scfmon stc, int Nstc, int Nvar)
Definition: hdegree.cc:1277
int hisModule
Definition: hutil.cc:23
static scmon act
Definition: hdegree.cc:1076
static void scAll(int Nvar, int deg)
Definition: hdegree.cc:1162
polyrec * poly
Definition: hilb.h:10
scfmon hstc
Definition: hutil.cc:19
void hComp(scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
Definition: hutil.cc:160
scfmon hInit(ideal S, ideal Q, int *Nexist, ring tailRing)
Definition: hutil.cc:34
static int scMax ( int  i,
scfmon  stc,
int  Nvar 
)
static

Definition at line 1087 of file hdegree.cc.

1088 {
1089  int x, y=stc[0][Nvar];
1090  for (; i;)
1091  {
1092  i--;
1093  x = stc[i][Nvar];
1094  if (x > y) y = x;
1095  }
1096  return y;
1097 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
int i
Definition: cfEzgcd.cc:123
Variable x
Definition: cfModGcd.cc:4023
static int scMin ( int  i,
scfmon  stc,
int  Nvar 
)
static

Definition at line 1099 of file hdegree.cc.

1100 {
1101  int x, y=stc[0][Nvar];
1102  for (; i;)
1103  {
1104  i--;
1105  x = stc[i][Nvar];
1106  if (x < y) y = x;
1107  }
1108  return y;
1109 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
int i
Definition: cfEzgcd.cc:123
Variable x
Definition: cfModGcd.cc:4023
int scMult0Int ( ideal  S,
ideal  Q,
const ring  tailRing 
)

Definition at line 919 of file hdegree.cc.

920 {
922  if (Q!=NULL) id_TestTail(Q, currRing, tailRing);
923 
924  hDegree0(S, Q, tailRing);
925  return hMu;
926 }
#define id_TestTail(A, lR, tR)
Definition: simpleideals.h:79
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
#define Q
Definition: sirandom.c:25
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
#define NULL
Definition: omList.c:10
static void hDegree0(ideal S, ideal Q, const ring tailRing)
Definition: hdegree.cc:845
int hMu
Definition: hdegree.cc:22
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 }
#define id_Test(A, lR)
Definition: simpleideals.h:80
static void hDegree(ideal S, ideal Q)
Definition: hdegree.cc:698
#define Q
Definition: sirandom.c:25
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
#define NULL
Definition: omList.c:10
int hMu
Definition: hdegree.cc:22
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 }
#define Print
Definition: emacs.cc:83
void mu(int **points, int sizePoints)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
static int scRestrict ( int &  Nstc,
scfmon  stc,
int  Nvar 
)
static

Definition at line 1111 of file hdegree.cc.

1112 {
1113  int x, y;
1114  int i, j, Istc = Nstc;
1115 
1116  y = MAX_INT_VAL;
1117  for (i=Nstc-1; i>=0; i--)
1118  {
1119  j = Nvar-1;
1120  loop
1121  {
1122  if(stc[i][j] != 0) break;
1123  j--;
1124  if (j == 0)
1125  {
1126  Istc--;
1127  x = stc[i][Nvar];
1128  if (x < y) y = x;
1129  stc[i] = NULL;
1130  break;
1131  }
1132  }
1133  }
1134  if (Istc < Nstc)
1135  {
1136  for (i=Nstc-1; i>=0; i--)
1137  {
1138  if (stc[i] && (stc[i][Nvar] >= y))
1139  {
1140  Istc--;
1141  stc[i] = NULL;
1142  }
1143  }
1144  j = 0;
1145  while (stc[j]) j++;
1146  i = j+1;
1147  for(; i<Nstc; i++)
1148  {
1149  if (stc[i])
1150  {
1151  stc[j] = stc[i];
1152  j++;
1153  }
1154  }
1155  Nstc = Istc;
1156  return y;
1157  }
1158  else
1159  return -1;
1160 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
loop
Definition: myNF.cc:98
int j
Definition: myNF.cc:70
const int MAX_INT_VAL
Definition: mylimits.h:12
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
Variable x
Definition: cfModGcd.cc:4023

Variable Documentation

scmon act
static

Definition at line 1076 of file hdegree.cc.

int hCo

Definition at line 22 of file hdegree.cc.

scmon hInd
static

Definition at line 131 of file hdegree.cc.

int hMu

Definition at line 22 of file hdegree.cc.

int hMu2

Definition at line 22 of file hdegree.cc.

omBin indlist_bin = omGetSpecBin(sizeof(indlist))

Definition at line 23 of file hdegree.cc.

indset ISet

Definition at line 279 of file hdegree.cc.

indset JSet

Definition at line 279 of file hdegree.cc.

poly last
static

Definition at line 1075 of file hdegree.cc.

poly pWork
static

Definition at line 931 of file hdegree.cc.