Loading...
Searching...
No Matches
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 scmon * | scfmon
typedef int * | varset
typedef monh * | monp
typedef monp * | monf
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 | 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.

{
int k = 0;
scfmon ex = exist, co = stc;
int i;
for (i = Nexist; i>0; i--)
{
if (((**ex) == 0) || ((**ex) == ak))
{
*co = *ex;
co++;
k++;
}
ex++;
}
*Nstc = k;
}
i
int i
Definition cfEzgcd.cc:132
k
int k
Definition cfEzgcd.cc:99
scfmon
scmon * scfmon
Definition hutil.h:15

## hCreate()

monf hCreate | ( | int | Nvar | ) |

Definition at line 996 of file hutil.cc.

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

## hDegreeSeries()

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

Definition at line 106 of file hilb.cc.

{
int i, j, k;
int m;
*co = *mu = 0;
if ((s1 == NULL) || (s2 == NULL))
return;
i = s1->length();
j = s2->length();
if (j > i)
return;
m = 0;
for(k=j-2; k>=0; k--)
m += (*s2)[k];
*mu = m;
*co = i - j;
}
m
int m
Definition cfEzgcd.cc:128
intvec::length
int length() const
Definition intvec.h:95
j
int j
Definition facHensel.cc:110
mu
static matrix mu(matrix A, const ring R)
Definition matpol.cc:2028

## hDelete()

void hDelete | ( | scfmon | ev,
|  | int | ev_length )

Definition at line 140 of file hutil.cc.

{
int i;
if (ev_length>0)
{
for (i=ev_length-1;i>=0;i--)
omFreeSize(hsecure[i],((currRing->N)+1)*sizeof(int));
omFreeSize(hsecure, ev_length*sizeof(scmon));
omFreeSize(ev, ev_length*sizeof(scmon));
}
}
hsecure
STATIC_VAR scfmon hsecure
Definition hutil.cc:29
scmon
int * scmon
Definition hutil.h:14
omFreeSize
#define omFreeSize(addr, size)
Definition omAllocDecl.h:260
currRing
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.

{
int dn, iv, rad0, b, c, x;
scmon pn;
scfmon rn;
if (Nrad < 2)
{
dn = Npure + Nrad;
if (dn < hCo)
hCo = dn;
return;
}
if (Npure+1 >= hCo)
return;
iv = Nvar;
while(pure[var[iv]]) iv--;
hStepR(rad, Nrad, var, iv, &rad0);
if (rad0!=0)
{
iv--;
if (rad0 < Nrad)
{
pn = hGetpure(pure);
rn = hGetmem(Nrad, rad, radmem[iv]);
hDimSolve(pn, Npure + 1, rn, rad0, var, iv);
b = rad0;
c = Nrad;
hElimR(rn, &rad0, b, c, var, iv);
hPure(rn, b, &c, var, iv, pn, &x);
hLex2R(rn, rad0, b, c, var, iv, hwork);
rad0 += (c - b);
hDimSolve(pn, Npure + x, rn, rad0, var, iv);
}
else
{
hDimSolve(pure, Npure, rad, Nrad, var, iv);
}
}
else
hCo = Npure + 1;
}
x
Variable x
Definition cfModGcd.cc:4090
b
CanonicalForm b
Definition cfModGcd.cc:4111
hCo
VAR int hCo
Definition hdegree.cc:27
hDimSolve
void hDimSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition hdegree.cc:35
hGetmem
scfmon hGetmem(int lm, scfmon old, monp monmem)
Definition hutil.cc:1023
hPure
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition hutil.cc:621
hwork
VAR scfmon hwork
Definition hutil.cc:16
hStepR
void hStepR(scfmon rad, int Nrad, varset var, int Nvar, int *a)
Definition hutil.cc:974
hLex2R
void hLex2R(scfmon rad, int e1, int a2, int e2, varset var, int Nvar, scfmon w)
Definition hutil.cc:880
hElimR
void hElimR(scfmon rad, int *e1, int a2, int e2, varset var, int Nvar)
Definition hutil.cc:742
radmem
VAR monf radmem
Definition hutil.cc:21
hGetpure
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.

{
int nc = *e1, z = 0, i, j, k, k1;
scmon n, o;
if (!nc || (a2 == e2))
return;
j = 0;
i = a2;
o = rad[i];
n = rad[0];
k = Nvar;
loop
{
k1 = var[k];
if (o[k1] && !n[k1])
{
k = Nvar;
i++;
if (i < e2)
o = rad[i];
else
{
j++;
if (j < nc)
{
i = a2;
o = rad[i];
n = rad[j];
}
else
{
if (z!=0)
{
*e1 -= z;
hShrink(rad, 0, nc);
}
return;
}
}
}
else
{
k--;
if (!k)
{
rad[j] = NULL;
z++;
j++;
if (j < nc)
{
i = a2;
o = rad[i];
n = rad[j];
k = Nvar;
}
else
{
if (z!=0)
{
*e1 -= z;
hShrink(rad, 0, nc);
}
return;
}
}
}
}
}
hShrink
static void hShrink(scfmon co, int a, int Nco)
Definition hutil.cc:297
loop
#define loop
Definition structs.h:71

## hElimS()

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

Definition at line 672 of file hutil.cc.

{
int nc = *e1, z = 0, i, j, k, k1;
scmon n, o;
if (!nc || (a2 == e2))
return;
j = 0;
i = a2;
o = stc[i];
n = stc[0];
k = Nvar;
loop
{
k1 = var[k];
if (o[k1] > n[k1])
{
k = Nvar;
i++;
if (i < e2)
o = stc[i];
else
{
j++;
if (j < nc)
{
i = a2;
o = stc[i];
n = stc[j];
}
else
{
if (z!=0)
{
*e1 -= z;
hShrink(stc, 0, nc);
}
return;
}
}
}
else
{
k--;
if (k==0)
{
stc[j] = NULL;
z++;
j++;
if (j < nc)
{
i = a2;
o = stc[i];
n = stc[j];
k = Nvar;
}
else
{
if (z!=0)
{
*e1 -= z;
hShrink(stc, 0, nc);
}
return;
}
}
}
}
}

## hGetmem()

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

Definition at line 1023 of file hutil.cc.

{
scfmon x = monmem->mo;
int lx = monmem->a;
if ((x==NULL) || (lm > lx))
{
/* according to http://www.singular.uni-kl.de:8002/trac/ticket/463#comment:4
* we need to work around a compiler bug:
* if ((x!=NULL)&&(lx>0)) omFreeSize((ADDRESS)x, lx * sizeof(scmon));
*/
if (x!=NULL) if (lx>0) omFreeSize((ADDRESS)x, lx * sizeof(scmon));
monmem->mo = x = (scfmon)omAlloc(lm * sizeof(scmon));
monmem->a = lm;
}
memcpy(x, old, lm * sizeof(scmon));
return x;
}
ADDRESS
void * ADDRESS
Definition auxiliary.h:120

## hGetpure()

scmon hGetpure | ( | scmon | p | ) |

Definition at line 1052 of file hutil.cc.

{
scmon p1 = p;
scmon pn;
p1++;
pn = p1;
pn += (currRing->N);
memcpy(pn, p1, (currRing->N) * sizeof(int));
return pn - 1;
}
p
int p
Definition cfModGcd.cc:4086

## HilbertSeries_OrbitData()

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

Definition at line 770 of file hilb.cc.

{
/* new story:
no lV is needed, i.e. it is to be determined
the rest is extracted from the interface input list in extra.cc and makes the input of this proc
called from extra.cc
*/
/*
* This is based on iterative right colon operations on a
* two-sided monomial ideal of the free associative algebra.
* The algorithm terminates for those monomial ideals
* whose monomials define "regular formal languages",
* that is, all monomials of the input ideal can be obtained
* from finite languages by applying finite number of
* rational operations.
*/
int trInd;
S = minimalMonomialGenSet(S);
if( !idIs0(S) && p_Totaldegree(S->m[0], currRing)==0)
{
PrintS("Hilbert Series:\n 0\n");
return;
}
int (*POS)(ideal, poly, std::vector<ideal>, std::vector<poly>, int, int);
if(trunDegHs != 0)
{
Print("\nTruncation degree = %d\n",trunDegHs);
POS=&positionInOrbitTruncationCase;
}
else
{
if(IG_CASE)
{
if(idIs0(S))
{
WerrorS("wrong input: it is not an infinitely gen. case");
return;
}
trInd = p_Totaldegree(S->m[IDELEMS(S)-1], currRing);
POS = &positionInOrbit_IG_Case;
}
else
POS = &positionInOrbit_FG_Case;
}
std::vector<ideal > idorb;
std::vector< poly > polist;
ideal orb_init = idInit(1, 1);
idorb.push_back(orb_init);
polist.push_back( p_One(currRing));
std::vector< std::vector<int> > posMat;
std::vector<int> posRow(lV,0);
std::vector<int> C;
int ds, is, ps;
unsigned long lpcnt = 0;
poly w, wi;
ideal Jwi;
while(lpcnt < idorb.size())
{
w = NULL;
w = polist[lpcnt];
if(lpcnt >= 1 && idIs0(idorb[lpcnt]) == FALSE)
{
if(p_Totaldegree(idorb[lpcnt]->m[0], currRing) != 0)
{
C.push_back(1);
}
else
C.push_back(0);
}
else
{
C.push_back(1);
}
ds = p_Totaldegree(w, currRing);
lpcnt++;
for(is = 1; is <= lV; is++)
{
wi = NULL;
//make new copy 'wi' of word w=polist[lpcnt]
//and update it (for the colon operation).
//if corresponding to wi, right colon operation gives
//a new (right colon) ideal of S,
//keep 'wi' in the polist else delete it
wi = pCopy(w);
p_SetExp(wi, (ds*lV)+is, 1, currRing);
p_Setm(wi, currRing);
Jwi = NULL;
//Jwi stores (right) colon ideal of S w.r.t. word
//wi if colon operation gives a new ideal place it
//in the vector of ideals 'idorb'
//otherwise delete it
Jwi = idInit(1,1);
Jwi = colonIdeal(S, wi, lV, Jwi, trunDegHs);
ps = (*POS)(Jwi, wi, idorb, polist, trInd, trunDegHs);
if(ps == 0) // finds a new ideal
{
posRow[is-1] = idorb.size();
idorb.push_back(Jwi);
polist.push_back(wi);
}
else // ideal is already there in the set
{
posRow[is-1]=ps-1;
idDelete(&Jwi);
pDelete(&wi);
}
}
posMat.push_back(posRow);
posRow.resize(lV,0);
}
int lO = C.size();//size of the orbit
PrintLn();
Print("maximal length of words = %ld\n", p_Totaldegree(polist[lO-1], currRing));
Print("\nlength of the Orbit = %d", lO);
PrintLn();
if(odp)
{
Print("words description of the Orbit: \n");
for(is = 0; is < lO; is++)
{
pWrite0(polist[is]);
PrintS(" ");
}
PrintLn();
PrintS("\nmaximal degree, #(sum_j R(w,w_j))");
PrintLn();
for(is = 0; is < lO; is++)
{
if(idIs0(idorb[is]))
{
PrintS("NULL\n");
}
else
{
Print("%ld, %d \n",p_Totaldegree(idorb[is]->m[IDELEMS(idorb[is])-1], currRing),IDELEMS(idorb[is]));
}
}
}
for(is = idorb.size()-1; is >= 0; is--)
{
idDelete(&idorb[is]);
}
for(is = polist.size()-1; is >= 0; is--)
{
pDelete(&polist[is]);
}
idorb.resize(0);
polist.resize(0);
int adjMatrix[lO][lO];
memset(adjMatrix, 0, lO*lO*sizeof(int));
int rowCount, colCount;
int tm = 0;
if(!mgrad)
{
for(rowCount = 0; rowCount < lO; rowCount++)
{
for(colCount = 0; colCount < lV; colCount++)
{
tm = posMat[rowCount][colCount];
adjMatrix[rowCount][tm] = adjMatrix[rowCount][tm] + 1;
}
}
}
ring r = currRing;
int npar;
char** tt;
TransExtInfo p;
if(!mgrad)
{
tt=(char**)omAlloc(2*sizeof(char*));
tt[0] = omStrDup("t");
npar = 1;
}
else
{
tt=(char**)omalloc(lV*sizeof(char*));
for(is = 0; is < lV; is++)
{
tt[is] = (char*)omAlloc(12*sizeof(char)); //if required enlarge it later
snprintf (tt[is],12, "t%d", is+1);
}
npar = lV;
}
p.r = rDefault(0, npar, tt);
coeffs cf = nInitChar(n_transExt, &p);
char** xx = (char**)omAlloc(sizeof(char*));
xx[0] = omStrDup("x");
ring R = rDefault(cf, 1, xx);
rChangeCurrRing(R);//rWrite(R);
/*
* matrix corresponding to the orbit of the ideal
*/
matrix mR = mpNew(lO, lO);
matrix cMat = mpNew(lO,1);
poly rc;
if(!mgrad)
{
for(rowCount = 0; rowCount < lO; rowCount++)
{
for(colCount = 0; colCount < lO; colCount++)
{
if(adjMatrix[rowCount][colCount] != 0)
{
MATELEM(mR, rowCount + 1, colCount + 1) = p_ISet(adjMatrix[rowCount][colCount], R);
p_SetCoeff(MATELEM(mR, rowCount + 1, colCount + 1), n_Mult(pGetCoeff(mR->m[lO*rowCount+colCount]),n_Param(1, R->cf), R->cf), R);
}
}
}
}
else
{
for(rowCount = 0; rowCount < lO; rowCount++)
{
for(colCount = 0; colCount < lV; colCount++)
{
rc=NULL;
rc=p_One(R);
p_SetCoeff(rc, n_Mult(pGetCoeff(rc), n_Param(colCount+1, R->cf),R->cf), R);
MATELEM(mR, rowCount +1, posMat[rowCount][colCount]+1)=p_Add_q(rc,MATELEM(mR, rowCount +1, posMat[rowCount][colCount]+1), R);
}
}
}
for(rowCount = 0; rowCount < lO; rowCount++)
{
if(C[rowCount] != 0)
{
MATELEM(cMat, rowCount + 1, 1) = p_ISet(C[rowCount], R);
}
}
matrix u;
unitMatrix(lO, u); //unit matrix
matrix gMat = mp_Sub(u, mR, R);
char* s;
if(odp)
{
PrintS("\nlinear system:\n");
if(!mgrad)
{
for(rowCount = 0; rowCount < lO; rowCount++)
{
Print("H(%d) = ", rowCount+1);
for(colCount = 0; colCount < lV; colCount++)
{
StringSetS(""); nWrite(n_Param(1, R->cf));
s = StringEndS(); PrintS(s);
Print("*"); omFree(s);
Print("H(%d) + ", posMat[rowCount][colCount] + 1);
}
Print(" %d\n", C[rowCount] );
}
PrintS("where H(1) represents the series corresp. to input ideal\n");
PrintS("and i^th summand in the rhs of an eqn. is according\n");
PrintS("to the right colon map corresp. to the i^th variable\n");
}
else
{
for(rowCount = 0; rowCount < lO; rowCount++)
{
Print("H(%d) = ", rowCount+1);
for(colCount = 0; colCount < lV; colCount++)
{
StringSetS(""); nWrite(n_Param(colCount+1, R->cf));
s = StringEndS(); PrintS(s);
Print("*");omFree(s);
Print("H(%d) + ", posMat[rowCount][colCount] + 1);
}
Print(" %d\n", C[rowCount] );
}
PrintS("where H(1) represents the series corresp. to input ideal\n");
}
}
PrintLn();
posMat.resize(0);
C.resize(0);
matrix pMat;
matrix lMat;
matrix uMat;
matrix H_serVec = mpNew(lO, 1);
matrix Hnot;
//std::clock_t start;
//start = std::clock();
luDecomp(gMat, pMat, lMat, uMat, R);
luSolveViaLUDecomp(pMat, lMat, uMat, cMat, H_serVec, Hnot);
//to print system solving time
//if(odp){
//std::cout<<"solving time of the system = "<<(std::clock()-start)/(double)(CLOCKS_PER_SEC / 1000)<<" ms"<<std::endl;}
mp_Delete(&mR, R);
mp_Delete(&u, R);
mp_Delete(&pMat, R);
mp_Delete(&lMat, R);
mp_Delete(&uMat, R);
mp_Delete(&cMat, R);
mp_Delete(&gMat, R);
mp_Delete(&Hnot, R);
//print the Hilbert series and length of the Orbit
PrintLn();
Print("Hilbert series:");
PrintLn();
pWrite(H_serVec->m[0]);
if(!mgrad)
{
omFree(tt[0]);
}
else
{
for(is = lV-1; is >= 0; is--)
omFree( tt[is]);
}
omFree(tt);
omFree(xx[0]);
omFree(xx);
rChangeCurrRing(r);
rKill(R);
}
FALSE
#define FALSE
Definition auxiliary.h:97
cf
CanonicalForm cf
Definition cfModGcd.cc:4091
ip_smatrix::m
poly * m
Definition matpol.h:18
n_Mult
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:639
n_Param
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:778
n_transExt
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition coeffs.h:38
nInitChar
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition numbers.cc:412
Print
#define Print
Definition emacs.cc:80
s
const CanonicalForm int s
Definition facAbsFact.cc:51
w
const CanonicalForm & w
Definition facAbsFact.cc:51
WerrorS
void WerrorS(const char *s)
Definition feFopen.cc:24
positionInOrbitTruncationCase
static int positionInOrbitTruncationCase(ideal I, poly w, std::vector< ideal > idorb, std::vector< poly > polist, int, int trunDegHs)
Definition hilb.cc:481
colonIdeal
static ideal colonIdeal(ideal S, poly w, int lV, ideal Jwi, int trunDegHs)
Definition hilb.cc:735
positionInOrbit_FG_Case
static int positionInOrbit_FG_Case(ideal I, poly, std::vector< ideal > idorb, std::vector< poly >, int, int)
Definition hilb.cc:450
positionInOrbit_IG_Case
static int positionInOrbit_IG_Case(ideal I, poly w, std::vector< ideal > idorb, std::vector< poly > polist, int trInd, int)
Definition hilb.cc:372
minimalMonomialGenSet
static ideal minimalMonomialGenSet(ideal I)
Definition hilb.cc:575
idDelete
#define idDelete(H)
delete an ideal
Definition ideals.h:29
idIs0
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
Definition simpleideals.cc:960
rKill
void rKill(ring r)
Definition ipshell.cc:6181
unitMatrix
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.
Definition linearAlgebra.cc:95
luDecomp
void luDecomp(const matrix aMat, matrix &pMat, matrix &lMat, matrix &uMat, const ring R)
LU-decomposition of a given (m x n)-matrix.
Definition linearAlgebra.cc:103
luSolveViaLUDecomp
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...
Definition linearAlgebra.cc:377
mp_Delete
void mp_Delete(matrix *a, const ring r)
Definition matpol.cc:874
mp_Sub
matrix mp_Sub(matrix a, matrix b, const ring R)
Definition matpol.cc:189
mpNew
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition matpol.cc:37
MATELEM
#define MATELEM(mat, i, j)
1-based access to matrix
Definition matpol.h:29
matrix
ip_smatrix * matrix
Definition matpol.h:43
pGetCoeff
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition monomials.h:44
coeffs
The main handler for Singular numbers which are suitable for Singular polynomials.
nWrite
#define nWrite(n)
Definition numbers.h:29
omStrDup
#define omStrDup(s)
Definition omAllocDecl.h:263
omalloc
#define omalloc(size)
Definition omAllocDecl.h:228
omFree
#define omFree(addr)
Definition omAllocDecl.h:261
p_ISet
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition p_polys.cc:1298
p_One
poly p_One(const ring r)
Definition p_polys.cc:1314
p_Add_q
static poly p_Add_q(poly p, poly q, const ring r)
Definition p_polys.h:938
p_SetExp
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:490
p_Setm
static void p_Setm(poly p, const ring r)
Definition p_polys.h:235
p_SetCoeff
static number p_SetCoeff(poly p, number n, ring r)
Definition p_polys.h:414
p_Totaldegree
static long p_Totaldegree(poly p, const ring r)
Definition p_polys.h:1528
rChangeCurrRing
void rChangeCurrRing(ring r)
Definition polys.cc:16
pDelete
#define pDelete(p_ptr)
Definition polys.h:187
pWrite0
void pWrite0(poly p)
Definition polys.h:310
pWrite
void pWrite(poly p)
Definition polys.h:309
pCopy
#define pCopy(p)
return a copy of the poly
Definition polys.h:186
StringSetS
void StringSetS(const char *st)
Definition reporter.cc:128
PrintS
void PrintS(const char *s)
Definition reporter.cc:288
StringEndS
char * StringEndS()
Definition reporter.cc:151
PrintLn
void PrintLn()
Definition reporter.cc:314
rDefault
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:103
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition simpleideals.cc:35
IDELEMS
#define IDELEMS(i)
Definition simpleideals.h:23
R
#define R
Definition sirandom.c:27
TransExtInfo
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 562 of file hdegree.cc.

{
int dn, iv, rad0, b, c, x;
scmon pn;
scfmon rn;
if (Nrad < 2)
{
dn = Npure + Nrad;
if (dn > hCo)
{
if (!Nrad)
hCheckIndep(pure);
else
{
pn = *rad;
for (iv = Nvar; iv; iv--)
{
x = var[iv];
if (pn[x])
{
pure[x] = 1;
hCheckIndep(pure);
pure[x] = 0;
}
}
}
}
return;
}
iv = Nvar;
while(pure[var[iv]]) iv--;
hStepR(rad, Nrad, var, iv, &rad0);
iv--;
if (rad0 < Nrad)
{
pn = hGetpure(pure);
rn = hGetmem(Nrad, rad, radmem[iv]);
pn[var[iv + 1]] = 1;
hIndAllMult(pn, Npure + 1, rn, rad0, var, iv);
pn[var[iv + 1]] = 0;
b = rad0;
c = Nrad;
hElimR(rn, &rad0, b, c, var, iv);
hPure(rn, b, &c, var, iv, pn, &x);
hLex2R(rn, rad0, b, c, var, iv, hwork);
rad0 += (c - b);
hIndAllMult(pn, Npure + x, rn, rad0, var, iv);
}
else
{
hIndAllMult(pure, Npure, rad, Nrad, var, iv);
}
}
hCheckIndep
static void hCheckIndep(scmon pure)
Definition hdegree.cc:541
hIndAllMult
void hIndAllMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition hdegree.cc:562

## hIndMult()

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

Definition at line 382 of file hdegree.cc.

{
int dn, iv, rad0, b, c, x;
scmon pn;
scfmon rn;
if (Nrad < 2)
{
dn = Npure + Nrad;
if (dn == hCo)
{
if (Nrad==0)
hIndep(pure);
else
{
pn = *rad;
for (iv = Nvar; iv!=0; iv--)
{
x = var[iv];
if (pn[x])
{
pure[x] = 1;
hIndep(pure);
pure[x] = 0;
}
}
}
}
return;
}
iv = Nvar;
dn = Npure+1;
if (dn >= hCo)
{
if (dn > hCo)
return;
loop
{
if(!pure[var[iv]])
{
if(hNotZero(rad, Nrad, var, iv))
{
pure[var[iv]] = 1;
hIndep(pure);
pure[var[iv]] = 0;
}
}
iv--;
if (!iv)
return;
}
}
while(pure[var[iv]]) iv--;
hStepR(rad, Nrad, var, iv, &rad0);
iv--;
if (rad0 < Nrad)
{
pn = hGetpure(pure);
rn = hGetmem(Nrad, rad, radmem[iv]);
pn[var[iv + 1]] = 1;
hIndMult(pn, Npure + 1, rn, rad0, var, iv);
pn[var[iv + 1]] = 0;
b = rad0;
c = Nrad;
hElimR(rn, &rad0, b, c, var, iv);
hPure(rn, b, &c, var, iv, pn, &x);
hLex2R(rn, rad0, b, c, var, iv, hwork);
rad0 += (c - b);
hIndMult(pn, Npure + x, rn, rad0, var, iv);
}
else
{
hIndMult(pure, Npure, rad, Nrad, var, iv);
}
}
hIndMult
void hIndMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition hdegree.cc:382
hNotZero
static BOOLEAN hNotZero(scfmon rad, int Nrad, varset var, int Nvar)
Definition hdegree.cc:353
hIndep
static void hIndep(scmon pure)
Definition hdegree.cc:368

## hInit()

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

Definition at line 31 of file hutil.cc.

{
id_LmTest(S, currRing);
if (Q!=NULL) id_LmTest(Q, currRing);
hisModule = id_RankFreeModule(S, currRing);
if (hisModule < 0)
hisModule = 0;
int sl, ql, i, k = 0;
polyset si, qi, ss;
scfmon ex, ek;
if (S!=NULL)
{
si = S->m;
sl = IDELEMS(S);
}
else
{
si = NULL;
sl = 0;
}
if (Q!=NULL)
{
qi = Q->m;
ql = IDELEMS(Q);
}
else
{
qi = NULL;
ql = 0;
}
if ((sl + ql) == 0)
{
*Nexist = 0;
return NULL;
}
ss = si;
for (i = sl; i>0; i--)
{
if (*ss!=0)
k++;
ss++;
}
ss = qi;
for (i = ql; i>0; i--)
{
if (*ss!=0)
k++;
ss++;
}
*Nexist = k;
if (k==0)
return NULL;
ek = ex = (scfmon)omAlloc0(k * sizeof(scmon));
hsecure = (scfmon) omAlloc0(k * sizeof(scmon));
for (i = sl; i>0; i--)
{
if (*si!=NULL)
{
*ek = (scmon) omAlloc(((currRing->N)+1)*sizeof(int));
p_GetExpV(*si, *ek, currRing);
ek++;
}
si++;
}
for (i = ql; i>0; i--)
{
if (*qi!=NULL)
{
*ek = (scmon) omAlloc(((currRing->N)+1)*sizeof(int));
p_GetExpV(*qi, *ek, currRing);
ek++;
}
qi++;
}
memcpy(hsecure, ex, k * sizeof(scmon));
return ex;
}
hisModule
VAR int hisModule
Definition hutil.cc:20
omAlloc0
#define omAlloc0(size)
Definition omAllocDecl.h:211
p_GetExpV
static void p_GetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1541
polyset
poly * polyset
Definition polys.h:260
id_RankFreeModule
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
Definition simpleideals.cc:992
id_LmTest
#define id_LmTest(A, lR)
Definition simpleideals.h:90
Q
#define Q
Definition sirandom.c:26

## hKill()

void hKill | ( | monf | xmem,
|  | int | Nvar )

Definition at line 1010 of file hutil.cc.

{
int i;
for (i = Nvar; i!=0; i--)
{
if (xmem[i]->mo!=NULL)
omFreeSize((ADDRESS)xmem[i]->mo, xmem[i]->a * sizeof(scmon));
omFreeSize((ADDRESS)xmem[i], LEN_MON);
}
omFreeSize((ADDRESS)xmem, (Nvar + 1) * sizeof(monp));
}

## 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.

{
int j0 = 0, j = 0, i = a2, k, k1;
scmon n, o;
if (!e1)
{
for (; i < e2; i++)
rad[i - a2] = rad[i];
return;
}
else if (i == e2)
return;
n = rad[j];
o = rad[i];
loop
{
k = Nvar;
loop
{
k1 = var[k];
if (!o[k1] && n[k1])
{
w[j0] = o;
j0++;
i++;
if (i < e2)
{
o = rad[i];
break;
}
else
{
for (; j < e1; j++)
{
w[j0] = rad[j];
j0++;
}
memcpy(rad, w, (e1 + e2 - a2) * sizeof(scmon));
return;
}
}
else if (o[k1] && !n[k1])
{
w[j0] = n;
j0++;
j++;
if (j < e1)
{
n = rad[j];
break;
}
else
{
for (; i < e2; i++)
{
w[j0] = rad[i];
j0++;
}
memcpy(rad, w, (e1 + e2 - a2) * sizeof(scmon));
return;
}
}
k--;
}
}
}

## 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.

{
int j0 = 0, j = 0, i = a2, k, k1;
scmon n, o;
if (!e1)
{
for (; i < e2; i++)
rad[i - a2] = rad[i];
return;
} else if (i == e2)
return;
n = rad[j];
o = rad[i];
loop
{
k = Nvar;
loop
{
k1 = var[k];
if (o[k1] < n[k1])
{
w[j0] = o;
j0++;
i++;
if (i < e2)
{
o = rad[i];
break;
}
else
{
for (; j < e1; j++)
{
w[j0] = rad[j];
j0++;
}
memcpy(rad, w, (e1 + e2 - a2) * sizeof(scmon));
return;
}
}
else if (o[k1] > n[k1])
{
w[j0] = n;
j0++;
j++;
if (j < e1)
{
n = rad[j];
break;
}
else
{
for (; i < e2; i++)
{
w[j0] = rad[i];
j0++;
}
memcpy(rad, w, (e1 + e2 - a2) * sizeof(scmon));
return;
}
}
k--;
}
}
}

## hLexR()

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

Definition at line 565 of file hutil.cc.

{
int j = 1, i = 0, k, k1;
scmon n, o;
if (Nrad < 2)
return;
n = rad[j];
o = rad[0];
k = Nvar;
loop
{
k1 = var[k];
if (!o[k1] && n[k1])
{
i++;
if (i < j)
{
o = rad[i];
k = Nvar;
}
else
{
j++;
if (j < Nrad)
{
i = 0;
o = rad[0];
n = rad[j];
k = Nvar;
}
else
return;
}
}
else if (o[k1] && !n[k1])
{
for (k = j; k > i; k--)
rad[k] = rad[k - 1];
rad[i] = n;
j++;
if (j < Nrad)
{
i = 0;
o = rad[0];
n = rad[j];
k = Nvar;
}
else
return;
}
else
k--;
}
}

## hLexS()

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

Definition at line 506 of file hutil.cc.

{
if (Nstc < 2)
return;
int j = 1, i = 0;
scmon n = stc[j];
scmon o = stc[0];
int k = Nvar;
loop
{
int k1 = var[k];
if (o[k1] < n[k1])
{
i++;
if (i < j)
{
o = stc[i];
k = Nvar;
}
else
{
j++;
if (j < Nstc)
{
i = 0;
o = stc[0];
n = stc[j];
k = Nvar;
}
else
return;
}
}
else if (o[k1] > n[k1])
{
int tmp_k;
for (tmp_k = j; tmp_k > i; tmp_k--)
stc[tmp_k] = stc[tmp_k - 1];
stc[i] = n;
j++;
if (j < Nstc)
{
i = 0;
o = stc[0];
n = stc[j];
k = Nvar;
}
else
return;
}
else
{
k--;
if (k<=0) return;
}
}
}

## hOrdSupp()

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

Definition at line 202 of file hutil.cc.

{
int i, i1, j, jj, k, l;
int x;
scmon temp, count;
float o, h, g, *v1;
v1 = (float *)omAlloc(Nvar * sizeof(float));
temp = (int *)omAlloc(Nstc * sizeof(int));
count = (int *)omAlloc(Nstc * sizeof(int));
for (i = 1; i <= Nvar; i++)
{
i1 = var[i];
*temp = stc[0][i1];
*count = 1;
jj = 1;
for (j = 1; j < Nstc; j++)
{
x = stc[j][i1];
k = 0;
loop
{
if (x > temp[k])
{
k++;
if (k == jj)
{
temp[k] = x;
count[k] = 1;
jj++;
break;
}
}
else if (x < temp[k])
{
for (l = jj; l > k; l--)
{
temp[l] = temp[l-1];
count[l] = count[l-1];
}
temp[k] = x;
count[k] = 1;
jj++;
break;
}
else
{
count[k]++;
break;
}
}
}
h = 0.0;
o = (float)Nstc/(float)jj;
for(j = 0; j < jj; j++)
{
g = (float)count[j];
if (g > o)
g -= o;
else
g = o - g;
if (g > h)
h = g;
}
v1[i-1] = h * (float)jj;
}
omFreeSize((ADDRESS)count, Nstc * sizeof(int));
omFreeSize((ADDRESS)temp, Nstc * sizeof(int));
for (i = 1; i < Nvar; i++)
{
i1 = var[i+1];
h = v1[i];
j = 0;
loop
{
if (h > v1[j])
{
for (l = i; l > j; l--)
{
v1[l] = v1[l-1];
var[l+1] = var[l];
}
v1[j] = h;
var[j+1] = i1;
break;
}
j++;
if (j == i)
break;
}
}
omFreeSize((ADDRESS)v1, Nvar * sizeof(float));
}
l
int l
Definition cfEzgcd.cc:100
g
g
Definition cfModGcd.cc:4098
h
STATIC_VAR Poly * h
Definition janet.cc:971
count
int status int void size_t count
Definition si_signals.h:69

## 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.

{
int nc = *Nstc, np = 0, nq = 0, j, i, i1, c, l;
scmon x;
for (j = a; j < nc; j++)
{
x = stc[j];
i = Nvar;
c = 2;
l = 0;
loop
{
i1 = var[i];
if (x[i1])
{
c--;
if (!c)
{
l = 0;
break;
}
else if (c == 1)
l = i1;
}
i--;
if (!i)
break;
}
if (l)
{
if (!pure[l])
{
np++;
pure[l] = x[l];
}
else if (x[l] < pure[l])
pure[l] = x[l];
stc[j] = NULL;
nq++;
}
}
*Npure = np;
if (nq!=0)
{
*Nstc -= nq;
hShrink(stc, a, nc);
}
}

## hRadical()

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

Definition at line 411 of file hutil.cc.

{
int nc = *Nrad, z = 0, i, j, k;
scmon n, o;
if (nc < 2)
return;
i = 0;
j = 1;
n = rad[j];
o = rad[0];
k = Nvar;
loop
{
if ((o[k]!=0) && (n[k]==0))
{
loop
{
k--;
if (k==0)
{
rad[i] = NULL;
z++;
break;
}
else
{
if ((o[k]==0) && (n[k]!=0))
break;
}
}
k = Nvar;
}
else if (!o[k] && n[k])
{
loop
{
k--;
if (!k)
{
rad[j] = NULL;
z++;
break;
}
else
{
if (o[k] && !n[k])
break;
}
}
k = Nvar;
}
else
{
k--;
if (!k)
{
rad[j] = NULL;
z++;
k = Nvar;
}
}
if (k == Nvar)
{
if (!rad[j])
i = j - 1;
loop
{
i++;
if (i == j)
{
i = -1;
j++;
if (j < nc)
n = rad[j];
else
{
if (z)
{
*Nrad -= z;
hShrink(rad, 0, nc);
}
return;
}
}
else if (rad[i])
{
o = rad[i];
break;
}
}
}
}
}

## hStaircase()

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

Definition at line 313 of file hutil.cc.

{
int nc = *Nstc;
if (nc < 2)
return;
int z = 0;
int i = 0;
int j = 1;
scmon n = stc[1 /*j*/];
scmon o = stc[0];
int k = Nvar;
loop
{
int k1 = var[k];
if (o[k1] > n[k1])
{
loop
{
k--;
if (k==0)
{
stc[i] = NULL;
z++;
break;
}
else
{
k1 = var[k];
if (o[k1] < n[k1])
break;
}
}
k = Nvar;
}
else if (o[k1] < n[k1])
{
loop
{
k--;
if (k==0)
{
stc[j] = NULL;
z++;
break;
}
else
{
k1 = var[k];
if (o[k1] > n[k1])
break;
}
}
k = Nvar;
}
else
{
k--;
if (k==0)
{
stc[j] = NULL;
z++;
k = Nvar;
}
}
if (k == Nvar)
{
if (stc[j]==NULL)
i = j - 1;
loop
{
i++;
if (i == j)
{
i = -1;
j++;
if (j < nc)
n = stc[j];
else
{
if (z!=0)
{
*Nstc -= z;
hShrink(stc, 0, nc);
}
return;
}
}
else if (stc[i]!=NULL)
{
o = stc[i];
break;
}
}
}
}
}

## hStepR()

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

Definition at line 974 of file hutil.cc.

{
int k1, i;
k1 = var[Nvar];
i = 0;
loop
{
if (rad[i][k1])
{
*a = i;
return;
}
i++;
if (i == Nrad)
{
*a = i;
return;
}
}
}

## hStepS()

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

Definition at line 949 of file hutil.cc.

{
int k1, i;
int y;
k1 = var[Nvar];
y = *x;
i = *a;
loop
{
if (y < stc[i][k1])
{
*a = i;
*x = stc[i][k1];
return;
}
i++;
if (i == Nstc)
{
*a = i;
return;
}
}
}
y
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.

{
int nv, i0, i1, i, j;
nv = i0 = *Nvar;
i1 = 0;
for (i = 1; i <= nv; i++)
{
j = 0;
loop
{
if (stc[j][i]>0)
{
i1++;
var[i1] = i;
break;
}
j++;
if (j == Nstc)
{
var[i0] = i;
i0--;
break;
}
}
}
*Nvar = i1;
}

## RightColonOperation()

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

Definition at line 1117 of file hilb.cc.

{
/*
* This returns right colon ideal of a monomial two-sided ideal of
* the free associative algebra with respect to a monomial 'w'
* (S:_R w).
*/
S = minimalMonomialGenSet(S);
ideal Iw = idInit(1,1);
Iw = colonIdeal(S, w, lV, Iw, 0);
return (Iw);
}

## Variable Documentation

## hCo

EXTERN_VAR int hCo

Definition at line 47 of file hutil.h.

## hexist

EXTERN_VAR scfmon 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

EXTERN_VAR scmon hpur0

Definition at line 40 of file hutil.h.

## hpure

EXTERN_VAR scmon hpure

Definition at line 40 of file hutil.h.

## hrad

EXTERN_VAR scfmon hrad

Definition at line 39 of file hutil.h.

## hsel

EXTERN_VAR varset hsel

Definition at line 41 of file hutil.h.

## hstc

EXTERN_VAR scfmon hstc

Definition at line 39 of file hutil.h.

## hvar

EXTERN_VAR varset hvar

Definition at line 41 of file hutil.h.

## hwork

EXTERN_VAR scfmon 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

EXTERN_VAR indset ISet

Definition at line 46 of file hutil.h.

## JSet

EXTERN_VAR indset 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.