My Project
Loading...
Searching...
No Matches
Data Structures | Macros | Typedefs | Functions | Variables
hutil.h File Reference
#include "polys/monomials/ring.h"
#include "kernel/polys.h"
#include "misc/intvec.h"

Go to the source code of this file.

Data Structures

struct  monh
 
struct  indlist
 

Macros

#define LEN_MON   (sizeof(scfmon) + sizeof(int))
 

Typedefs

typedef int * scmon
 
typedef scmonscfmon
 
typedef int * varset
 
typedef monh * monp
 
typedef monpmonf
 
typedef indlist * indset
 

Functions

void hDelete (scfmon ev, int ev_length)
 
void hComp (scfmon exist, int Nexist, int ak, scfmon stc, int *Nstc)
 
void hSupp (scfmon stc, int Nstc, varset var, int *Nvar)
 
void hOrdSupp (scfmon stc, int Nstc, varset var, int Nvar)
 
void hStaircase (scfmon stc, int *Nstc, varset var, int Nvar)
 
void hRadical (scfmon rad, int *Nrad, int Nvar)
 
void hLexS (scfmon stc, int Nstc, varset var, int Nvar)
 
void hLexR (scfmon rad, int Nrad, varset var, int Nvar)
 
void hPure (scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
 
void hElimS (scfmon stc, int *e1, int a2, int e2, varset var, int Nvar)
 
void hElimR (scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
 
void hLex2S (scfmon stc, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
 
void hLex2R (scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
 
void hStepS (scfmon stc, int Nstc, varset var, int Nvar, int *a, int *x)
 
void hStepR (scfmon rad, int Nrad, varset var, int Nvar, int *a)
 
monf hCreate (int Nvar)
 
void hKill (monf xmem, int Nvar)
 
scfmon hGetmem (int lm, scfmon old, monp monmem)
 
scmon hGetpure (scmon p)
 
void hDimSolve (scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
 
void hIndMult (scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
 
void hIndAllMult (scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
 
void hDegreeSeries (intvec *s1, intvec *s2, int *co, int *mu)
 
scfmon hInit (ideal S, ideal Q, int *Nexist)
 
void slicehilb (ideal I)
 
void HilbertSeries_OrbitData (ideal S, int lV, bool ig, bool mgrad, bool odp, int trunDegHs)
 
ideal RightColonOperation (ideal i, poly w, int lV)
 

Variables

EXTERN_VAR omBin indlist_bin
 
EXTERN_VAR scfmon hexist
 
EXTERN_VAR scfmon hstc
 
EXTERN_VAR scfmon hrad
 
EXTERN_VAR scfmon hwork
 
EXTERN_VAR scmon hpure
 
EXTERN_VAR scmon hpur0
 
EXTERN_VAR varset hvar
 
EXTERN_VAR varset hsel
 
EXTERN_VAR int hNexist
 
EXTERN_VAR int hNstc
 
EXTERN_VAR int hNrad
 
EXTERN_VAR int hNvar
 
EXTERN_VAR int hNpure
 
EXTERN_VAR monf stcmem
 
EXTERN_VAR monf radmem
 
EXTERN_VAR int hisModule
 
EXTERN_VAR indset ISet
 
EXTERN_VAR indset JSet
 
EXTERN_VAR int hCo
 
EXTERN_VAR int hMu2
 
EXTERN_VAR long hMu
 

Data Structure Documentation

◆ monrec

struct monrec

Definition at line 21 of file hutil.h.

Data Fields
int a
scfmon mo

◆ sindlist

struct sindlist

Definition at line 29 of file hutil.h.

Data Fields
indset nx
intvec * set

Macro Definition Documentation

◆ LEN_MON

#define LEN_MON   (sizeof(scfmon) + sizeof(int))

Definition at line 35 of file hutil.h.

Typedef Documentation

◆ indset

typedef indlist* indset

Definition at line 28 of file hutil.h.

◆ monf

typedef monp* monf

Definition at line 20 of file hutil.h.

◆ monp

typedef monh* monp

Definition at line 19 of file hutil.h.

◆ scfmon

typedef scmon* scfmon

Definition at line 15 of file hutil.h.

◆ scmon

typedef int* scmon

Definition at line 14 of file hutil.h.

◆ varset

typedef int* varset

Definition at line 16 of file hutil.h.

Function Documentation

◆ hComp()

void hComp ( scfmon  exist,
int  Nexist,
int  ak,
scfmon  stc,
int *  Nstc 
)

Definition at line 154 of file hutil.cc.

155{
156 int k = 0;
157 scfmon ex = exist, co = stc;
158 int i;
159
160 for (i = Nexist; i>0; i--)
161 {
162 if (((**ex) == 0) || ((**ex) == ak))
163 {
164 *co = *ex;
165 co++;
166 k++;
167 }
168 ex++;
169 }
170 *Nstc = k;
171}
int i
Definition: cfEzgcd.cc:132
int k
Definition: cfEzgcd.cc:99
scmon * scfmon
Definition: hutil.h:15

◆ hCreate()

monf hCreate ( int  Nvar)

Definition at line 996 of file hutil.cc.

997{
998 monf xmem;
999 int i;
1000 xmem = (monf)omAlloc((Nvar + 1) * sizeof(monp));
1001 for (i = Nvar; i>0; i--)
1002 {
1003 xmem[i] = (monp)omAlloc(LEN_MON);
1004 xmem[i]->mo = NULL;
1005 }
1006 return xmem;
1007}
#define LEN_MON
Definition: hutil.h:35
monh * monp
Definition: hutil.h:19
monp * monf
Definition: hutil.h:20
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define NULL
Definition: omList.c:12

◆ hDegreeSeries()

void hDegreeSeries ( intvec s1,
intvec s2,
int *  co,
int *  mu 
)

Definition at line 732 of file hilb.cc.

733{
734 int i, j, k;
735 int m;
736 *co = *mu = 0;
737 if ((s1 == NULL) || (s2 == NULL))
738 return;
739 i = s1->length();
740 j = s2->length();
741 if (j > i)
742 return;
743 m = 0;
744 for(k=j-2; k>=0; k--)
745 m += (*s2)[k];
746 *mu = m;
747 *co = i - j;
748}
int m
Definition: cfEzgcd.cc:128
int length() const
Definition: intvec.h:94
int j
Definition: facHensel.cc:110
static matrix mu(matrix A, const ring R)
Definition: matpol.cc:2025

◆ hDelete()

void hDelete ( scfmon  ev,
int  ev_length 
)

Definition at line 140 of file hutil.cc.

141{
142 int i;
143
144 if (ev_length>0)
145 {
146 for (i=ev_length-1;i>=0;i--)
147 omFreeSize(hsecure[i],((currRing->N)+1)*sizeof(int));
148 omFreeSize(hsecure, ev_length*sizeof(scmon));
149 omFreeSize(ev, ev_length*sizeof(scmon));
150 }
151}
STATIC_VAR scfmon hsecure
Definition: hutil.cc:29
int * scmon
Definition: hutil.h:14
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13

◆ hDimSolve()

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

Definition at line 35 of file hdegree.cc.

37{
38 int dn, iv, rad0, b, c, x;
39 scmon pn;
40 scfmon rn;
41 if (Nrad < 2)
42 {
43 dn = Npure + Nrad;
44 if (dn < hCo)
45 hCo = dn;
46 return;
47 }
48 if (Npure+1 >= hCo)
49 return;
50 iv = Nvar;
51 while(pure[var[iv]]) iv--;
52 hStepR(rad, Nrad, var, iv, &rad0);
53 if (rad0!=0)
54 {
55 iv--;
56 if (rad0 < Nrad)
57 {
58 pn = hGetpure(pure);
59 rn = hGetmem(Nrad, rad, radmem[iv]);
60 hDimSolve(pn, Npure + 1, rn, rad0, var, iv);
61 b = rad0;
62 c = Nrad;
63 hElimR(rn, &rad0, b, c, var, iv);
64 hPure(rn, b, &c, var, iv, pn, &x);
65 hLex2R(rn, rad0, b, c, var, iv, hwork);
66 rad0 += (c - b);
67 hDimSolve(pn, Npure + x, rn, rad0, var, iv);
68 }
69 else
70 {
71 hDimSolve(pure, Npure, rad, Nrad, var, iv);
72 }
73 }
74 else
75 hCo = Npure + 1;
76}
Variable x
Definition: cfModGcd.cc:4082
CanonicalForm b
Definition: cfModGcd.cc:4103
VAR int hCo
Definition: hdegree.cc:27
void hDimSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:35
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition: hutil.cc:1023
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition: hutil.cc:621
VAR scfmon hwork
Definition: hutil.cc:16
void hStepR(scfmon rad, int Nrad, varset var, int Nvar, int *a)
Definition: hutil.cc:974
void hLex2R(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition: hutil.cc:880
void hElimR(scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
Definition: hutil.cc:742
VAR monf radmem
Definition: hutil.cc:21
scmon hGetpure(scmon p)
Definition: hutil.cc:1052

◆ hElimR()

void hElimR ( scfmon  rad,
int *  e1,
int  a2,
int  e2,
varset  var,
int  Nvar 
)

Definition at line 742 of file hutil.cc.

743{
744 int nc = *e1, z = 0, i, j, k, k1;
745 scmon n, o;
746 if (!nc || (a2 == e2))
747 return;
748 j = 0;
749 i = a2;
750 o = rad[i];
751 n = rad[0];
752 k = Nvar;
753 loop
754 {
755 k1 = var[k];
756 if (o[k1] && !n[k1])
757 {
758 k = Nvar;
759 i++;
760 if (i < e2)
761 o = rad[i];
762 else
763 {
764 j++;
765 if (j < nc)
766 {
767 i = a2;
768 o = rad[i];
769 n = rad[j];
770 }
771 else
772 {
773 if (z!=0)
774 {
775 *e1 -= z;
776 hShrink(rad, 0, nc);
777 }
778 return;
779 }
780 }
781 }
782 else
783 {
784 k--;
785 if (!k)
786 {
787 rad[j] = NULL;
788 z++;
789 j++;
790 if (j < nc)
791 {
792 i = a2;
793 o = rad[i];
794 n = rad[j];
795 k = Nvar;
796 }
797 else
798 {
799 if (z!=0)
800 {
801 *e1 -= z;
802 hShrink(rad, 0, nc);
803 }
804 return;
805 }
806 }
807 }
808 }
809}
static void hShrink(scfmon co, int a, int Nco)
Definition: hutil.cc:297
#define loop
Definition: structs.h:75

◆ hElimS()

void hElimS ( scfmon  stc,
int *  e1,
int  a2,
int  e2,
varset  var,
int  Nvar 
)

Definition at line 672 of file hutil.cc.

673{
674 int nc = *e1, z = 0, i, j, k, k1;
675 scmon n, o;
676 if (!nc || (a2 == e2))
677 return;
678 j = 0;
679 i = a2;
680 o = stc[i];
681 n = stc[0];
682 k = Nvar;
683 loop
684 {
685 k1 = var[k];
686 if (o[k1] > n[k1])
687 {
688 k = Nvar;
689 i++;
690 if (i < e2)
691 o = stc[i];
692 else
693 {
694 j++;
695 if (j < nc)
696 {
697 i = a2;
698 o = stc[i];
699 n = stc[j];
700 }
701 else
702 {
703 if (z!=0)
704 {
705 *e1 -= z;
706 hShrink(stc, 0, nc);
707 }
708 return;
709 }
710 }
711 }
712 else
713 {
714 k--;
715 if (k==0)
716 {
717 stc[j] = NULL;
718 z++;
719 j++;
720 if (j < nc)
721 {
722 i = a2;
723 o = stc[i];
724 n = stc[j];
725 k = Nvar;
726 }
727 else
728 {
729 if (z!=0)
730 {
731 *e1 -= z;
732 hShrink(stc, 0, nc);
733 }
734 return;
735 }
736 }
737 }
738 }
739}

◆ hGetmem()

scfmon hGetmem ( int  lm,
scfmon  old,
monp  monmem 
)

Definition at line 1023 of file hutil.cc.

1024{
1025 scfmon x = monmem->mo;
1026 int lx = monmem->a;
1027 if ((x==NULL) || (lm > lx))
1028 {
1029 /* according to http://www.singular.uni-kl.de:8002/trac/ticket/463#comment:4
1030 * we need to work around a compiler bug:
1031 * if ((x!=NULL)&&(lx>0)) omFreeSize((ADDRESS)x, lx * sizeof(scmon));
1032 */
1033 if (x!=NULL) if (lx>0) omFreeSize((ADDRESS)x, lx * sizeof(scmon));
1034 monmem->mo = x = (scfmon)omAlloc(lm * sizeof(scmon));
1035 monmem->a = lm;
1036 }
1037 memcpy(x, old, lm * sizeof(scmon));
1038 return x;
1039}
void * ADDRESS
Definition: auxiliary.h:119

◆ hGetpure()

scmon hGetpure ( scmon  p)

Definition at line 1052 of file hutil.cc.

1053{
1054 scmon p1 = p;
1055 scmon pn;
1056 p1++;
1057 pn = p1;
1058 pn += (currRing->N);
1059 memcpy(pn, p1, (currRing->N) * sizeof(int));
1060 return pn - 1;
1061}
int p
Definition: cfModGcd.cc:4078

◆ HilbertSeries_OrbitData()

void HilbertSeries_OrbitData ( ideal  S,
int  lV,
bool  ig,
bool  mgrad,
bool  odp,
int  trunDegHs 
)

Definition at line 1326 of file hilb.cc.

1327{
1328
1329 /* new story:
1330 no lV is needed, i.e. it is to be determined
1331 the rest is extracted from the interface input list in extra.cc and makes the input of this proc
1332 called from extra.cc
1333 */
1334
1335 /*
1336 * This is based on iterative right colon operations on a
1337 * two-sided monomial ideal of the free associative algebra.
1338 * The algorithm terminates for those monomial ideals
1339 * whose monomials define "regular formal languages",
1340 * that is, all monomials of the input ideal can be obtained
1341 * from finite languages by applying finite number of
1342 * rational operations.
1343 */
1344
1345 int trInd;
1346 S = minimalMonomialGenSet(S);
1347 if( !idIs0(S) && p_Totaldegree(S->m[0], currRing)==0)
1348 {
1349 PrintS("Hilbert Series:\n 0\n");
1350 return;
1351 }
1352 int (*POS)(ideal, poly, std::vector<ideal>, std::vector<poly>, int, int);
1353 if(trunDegHs != 0)
1354 {
1355 Print("\nTruncation degree = %d\n",trunDegHs);
1357 }
1358 else
1359 {
1360 if(IG_CASE)
1361 {
1362 if(idIs0(S))
1363 {
1364 WerrorS("wrong input: it is not an infinitely gen. case");
1365 return;
1366 }
1367 trInd = p_Totaldegree(S->m[IDELEMS(S)-1], currRing);
1369 }
1370 else
1372 }
1373 std::vector<ideal > idorb;
1374 std::vector< poly > polist;
1375
1376 ideal orb_init = idInit(1, 1);
1377 idorb.push_back(orb_init);
1378
1379 polist.push_back( p_One(currRing));
1380
1381 std::vector< std::vector<int> > posMat;
1382 std::vector<int> posRow(lV,0);
1383 std::vector<int> C;
1384
1385 int ds, is, ps;
1386 unsigned long lpcnt = 0;
1387
1388 poly w, wi;
1389 ideal Jwi;
1390
1391 while(lpcnt < idorb.size())
1392 {
1393 w = NULL;
1394 w = polist[lpcnt];
1395 if(lpcnt >= 1 && idIs0(idorb[lpcnt]) == FALSE)
1396 {
1397 if(p_Totaldegree(idorb[lpcnt]->m[0], currRing) != 0)
1398 {
1399 C.push_back(1);
1400 }
1401 else
1402 C.push_back(0);
1403 }
1404 else
1405 {
1406 C.push_back(1);
1407 }
1408
1409 ds = p_Totaldegree(w, currRing);
1410 lpcnt++;
1411
1412 for(is = 1; is <= lV; is++)
1413 {
1414 wi = NULL;
1415 //make new copy 'wi' of word w=polist[lpcnt]
1416 //and update it (for the colon operation).
1417 //if corresponding to wi, right colon operation gives
1418 //a new (right colon) ideal of S,
1419 //keep 'wi' in the polist else delete it
1420
1421 wi = pCopy(w);
1422 p_SetExp(wi, (ds*lV)+is, 1, currRing);
1423 p_Setm(wi, currRing);
1424 Jwi = NULL;
1425 //Jwi stores (right) colon ideal of S w.r.t. word
1426 //wi if colon operation gives a new ideal place it
1427 //in the vector of ideals 'idorb'
1428 //otherwise delete it
1429
1430 Jwi = idInit(1,1);
1431
1432 Jwi = colonIdeal(S, wi, lV, Jwi, trunDegHs);
1433 ps = (*POS)(Jwi, wi, idorb, polist, trInd, trunDegHs);
1434
1435 if(ps == 0) // finds a new ideal
1436 {
1437 posRow[is-1] = idorb.size();
1438
1439 idorb.push_back(Jwi);
1440 polist.push_back(wi);
1441 }
1442 else // ideal is already there in the set
1443 {
1444 posRow[is-1]=ps-1;
1445 idDelete(&Jwi);
1446 pDelete(&wi);
1447 }
1448 }
1449 posMat.push_back(posRow);
1450 posRow.resize(lV,0);
1451 }
1452 int lO = C.size();//size of the orbit
1453 PrintLn();
1454 Print("maximal length of words = %ld\n", p_Totaldegree(polist[lO-1], currRing));
1455 Print("\nlength of the Orbit = %d", lO);
1456 PrintLn();
1457
1458 if(odp)
1459 {
1460 Print("words description of the Orbit: \n");
1461 for(is = 0; is < lO; is++)
1462 {
1463 pWrite0(polist[is]);
1464 PrintS(" ");
1465 }
1466 PrintLn();
1467 PrintS("\nmaximal degree, #(sum_j R(w,w_j))");
1468 PrintLn();
1469 for(is = 0; is < lO; is++)
1470 {
1471 if(idIs0(idorb[is]))
1472 {
1473 PrintS("NULL\n");
1474 }
1475 else
1476 {
1477 Print("%ld, %d \n",p_Totaldegree(idorb[is]->m[IDELEMS(idorb[is])-1], currRing),IDELEMS(idorb[is]));
1478 }
1479 }
1480 }
1481
1482 for(is = idorb.size()-1; is >= 0; is--)
1483 {
1484 idDelete(&idorb[is]);
1485 }
1486 for(is = polist.size()-1; is >= 0; is--)
1487 {
1488 pDelete(&polist[is]);
1489 }
1490
1491 idorb.resize(0);
1492 polist.resize(0);
1493
1494 int adjMatrix[lO][lO];
1495 memset(adjMatrix, 0, lO*lO*sizeof(int));
1496 int rowCount, colCount;
1497 int tm = 0;
1498 if(!mgrad)
1499 {
1500 for(rowCount = 0; rowCount < lO; rowCount++)
1501 {
1502 for(colCount = 0; colCount < lV; colCount++)
1503 {
1504 tm = posMat[rowCount][colCount];
1505 adjMatrix[rowCount][tm] = adjMatrix[rowCount][tm] + 1;
1506 }
1507 }
1508 }
1509
1510 ring r = currRing;
1511 int npar;
1512 char** tt;
1514 if(!mgrad)
1515 {
1516 tt=(char**)omAlloc(sizeof(char*));
1517 tt[0] = omStrDup("t");
1518 npar = 1;
1519 }
1520 else
1521 {
1522 tt=(char**)omalloc(lV*sizeof(char*));
1523 for(is = 0; is < lV; is++)
1524 {
1525 tt[is] = (char*)omAlloc(7*sizeof(char)); //if required enlarge it later
1526 sprintf (tt[is], "t%d", is+1);
1527 }
1528 npar = lV;
1529 }
1530
1531 p.r = rDefault(0, npar, tt);
1533 char** xx = (char**)omAlloc(sizeof(char*));
1534 xx[0] = omStrDup("x");
1535 ring R = rDefault(cf, 1, xx);
1536 rChangeCurrRing(R);//rWrite(R);
1537 /*
1538 * matrix corresponding to the orbit of the ideal
1539 */
1540 matrix mR = mpNew(lO, lO);
1541 matrix cMat = mpNew(lO,1);
1542 poly rc;
1543
1544 if(!mgrad)
1545 {
1546 for(rowCount = 0; rowCount < lO; rowCount++)
1547 {
1548 for(colCount = 0; colCount < lO; colCount++)
1549 {
1550 if(adjMatrix[rowCount][colCount] != 0)
1551 {
1552 MATELEM(mR, rowCount + 1, colCount + 1) = p_ISet(adjMatrix[rowCount][colCount], R);
1553 p_SetCoeff(MATELEM(mR, rowCount + 1, colCount + 1), n_Mult(pGetCoeff(mR->m[lO*rowCount+colCount]),n_Param(1, R->cf), R->cf), R);
1554 }
1555 }
1556 }
1557 }
1558 else
1559 {
1560 for(rowCount = 0; rowCount < lO; rowCount++)
1561 {
1562 for(colCount = 0; colCount < lV; colCount++)
1563 {
1564 rc=NULL;
1565 rc=p_One(R);
1566 p_SetCoeff(rc, n_Mult(pGetCoeff(rc), n_Param(colCount+1, R->cf),R->cf), R);
1567 MATELEM(mR, rowCount +1, posMat[rowCount][colCount]+1)=p_Add_q(rc,MATELEM(mR, rowCount +1, posMat[rowCount][colCount]+1), R);
1568 }
1569 }
1570 }
1571
1572 for(rowCount = 0; rowCount < lO; rowCount++)
1573 {
1574 if(C[rowCount] != 0)
1575 {
1576 MATELEM(cMat, rowCount + 1, 1) = p_ISet(C[rowCount], R);
1577 }
1578 }
1579
1580 matrix u;
1581 unitMatrix(lO, u); //unit matrix
1582 matrix gMat = mp_Sub(u, mR, R);
1583
1584 char* s;
1585
1586 if(odp)
1587 {
1588 PrintS("\nlinear system:\n");
1589 if(!mgrad)
1590 {
1591 for(rowCount = 0; rowCount < lO; rowCount++)
1592 {
1593 Print("H(%d) = ", rowCount+1);
1594 for(colCount = 0; colCount < lV; colCount++)
1595 {
1596 StringSetS(""); nWrite(n_Param(1, R->cf));
1597 s = StringEndS(); PrintS(s);
1598 Print("*"); omFree(s);
1599 Print("H(%d) + ", posMat[rowCount][colCount] + 1);
1600 }
1601 Print(" %d\n", C[rowCount] );
1602 }
1603 PrintS("where H(1) represents the series corresp. to input ideal\n");
1604 PrintS("and i^th summand in the rhs of an eqn. is according\n");
1605 PrintS("to the right colon map corresp. to the i^th variable\n");
1606 }
1607 else
1608 {
1609 for(rowCount = 0; rowCount < lO; rowCount++)
1610 {
1611 Print("H(%d) = ", rowCount+1);
1612 for(colCount = 0; colCount < lV; colCount++)
1613 {
1614 StringSetS(""); nWrite(n_Param(colCount+1, R->cf));
1615 s = StringEndS(); PrintS(s);
1616 Print("*");omFree(s);
1617 Print("H(%d) + ", posMat[rowCount][colCount] + 1);
1618 }
1619 Print(" %d\n", C[rowCount] );
1620 }
1621 PrintS("where H(1) represents the series corresp. to input ideal\n");
1622 }
1623 }
1624 PrintLn();
1625 posMat.resize(0);
1626 C.resize(0);
1627 matrix pMat;
1628 matrix lMat;
1629 matrix uMat;
1630 matrix H_serVec = mpNew(lO, 1);
1631 matrix Hnot;
1632
1633 //std::clock_t start;
1634 //start = std::clock();
1635
1636 luDecomp(gMat, pMat, lMat, uMat, R);
1637 luSolveViaLUDecomp(pMat, lMat, uMat, cMat, H_serVec, Hnot);
1638
1639 //to print system solving time
1640 //if(odp){
1641 //std::cout<<"solving time of the system = "<<(std::clock()-start)/(double)(CLOCKS_PER_SEC / 1000)<<" ms"<<std::endl;}
1642
1643 mp_Delete(&mR, R);
1644 mp_Delete(&u, R);
1645 mp_Delete(&pMat, R);
1646 mp_Delete(&lMat, R);
1647 mp_Delete(&uMat, R);
1648 mp_Delete(&cMat, R);
1649 mp_Delete(&gMat, R);
1650 mp_Delete(&Hnot, R);
1651 //print the Hilbert series and length of the Orbit
1652 PrintLn();
1653 Print("Hilbert series:");
1654 PrintLn();
1655 pWrite(H_serVec->m[0]);
1656 if(!mgrad)
1657 {
1658 omFree(tt[0]);
1659 }
1660 else
1661 {
1662 for(is = lV-1; is >= 0; is--)
1663
1664 omFree( tt[is]);
1665 }
1666 omFree(tt);
1667 omFree(xx[0]);
1668 omFree(xx);
1669 rChangeCurrRing(r);
1670 rKill(R);
1671}
#define FALSE
Definition: auxiliary.h:96
CanonicalForm cf
Definition: cfModGcd.cc:4083
poly * m
Definition: matpol.h:18
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
Definition: coeffs.h:633
static FORCE_INLINE number n_Param(const int iParameter, const coeffs r)
return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1....
Definition: coeffs.h:780
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:38
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:413
#define Print
Definition: emacs.cc:80
const CanonicalForm int s
Definition: facAbsFact.cc:51
const CanonicalForm & w
Definition: facAbsFact.cc:51
void WerrorS(const char *s)
Definition: feFopen.cc:24
static int positionInOrbitTruncationCase(ideal I, poly w, std::vector< ideal > idorb, std::vector< poly > polist, int, int trunDegHs)
Definition: hilb.cc:1037
static ideal colonIdeal(ideal S, poly w, int lV, ideal Jwi, int trunDegHs)
Definition: hilb.cc:1291
static int positionInOrbit_FG_Case(ideal I, poly, std::vector< ideal > idorb, std::vector< poly >, int, int)
Definition: hilb.cc:1006
static int positionInOrbit_IG_Case(ideal I, poly w, std::vector< ideal > idorb, std::vector< poly > polist, int trInd, int)
Definition: hilb.cc:928
static ideal minimalMonomialGenSet(ideal I)
Definition: hilb.cc:1131
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
void rKill(ring r)
Definition: ipshell.cc:6180
bool unitMatrix(const int n, matrix &unitMat, const ring R)
Creates a new matrix which is the (nxn) unit matrix, and returns true in case of success.
void luDecomp(const matrix aMat, matrix &pMat, matrix &lMat, matrix &uMat, const ring R)
LU-decomposition of a given (m x n)-matrix.
bool luSolveViaLUDecomp(const matrix pMat, const matrix lMat, const matrix uMat, const matrix bVec, matrix &xVec, matrix &H)
Solves the linear system A * x = b, where A is an (m x n)-matrix which is given by its LU-decompositi...
void mp_Delete(matrix *a, const ring r)
Definition: matpol.cc:873
matrix mp_Sub(matrix a, matrix b, const ring R)
Definition: matpol.cc:189
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
#define MATELEM(mat, i, j)
1-based access to matrix
Definition: matpol.h:29
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:44
The main handler for Singular numbers which are suitable for Singular polynomials.
#define nWrite(n)
Definition: numbers.h:29
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omalloc(size)
Definition: omAllocDecl.h:228
#define omFree(addr)
Definition: omAllocDecl.h:261
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition: p_polys.cc:1297
poly p_One(const ring r)
Definition: p_polys.cc:1313
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:934
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition: p_polys.h:486
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:231
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:410
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1505
void rChangeCurrRing(ring r)
Definition: polys.cc:15
#define pDelete(p_ptr)
Definition: polys.h:186
void pWrite0(poly p)
Definition: polys.h:309
void pWrite(poly p)
Definition: polys.h:308
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185
void StringSetS(const char *st)
Definition: reporter.cc:128
void PrintS(const char *s)
Definition: reporter.cc:284
char * StringEndS()
Definition: reporter.cc:151
void PrintLn()
Definition: reporter.cc:310
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
Definition: ring.cc:102
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define IDELEMS(i)
Definition: simpleideals.h:23
#define R
Definition: sirandom.c:27
struct for passing initialization parameters to naInitChar
Definition: transext.h:88

◆ hIndAllMult()

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

Definition at line 564 of file hdegree.cc.

566{
567 int dn, iv, rad0, b, c, x;
568 scmon pn;
569 scfmon rn;
570 if (Nrad < 2)
571 {
572 dn = Npure + Nrad;
573 if (dn > hCo)
574 {
575 if (!Nrad)
576 hCheckIndep(pure);
577 else
578 {
579 pn = *rad;
580 for (iv = Nvar; iv; iv--)
581 {
582 x = var[iv];
583 if (pn[x])
584 {
585 pure[x] = 1;
586 hCheckIndep(pure);
587 pure[x] = 0;
588 }
589 }
590 }
591 }
592 return;
593 }
594 iv = Nvar;
595 while(pure[var[iv]]) iv--;
596 hStepR(rad, Nrad, var, iv, &rad0);
597 iv--;
598 if (rad0 < Nrad)
599 {
600 pn = hGetpure(pure);
601 rn = hGetmem(Nrad, rad, radmem[iv]);
602 pn[var[iv + 1]] = 1;
603 hIndAllMult(pn, Npure + 1, rn, rad0, var, iv);
604 pn[var[iv + 1]] = 0;
605 b = rad0;
606 c = Nrad;
607 hElimR(rn, &rad0, b, c, var, iv);
608 hPure(rn, b, &c, var, iv, pn, &x);
609 hLex2R(rn, rad0, b, c, var, iv, hwork);
610 rad0 += (c - b);
611 hIndAllMult(pn, Npure + x, rn, rad0, var, iv);
612 }
613 else
614 {
615 hIndAllMult(pure, Npure, rad, Nrad, var, iv);
616 }
617}
static void hCheckIndep(scmon pure)
Definition: hdegree.cc:543
void hIndAllMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:564

◆ hIndMult()

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

Definition at line 384 of file hdegree.cc.

386{
387 int dn, iv, rad0, b, c, x;
388 scmon pn;
389 scfmon rn;
390 if (Nrad < 2)
391 {
392 dn = Npure + Nrad;
393 if (dn == hCo)
394 {
395 if (Nrad==0)
396 hIndep(pure);
397 else
398 {
399 pn = *rad;
400 for (iv = Nvar; iv!=0; iv--)
401 {
402 x = var[iv];
403 if (pn[x])
404 {
405 pure[x] = 1;
406 hIndep(pure);
407 pure[x] = 0;
408 }
409 }
410 }
411 }
412 return;
413 }
414 iv = Nvar;
415 dn = Npure+1;
416 if (dn >= hCo)
417 {
418 if (dn > hCo)
419 return;
420 loop
421 {
422 if(!pure[var[iv]])
423 {
424 if(hNotZero(rad, Nrad, var, iv))
425 {
426 pure[var[iv]] = 1;
427 hIndep(pure);
428 pure[var[iv]] = 0;
429 }
430 }
431 iv--;
432 if (!iv)
433 return;
434 }
435 }
436 while(pure[var[iv]]) iv--;
437 hStepR(rad, Nrad, var, iv, &rad0);
438 iv--;
439 if (rad0 < Nrad)
440 {
441 pn = hGetpure(pure);
442 rn = hGetmem(Nrad, rad, radmem[iv]);
443 pn[var[iv + 1]] = 1;
444 hIndMult(pn, Npure + 1, rn, rad0, var, iv);
445 pn[var[iv + 1]] = 0;
446 b = rad0;
447 c = Nrad;
448 hElimR(rn, &rad0, b, c, var, iv);
449 hPure(rn, b, &c, var, iv, pn, &x);
450 hLex2R(rn, rad0, b, c, var, iv, hwork);
451 rad0 += (c - b);
452 hIndMult(pn, Npure + x, rn, rad0, var, iv);
453 }
454 else
455 {
456 hIndMult(pure, Npure, rad, Nrad, var, iv);
457 }
458}
void hIndMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:384
static BOOLEAN hNotZero(scfmon rad, int Nrad, varset var, int Nvar)
Definition: hdegree.cc:355
static void hIndep(scmon pure)
Definition: hdegree.cc:370

◆ hInit()

scfmon hInit ( ideal  S,
ideal  Q,
int *  Nexist 
)

Definition at line 31 of file hutil.cc.

32{
34 if (Q!=NULL) id_LmTest(Q, currRing);
35
37
38 if (hisModule < 0)
39 hisModule = 0;
40
41 int sl, ql, i, k = 0;
42 polyset si, qi, ss;
43 scfmon ex, ek;
44
45 if (S!=NULL)
46 {
47 si = S->m;
48 sl = IDELEMS(S);
49 }
50 else
51 {
52 si = NULL;
53 sl = 0;
54 }
55 if (Q!=NULL)
56 {
57 qi = Q->m;
58 ql = IDELEMS(Q);
59 }
60 else
61 {
62 qi = NULL;
63 ql = 0;
64 }
65 if ((sl + ql) == 0)
66 {
67 *Nexist = 0;
68 return NULL;
69 }
70 ss = si;
71 for (i = sl; i>0; i--)
72 {
73 if (*ss!=0)
74 k++;
75 ss++;
76 }
77 ss = qi;
78 for (i = ql; i>0; i--)
79 {
80 if (*ss!=0)
81 k++;
82 ss++;
83 }
84 *Nexist = k;
85 if (k==0)
86 return NULL;
87 ek = ex = (scfmon)omAlloc0(k * sizeof(scmon));
88 hsecure = (scfmon) omAlloc0(k * sizeof(scmon));
89 for (i = sl; i>0; i--)
90 {
91 if (*si!=NULL)
92 {
93 *ek = (scmon) omAlloc(((currRing->N)+1)*sizeof(int));
94 p_GetExpV(*si, *ek, currRing);
95 ek++;
96 }
97 si++;
98 }
99 for (i = ql; i>0; i--)
100 {
101 if (*qi!=NULL)
102 {
103 *ek = (scmon) omAlloc(((currRing->N)+1)*sizeof(int));
104 p_GetExpV(*qi, *ek, currRing);
105 ek++;
106 }
107 qi++;
108 }
109 memcpy(hsecure, ex, k * sizeof(scmon));
110 return ex;
111}
VAR int hisModule
Definition: hutil.cc:20
#define omAlloc0(size)
Definition: omAllocDecl.h:211
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1518
poly * polyset
Definition: polys.h:259
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
#define id_LmTest(A, lR)
Definition: simpleideals.h:88
#define Q
Definition: sirandom.c:26

◆ hKill()

void hKill ( monf  xmem,
int  Nvar 
)

Definition at line 1010 of file hutil.cc.

1011{
1012 int i;
1013 for (i = Nvar; i!=0; i--)
1014 {
1015 if (xmem[i]->mo!=NULL)
1016 omFreeSize((ADDRESS)xmem[i]->mo, xmem[i]->a * sizeof(scmon));
1017 omFreeSize((ADDRESS)xmem[i], LEN_MON);
1018 }
1019 omFreeSize((ADDRESS)xmem, (Nvar + 1) * sizeof(monp));
1020}

◆ hLex2R()

void hLex2R ( scfmon  rad,
int  e1,
int  a2,
int  e2,
varset  var,
int  Nvar,
scfmon  w 
)

Definition at line 880 of file hutil.cc.

882{
883 int j0 = 0, j = 0, i = a2, k, k1;
884 scmon n, o;
885 if (!e1)
886 {
887 for (; i < e2; i++)
888 rad[i - a2] = rad[i];
889 return;
890 }
891 else if (i == e2)
892 return;
893 n = rad[j];
894 o = rad[i];
895 loop
896 {
897 k = Nvar;
898 loop
899 {
900 k1 = var[k];
901 if (!o[k1] && n[k1])
902 {
903 w[j0] = o;
904 j0++;
905 i++;
906 if (i < e2)
907 {
908 o = rad[i];
909 break;
910 }
911 else
912 {
913 for (; j < e1; j++)
914 {
915 w[j0] = rad[j];
916 j0++;
917 }
918 memcpy(rad, w, (e1 + e2 - a2) * sizeof(scmon));
919 return;
920 }
921 }
922 else if (o[k1] && !n[k1])
923 {
924 w[j0] = n;
925 j0++;
926 j++;
927 if (j < e1)
928 {
929 n = rad[j];
930 break;
931 }
932 else
933 {
934 for (; i < e2; i++)
935 {
936 w[j0] = rad[i];
937 j0++;
938 }
939 memcpy(rad, w, (e1 + e2 - a2) * sizeof(scmon));
940 return;
941 }
942 }
943 k--;
944 }
945 }
946}

◆ hLex2S()

void hLex2S ( scfmon  stc,
int  e1,
int  a2,
int  e2,
varset  var,
int  Nvar,
scfmon  w 
)

Definition at line 812 of file hutil.cc.

814{
815 int j0 = 0, j = 0, i = a2, k, k1;
816 scmon n, o;
817 if (!e1)
818 {
819 for (; i < e2; i++)
820 rad[i - a2] = rad[i];
821 return;
822 } else if (i == e2)
823 return;
824 n = rad[j];
825 o = rad[i];
826 loop
827 {
828 k = Nvar;
829 loop
830 {
831 k1 = var[k];
832 if (o[k1] < n[k1])
833 {
834 w[j0] = o;
835 j0++;
836 i++;
837 if (i < e2)
838 {
839 o = rad[i];
840 break;
841 }
842 else
843 {
844 for (; j < e1; j++)
845 {
846 w[j0] = rad[j];
847 j0++;
848 }
849 memcpy(rad, w, (e1 + e2 - a2) * sizeof(scmon));
850 return;
851 }
852 }
853 else if (o[k1] > n[k1])
854 {
855 w[j0] = n;
856 j0++;
857 j++;
858 if (j < e1)
859 {
860 n = rad[j];
861 break;
862 }
863 else
864 {
865 for (; i < e2; i++)
866 {
867 w[j0] = rad[i];
868 j0++;
869 }
870 memcpy(rad, w, (e1 + e2 - a2) * sizeof(scmon));
871 return;
872 }
873 }
874 k--;
875 }
876 }
877}

◆ hLexR()

void hLexR ( scfmon  rad,
int  Nrad,
varset  var,
int  Nvar 
)

Definition at line 565 of file hutil.cc.

566{
567 int j = 1, i = 0, k, k1;
568 scmon n, o;
569 if (Nrad < 2)
570 return;
571 n = rad[j];
572 o = rad[0];
573 k = Nvar;
574 loop
575 {
576 k1 = var[k];
577 if (!o[k1] && n[k1])
578 {
579 i++;
580 if (i < j)
581 {
582 o = rad[i];
583 k = Nvar;
584 }
585 else
586 {
587 j++;
588 if (j < Nrad)
589 {
590 i = 0;
591 o = rad[0];
592 n = rad[j];
593 k = Nvar;
594 }
595 else
596 return;
597 }
598 }
599 else if (o[k1] && !n[k1])
600 {
601 for (k = j; k > i; k--)
602 rad[k] = rad[k - 1];
603 rad[i] = n;
604 j++;
605 if (j < Nrad)
606 {
607 i = 0;
608 o = rad[0];
609 n = rad[j];
610 k = Nvar;
611 }
612 else
613 return;
614 }
615 else
616 k--;
617 }
618}

◆ hLexS()

void hLexS ( scfmon  stc,
int  Nstc,
varset  var,
int  Nvar 
)

Definition at line 506 of file hutil.cc.

507{
508 if (Nstc < 2)
509 return;
510 int j = 1, i = 0;
511 scmon n = stc[j];
512 scmon o = stc[0];
513 int k = Nvar;
514 loop
515 {
516 int k1 = var[k];
517 if (o[k1] < n[k1])
518 {
519 i++;
520 if (i < j)
521 {
522 o = stc[i];
523 k = Nvar;
524 }
525 else
526 {
527 j++;
528 if (j < Nstc)
529 {
530 i = 0;
531 o = stc[0];
532 n = stc[j];
533 k = Nvar;
534 }
535 else
536 return;
537 }
538 }
539 else if (o[k1] > n[k1])
540 {
541 int tmp_k;
542 for (tmp_k = j; tmp_k > i; tmp_k--)
543 stc[tmp_k] = stc[tmp_k - 1];
544 stc[i] = n;
545 j++;
546 if (j < Nstc)
547 {
548 i = 0;
549 o = stc[0];
550 n = stc[j];
551 k = Nvar;
552 }
553 else
554 return;
555 }
556 else
557 {
558 k--;
559 if (k<=0) return;
560 }
561 }
562}

◆ hOrdSupp()

void hOrdSupp ( scfmon  stc,
int  Nstc,
varset  var,
int  Nvar 
)

Definition at line 202 of file hutil.cc.

203{
204 int i, i1, j, jj, k, l;
205 int x;
206 scmon temp, count;
207 float o, h, g, *v1;
208
209 v1 = (float *)omAlloc(Nvar * sizeof(float));
210 temp = (int *)omAlloc(Nstc * sizeof(int));
211 count = (int *)omAlloc(Nstc * sizeof(int));
212 for (i = 1; i <= Nvar; i++)
213 {
214 i1 = var[i];
215 *temp = stc[0][i1];
216 *count = 1;
217 jj = 1;
218 for (j = 1; j < Nstc; j++)
219 {
220 x = stc[j][i1];
221 k = 0;
222 loop
223 {
224 if (x > temp[k])
225 {
226 k++;
227 if (k == jj)
228 {
229 temp[k] = x;
230 count[k] = 1;
231 jj++;
232 break;
233 }
234 }
235 else if (x < temp[k])
236 {
237 for (l = jj; l > k; l--)
238 {
239 temp[l] = temp[l-1];
240 count[l] = count[l-1];
241 }
242 temp[k] = x;
243 count[k] = 1;
244 jj++;
245 break;
246 }
247 else
248 {
249 count[k]++;
250 break;
251 }
252 }
253 }
254 h = 0.0;
255 o = (float)Nstc/(float)jj;
256 for(j = 0; j < jj; j++)
257 {
258 g = (float)count[j];
259 if (g > o)
260 g -= o;
261 else
262 g = o - g;
263 if (g > h)
264 h = g;
265 }
266 v1[i-1] = h * (float)jj;
267 }
268 omFreeSize((ADDRESS)count, Nstc * sizeof(int));
269 omFreeSize((ADDRESS)temp, Nstc * sizeof(int));
270 for (i = 1; i < Nvar; i++)
271 {
272 i1 = var[i+1];
273 h = v1[i];
274 j = 0;
275 loop
276 {
277 if (h > v1[j])
278 {
279 for (l = i; l > j; l--)
280 {
281 v1[l] = v1[l-1];
282 var[l+1] = var[l];
283 }
284 v1[j] = h;
285 var[j+1] = i1;
286 break;
287 }
288 j++;
289 if (j == i)
290 break;
291 }
292 }
293 omFreeSize((ADDRESS)v1, Nvar * sizeof(float));
294}
int l
Definition: cfEzgcd.cc:100
g
Definition: cfModGcd.cc:4090
STATIC_VAR Poly * h
Definition: janet.cc:971
int status int void size_t count
Definition: si_signals.h:59

◆ hPure()

void hPure ( scfmon  stc,
int  a,
int *  Nstc,
varset  var,
int  Nvar,
scmon  pure,
int *  Npure 
)

Definition at line 621 of file hutil.cc.

623{
624 int nc = *Nstc, np = 0, nq = 0, j, i, i1, c, l;
625 scmon x;
626 for (j = a; j < nc; j++)
627 {
628 x = stc[j];
629 i = Nvar;
630 c = 2;
631 l = 0;
632 loop
633 {
634 i1 = var[i];
635 if (x[i1])
636 {
637 c--;
638 if (!c)
639 {
640 l = 0;
641 break;
642 }
643 else if (c == 1)
644 l = i1;
645 }
646 i--;
647 if (!i)
648 break;
649 }
650 if (l)
651 {
652 if (!pure[l])
653 {
654 np++;
655 pure[l] = x[l];
656 }
657 else if (x[l] < pure[l])
658 pure[l] = x[l];
659 stc[j] = NULL;
660 nq++;
661 }
662 }
663 *Npure = np;
664 if (nq!=0)
665 {
666 *Nstc -= nq;
667 hShrink(stc, a, nc);
668 }
669}

◆ hRadical()

void hRadical ( scfmon  rad,
int *  Nrad,
int  Nvar 
)

Definition at line 411 of file hutil.cc.

412{
413 int nc = *Nrad, z = 0, i, j, k;
414 scmon n, o;
415 if (nc < 2)
416 return;
417 i = 0;
418 j = 1;
419 n = rad[j];
420 o = rad[0];
421 k = Nvar;
422 loop
423 {
424 if ((o[k]!=0) && (n[k]==0))
425 {
426 loop
427 {
428 k--;
429 if (k==0)
430 {
431 rad[i] = NULL;
432 z++;
433 break;
434 }
435 else
436 {
437 if ((o[k]==0) && (n[k]!=0))
438 break;
439 }
440 }
441 k = Nvar;
442 }
443 else if (!o[k] && n[k])
444 {
445 loop
446 {
447 k--;
448 if (!k)
449 {
450 rad[j] = NULL;
451 z++;
452 break;
453 }
454 else
455 {
456 if (o[k] && !n[k])
457 break;
458 }
459 }
460 k = Nvar;
461 }
462 else
463 {
464 k--;
465 if (!k)
466 {
467 rad[j] = NULL;
468 z++;
469 k = Nvar;
470 }
471 }
472 if (k == Nvar)
473 {
474 if (!rad[j])
475 i = j - 1;
476 loop
477 {
478 i++;
479 if (i == j)
480 {
481 i = -1;
482 j++;
483 if (j < nc)
484 n = rad[j];
485 else
486 {
487 if (z)
488 {
489 *Nrad -= z;
490 hShrink(rad, 0, nc);
491 }
492 return;
493 }
494 }
495 else if (rad[i])
496 {
497 o = rad[i];
498 break;
499 }
500 }
501 }
502 }
503}

◆ hStaircase()

void hStaircase ( scfmon  stc,
int *  Nstc,
varset  var,
int  Nvar 
)

Definition at line 313 of file hutil.cc.

314{
315 int nc = *Nstc;
316 if (nc < 2)
317 return;
318 int z = 0;
319 int i = 0;
320 int j = 1;
321 scmon n = stc[1 /*j*/];
322 scmon o = stc[0];
323 int k = Nvar;
324 loop
325 {
326 int k1 = var[k];
327 if (o[k1] > n[k1])
328 {
329 loop
330 {
331 k--;
332 if (k==0)
333 {
334 stc[i] = NULL;
335 z++;
336 break;
337 }
338 else
339 {
340 k1 = var[k];
341 if (o[k1] < n[k1])
342 break;
343 }
344 }
345 k = Nvar;
346 }
347 else if (o[k1] < n[k1])
348 {
349 loop
350 {
351 k--;
352 if (k==0)
353 {
354 stc[j] = NULL;
355 z++;
356 break;
357 }
358 else
359 {
360 k1 = var[k];
361 if (o[k1] > n[k1])
362 break;
363 }
364 }
365 k = Nvar;
366 }
367 else
368 {
369 k--;
370 if (k==0)
371 {
372 stc[j] = NULL;
373 z++;
374 k = Nvar;
375 }
376 }
377 if (k == Nvar)
378 {
379 if (stc[j]==NULL)
380 i = j - 1;
381 loop
382 {
383 i++;
384 if (i == j)
385 {
386 i = -1;
387 j++;
388 if (j < nc)
389 n = stc[j];
390 else
391 {
392 if (z!=0)
393 {
394 *Nstc -= z;
395 hShrink(stc, 0, nc);
396 }
397 return;
398 }
399 }
400 else if (stc[i]!=NULL)
401 {
402 o = stc[i];
403 break;
404 }
405 }
406 }
407 }
408}

◆ hStepR()

void hStepR ( scfmon  rad,
int  Nrad,
varset  var,
int  Nvar,
int *  a 
)

Definition at line 974 of file hutil.cc.

975{
976 int k1, i;
977 k1 = var[Nvar];
978 i = 0;
979 loop
980 {
981 if (rad[i][k1])
982 {
983 *a = i;
984 return;
985 }
986 i++;
987 if (i == Nrad)
988 {
989 *a = i;
990 return;
991 }
992 }
993}

◆ hStepS()

void hStepS ( scfmon  stc,
int  Nstc,
varset  var,
int  Nvar,
int *  a,
int *  x 
)

Definition at line 949 of file hutil.cc.

950{
951 int k1, i;
952 int y;
953 k1 = var[Nvar];
954 y = *x;
955 i = *a;
956 loop
957 {
958 if (y < stc[i][k1])
959 {
960 *a = i;
961 *x = stc[i][k1];
962 return;
963 }
964 i++;
965 if (i == Nstc)
966 {
967 *a = i;
968 return;
969 }
970 }
971}
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:53

◆ hSupp()

void hSupp ( scfmon  stc,
int  Nstc,
varset  var,
int *  Nvar 
)

Definition at line 174 of file hutil.cc.

175{
176 int nv, i0, i1, i, j;
177 nv = i0 = *Nvar;
178 i1 = 0;
179 for (i = 1; i <= nv; i++)
180 {
181 j = 0;
182 loop
183 {
184 if (stc[j][i]>0)
185 {
186 i1++;
187 var[i1] = i;
188 break;
189 }
190 j++;
191 if (j == Nstc)
192 {
193 var[i0] = i;
194 i0--;
195 break;
196 }
197 }
198 }
199 *Nvar = i1;
200}

◆ RightColonOperation()

ideal RightColonOperation ( ideal  i,
poly  w,
int  lV 
)

Definition at line 1673 of file hilb.cc.

1674{
1675 /*
1676 * This returns right colon ideal of a monomial two-sided ideal of
1677 * the free associative algebra with respect to a monomial 'w'
1678 * (S:_R w).
1679 */
1680 S = minimalMonomialGenSet(S);
1681 ideal Iw = idInit(1,1);
1682 Iw = colonIdeal(S, w, lV, Iw, 0);
1683 return (Iw);
1684}

◆ slicehilb()

void slicehilb ( ideal  I)

Definition at line 656 of file hilb.cc.

657{
658 //printf("Adi changes are here: \n");
659 int i, NNN = 0;
660 int steps = 0, prune = 0, moreprune = 0;
661 mpz_ptr hilbertcoef;
662 int *hilbpower;
663 ideal S = idInit(1,1);
664 poly q = p_One(currRing);
665 ideal X = idInit(1,1);
666 X->m[0]=p_One(currRing);
667 for(i=1;i<=currRing->N;i++)
668 {
669 p_SetExp(X->m[0],i,1,currRing);
670 }
671 p_Setm(X->m[0],currRing);
672 I = id_Mult(I,X,currRing);
673 ideal Itmp = SortByDeg(I);
675 I = Itmp;
676 //printf("\n-------------RouneSlice--------------\n");
677 rouneslice(I,S,q,X->m[0],prune, moreprune, steps, NNN, hilbertcoef, hilbpower);
679 p_Delete(&q,currRing);
680 //printf("\nIn total Prune got rid of %i elements\n",prune);
681 //printf("\nIn total More Prune got rid of %i elements\n",moreprune);
682 //printf("\nSteps of rouneslice: %i\n\n", steps);
683 printf("\n// %8d t^0",1);
684 for(i = 0; i<NNN; i++)
685 {
686 if(mpz_sgn(&hilbertcoef[i])!=0)
687 {
688 gmp_printf("\n// %8Zd t^%d",&hilbertcoef[i],hilbpower[i]);
689 }
690 }
691 PrintLn();
692 omFreeSize(hilbertcoef, (NNN)*sizeof(mpz_t));
693 omFreeSize(hilbpower, (NNN)*sizeof(int));
694 //printf("\n-------------------------------------\n");
695}
static void rouneslice(ideal I, ideal S, poly q, poly x, int &prune, int &moreprune, int &steps, int &NNN, mpz_ptr &hilbertcoef, int *&hilbpower)
Definition: hilb.cc:500
static ideal SortByDeg(ideal I)
Definition: hilb.cc:167
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:899
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
ideal id_Mult(ideal h1, ideal h2, const ring R)
h1 * h2 one h_i must be an ideal (with at least one column) the other h_i may be a module (with no co...
void prune(Variable &alpha)
Definition: variable.cc:261

Variable Documentation

◆ hCo

EXTERN_VAR int hCo

Definition at line 47 of file hutil.h.

◆ hexist

Definition at line 39 of file hutil.h.

◆ hisModule

EXTERN_VAR int hisModule

Definition at line 44 of file hutil.h.

◆ hMu

EXTERN_VAR long hMu

Definition at line 48 of file hutil.h.

◆ hMu2

EXTERN_VAR int hMu2

Definition at line 47 of file hutil.h.

◆ hNexist

EXTERN_VAR int hNexist

Definition at line 42 of file hutil.h.

◆ hNpure

EXTERN_VAR int hNpure

Definition at line 42 of file hutil.h.

◆ hNrad

EXTERN_VAR int hNrad

Definition at line 42 of file hutil.h.

◆ hNstc

EXTERN_VAR int hNstc

Definition at line 42 of file hutil.h.

◆ hNvar

EXTERN_VAR int hNvar

Definition at line 42 of file hutil.h.

◆ hpur0

Definition at line 40 of file hutil.h.

◆ hpure

Definition at line 40 of file hutil.h.

◆ hrad

Definition at line 39 of file hutil.h.

◆ hsel

Definition at line 41 of file hutil.h.

◆ hstc

Definition at line 39 of file hutil.h.

◆ hvar

Definition at line 41 of file hutil.h.

◆ hwork

Definition at line 39 of file hutil.h.

◆ indlist_bin

EXTERN_VAR omBin indlist_bin

Definition at line 37 of file hutil.h.

◆ ISet

Definition at line 46 of file hutil.h.

◆ JSet

Definition at line 46 of file hutil.h.

◆ radmem

EXTERN_VAR monf radmem

Definition at line 43 of file hutil.h.

◆ stcmem

EXTERN_VAR monf stcmem

Definition at line 43 of file hutil.h.