39 assume( idsize >= 0 && rank >= 0 );
49 hh->m = (poly *)
omAlloc0(idsize*
sizeof(poly));
59 void idShow(
const ideal
id,
const ring lmRing,
const ring tailRing,
const int debugPrint)
67 Print(
"Module of rank %ld,real rank %ld and %d generators.\n",
70 int j = (
id->ncols*
id->nrows) - 1;
71 while ((
j > 0) && (
id->m[
j]==
NULL))
j--;
72 for (
int i = 0;
i <=
j;
i++)
86 const poly *
m =
id->m +
N;
88 for (
int k =
N;
k >= 0; --
k, --
m)
103 for (
int l=
rVar(r)-1;
l>=0;
l--)
121 const int elems = (*h)->nrows * (*h)->ncols;
133 poly
pp=((*h)->m[
j]);
156 elems=
j=(*h)->nrows*(*h)->ncols;
182 if (ide->m[
k] !=
NULL)
187 ide->m[
j] = ide->m[
k];
233 ideal newI =
idInit(
k, ide->rank);
235 for (
int i = 0;
i <
k;
i++)
247 if (id->m[
i] !=
NULL)
322 if (id->m[
i] !=
NULL)
326 if ((id->m[
j] !=
NULL)
350 if (id->m[
i] !=
NULL)
416 void id_DBTest(ideal h1,
int level,
const char *
f,
const int l,
const ring r,
const ring tailRing)
428 const int n = (h1->ncols * h1->nrows);
432 if( h1->m !=
NULL && n > 0 )
438 for (
int i=n - 1;
i >= 0;
i--)
442 if (
k > new_rk) new_rk =
k;
447 assume( !( h1->nrows == h1->rank && h1->nrows > 1 && new_rk > 0 ) );
449 if(new_rk > h1->rank)
452 h1->rank, new_rk,
f,
l);
459 Print(
"error: ideal==NULL in %s:%d\n",
f,
l);
468 if (
b==
NULL)
return 1;
469 if (a==
NULL)
return -1;
508 int i,
j, actpos=0, newpos;
509 int diff, olddiff, lastcomp, newcomp;
518 diff = (actpos+1) / 2;
534 while (notFound && (newpos>=0) && (newpos<actpos))
544 && (newpos+
diff>=actpos))
546 diff = actpos-newpos-1;
548 else if ((newcomp==-1)
557 if ((olddiff==1) && (lastcomp>0))
564 if ((olddiff==1) && (lastcomp<0))
581 if (newpos<0) newpos = 0;
582 if (newpos>actpos) newpos = actpos;
585 for (
j=actpos;
j>newpos;
j--)
587 (*result)[
j] = (*result)[
j-1];
589 (*result)[newpos] =
i;
606 if (
res->rank<h1->rank)
res->rank=h1->rank;
612 if (
res->rank<h2->rank)
res->rank=h2->rank;
617 while ((
j >= 0) && (h1->m[
j] ==
NULL))
j--;
620 while ((
i >= 0) && (h2->m[
i] ==
NULL))
i--;
622 const int r =
si_max(h1->rank, h2->rank);
632 for (
l=
i;
l>=0;
l--,
j--)
647 while ((
j >= 0) && (h1->m[
j] ==
NULL))
j--;
666 while ((
j >= 0) && (I->m[
j] ==
NULL))
j--;
687 const poly h2,
const bool zeroOk,
const bool duplicateOk,
const ring r)
692 if ((!zeroOk) && (h2 ==
NULL))
return FALSE;
695 bool h2FoundInH1 =
false;
697 while ((
i < validEntries) && (!h2FoundInH1))
702 if (h2FoundInH1)
return FALSE;
704 if (validEntries ==
IDELEMS(h1))
709 h1->m[validEntries] = h2;
714 ideal
id_Add (ideal h1,ideal h2,
const ring r)
733 while ((
j > 0) && (h1->m[
j-1] ==
NULL))
j--;
736 while ((
i > 0) && (h2->m[
i-1] ==
NULL))
i--;
739 int r =
si_max( h2->rank, h1->rank );
750 if (h1->m[
i] !=
NULL)
754 if (h2->m[
j] !=
NULL)
858 while ((
i >= 0) && (choise[
i] == end))
868 for (
j=
i+1;
j<r;
j++)
870 choise[
j] = choise[
i]+
j-
i;
887 localchoise=(
int*)
omAlloc((d-1)*
sizeof(int));
893 while ((
i<t) && (localchoise[
i]==choise[
i]))
i++;
897 while ((
i<d) && (localchoise[
i-1]==choise[
i]))
i++;
918 if (n-r<r)
return binom(n,n-r);
925 WarnS(
"overflow in binomials");
940 for (
int j=0;
j<
i;
j++)
962 static void makemonoms(
int vars,
int actvar,
int deg,
int monomdeg,
const ring r)
1009 WarnS(
"maxideal: power must be non-negative");
1023 int i =
binom(vars+deg-1,deg);
1035 int begin,
int end,
int deg,
int restdeg, poly
ap,
const ring r)
1050 if (begin == end)
return;
1051 for (
i=restdeg-1;
i>0;
i--)
1093 while ((!
b) && (
i>=0))
1150 for(
unsigned j=0;
j<n ;
j++)
1178 for (
i=1;
i<=mr ;
i++)
1223 Print(
"## inv. rank %ld -> %ld\n",
mod->rank,cp);
1224 int k,
l,o=
mod->rank;
1227 for (
l=1;
l<=o;
l++)
1253 if (r>rows) r = rows;
1254 if (c>cols) c = cols;
1321 res->rank =
id->rank;
1341 long cmax=1,order=0,ord,*
diff,diffmin=32000;
1361 iscom = (
int *)
omAlloc0(cmax*
sizeof(
int));
1401 ord =
R->pFDeg(
p,
R);
1438 for (
i=1;
i<cmax;
i++) (**
w)[
i-1]=(int)(
diff[
i]);
1439 for (
i=1;
i<cmax;
i++)
1445 for (
i=1;
i<cmax;
i++)
1447 (**w)[
i-1]=(int)(
diff[
i]-diffmin);
1456 ideal r=
idInit((
i->nrows)*(
i->ncols),
i->rank);
1461 for(
int k=(
i->nrows)*(
i->ncols)-1;
k>=0;
k--)
1472 WerrorS(
"cannot compute weighted jets now");
1493 if (
idIs0(arg))
return -1;
1494 int i=0,
j, generator=-1;
1495 int rk_arg=arg->rank;
1496 int * componentIsUsed =(
int *)
omAlloc((rk_arg+1)*
sizeof(int));
1499 while ((generator<0) && (
i<
IDELEMS(arg)))
1501 memset(componentIsUsed,0,(rk_arg+1)*
sizeof(
int));
1506 if (componentIsUsed[
j]==0)
1512 componentIsUsed[
j] = 1;
1516 componentIsUsed[
j] = -1;
1519 else if (componentIsUsed[
j]>0)
1521 (componentIsUsed[
j])++;
1529 for (
j=0;
j<=rk_arg;
j++)
1531 if (componentIsUsed[
j]>0)
1533 if ((*
comp==-1) || (componentIsUsed[
j]<
i))
1536 i= componentIsUsed[
j];
1545 static void idDeleteComp(ideal arg,
int red_comp)
1572 int in=
IDELEMS(
id)-1, ready=0, all=0,
1573 coldim=
rVar(r), rowmax=2*coldim;
1574 if (in<0)
return NULL;
1586 for (
k=1;
k<=coldim;
k++)
1638 for(
i=I->nrows*I->ncols-1;
i>=0;
i--)
1652 if(-1<d0&&((d0<d)||(d==-1)))
1666 int r = a->rank, c =
IDELEMS(a);
1725 const int n = rRing->N;
1733 for(
int i = 0;
i <
k;
i++ )
1735 poly pTempSum =
NULL;
1760 if( cc == 0) cc =
m;
1761 int vv = 1 + (gen - cc) /
m;
1773 assume( (cc + (vv-1)*
m) == gen );
1780 pTempSum =
p_Add_q(pTempSum,
h, rRing);
1785 idTemp->m[
i] = pTempSum;
1790 ideal idResult =
id_Transp(idTemp, rRing);
1799 int cnt=0;
int rw=0;
int cl=0;
1802 for(
j=rl-1;
j>=0;
j--)
1806 if (xx[
j]->
nrows >rw) rw=xx[
j]->nrows;
1811 WerrorS(
"format mismatch in CRT");
1817 number *
x=(number *)
omAlloc(rl*
sizeof(number));
1818 poly *
p=(poly *)
omAlloc(rl*
sizeof(poly));
1823 for(
i=cnt-1;
i>=0;
i--)
1825 for(
j=rl-1;
j>=0;
j--)
1833 for(
j=rl-1;
j>=0;
j--)
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
static poly p_SortMerge(poly p, const ring r, BOOLEAN revert=FALSE)
#define __p_GetComp(p, r)
int id_PosConstant(ideal id, const ring r)
index of generator with leading term in ground ring (if any); otherwise -1
static int p_Comp_RevLex(poly a, poly b, BOOLEAN nolex, const ring R)
for idSort: compare a and b revlex inclusive module comp.
#define id_TestTail(A, lR, tR)
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
void id_Normalize(ideal I, const ring r)
normialize all polys in id
const CanonicalForm int s
void id_DelDiv(ideal id, const ring r)
delete id[j], if LT(j) == coeff*mon*LT(i) and vice versa, i.e., delete id[i], if LT(i) == coeff*mon*L...
ideal id_FreeModule(int i, const ring r)
the free module of rank i
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
ideal id_Transp(ideal a, const ring rRing)
transpose a module
#define omCheckAddrSize(addr, size)
ideal id_Homogen(ideal h, int varnum, const ring r)
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
static poly p_LmDeleteAndNext(poly p, const ring r)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
ideal id_Subst(ideal id, int n, poly e, const ring r)
BOOLEAN p_ComparePolys(poly p1, poly p2, const ring r)
returns TRUE if p1 is a skalar multiple of p2 assume p1 != NULL and p2 != NULL
gmp_float exp(const gmp_float &a)
poly p_Homogen(poly p, int varnum, const ring r)
short * iv2array(intvec *iv, const ring R)
void id_ShallowDelete(ideal *h, ring r)
Shallowdeletes an ideal/matrix.
BOOLEAN p_IsHomogeneous(poly p, const ring r)
static long p_IncrExp(poly p, int v, ring r)
int idGetNumberOfChoise(int t, int d, int begin, int end, int *choise)
int p_MinDeg(poly p, intvec *w, const ring R)
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
ideal id_ChineseRemainder(ideal *xx, number *q, int rl, const ring r)
BOOLEAN id_HomModule(ideal m, ideal Q, intvec **w, const ring R)
BOOLEAN id_HomIdeal(ideal id, ideal Q, const ring r)
void id_DBTest(ideal h1, int level, const char *f, const int l, const ring r, const ring tailRing)
Internal verification for ideals/modules and dense matrices!
void id_Norm(ideal id, const ring r)
ideal id = (id[i]), result is leadcoeff(id[i]) = 1
#define omFreeSize(addr, size)
static BOOLEAN p_IsUnit(const poly p, const ring r)
static short rVar(const ring r)
#define rVar(r) (r->N)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
intvec * id_QHomWeight(ideal id, const ring r)
BOOLEAN id_IsConstant(ideal id, const ring r)
test if the ideal has only constant polynomials NOTE: zero ideal/module is also constant
BOOLEAN id_InsertPolyWithTests(ideal h1, const int validEntries, const poly h2, const bool zeroOk, const bool duplicateOk, const ring r)
insert h2 into h1 depending on the two boolean parameters:
static long p_Totaldegree(poly p, const ring r)
BOOLEAN _pp_Test(poly p, ring lmRing, ring tailRing, int level)
BOOLEAN idInsertPolyOnPos(ideal I, poly p, int pos)
insert p into I on position pos
poly p_Subst(poly p, int n, poly e, const ring r)
void WerrorS(const char *s)
void p_ShallowDelete(poly *p, const ring r)
ideal id_TensorModuleMult(const int m, const ideal M, const ring rRing)
void p_Norm(poly p1, const ring r)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
ideal id_MaxIdeal(const ring r)
initialise the maximal ideal (at 0)
#define pGetComp(p)
Component.
static poly p_Copy(poly p, const ring r)
returns a copy of p
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)
static BOOLEAN rField_has_simple_inverse(const ring r)
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
poly pp_JetW(poly p, int m, short *w, const ring R)
static long p_GetExpDiff(poly p1, poly p2, int i, ring r)
void omPrintAddrInfo(FILE *fd, void *addr, const char *s)
void id_Shift(ideal M, int s, const ring r)
static poly p_Head(poly p, const ring r)
static void p_SetCompP(poly p, int i, ring r)
void id_DelMultiples(ideal id, const ring r)
ideal id = (id[i]), c any unit if id[i] = c*id[j] then id[j] is deleted for j > i
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
void id_DelLmEquals(ideal id, const ring r)
Delete id[j], if Lm(j) == Lm(i) and both LC(j), LC(i) are units and j > i.
const CanonicalForm CFMap CFMap & N
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
void sBucket_Merge_p(sBucket_pt bucket, poly p, int length)
Merges p into Spoly: assumes Bpoly and p have no common monoms destroys p!
void ivTriangIntern(intvec *imat, int &ready, int &all)
void sBucketDestroy(sBucket_pt *bucket)
static poly pp_Mult_qq(poly p, poly q, const ring r)
void p_Vec2Polys(poly v, poly **p, int *len, const ring r)
#define pp_Test(p, lmRing, tailRing)
sBucket_pt sBucketCreate(const ring r)
void id_DelEquals(ideal id, const ring r)
ideal id = (id[i]) if id[i] = id[j] then id[j] is deleted for j > i
intvec * id_Sort(const ideal id, const BOOLEAN nolex, const ring r)
sorts the ideal w.r.t. the actual ringordering uses lex-ordering when nolex = FALSE
ideal id_Power(ideal given, int exp, const ring r)
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
static int si_max(const int a, const int b)
ideal id_Jet(const ideal i, int d, const ring R)
ideal id_JetW(const ideal i, int d, intvec *iv, const ring R)
void PrintS(const char *s)
void sBucketClearMerge(sBucket_pt bucket, poly *p, int *length)
void idGetNextChoise(int r, int end, BOOLEAN *endch, int *choise)
matrix id_Module2Matrix(ideal mod, const ring R)
poly id_Array2Vector(poly *m, unsigned n, const ring R)
for julia: convert an array of poly to vector
static unsigned pLength(poly a)
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static poly pReverse(poly p)
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
static void makemonoms(int vars, int actvar, int deg, int monomdeg, const ring r)
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
matrix mpNew(int r, int c)
create a r x c zero-matrix
void p_Normalize(poly p, const ring r)
#define rRing_has_Comp(r)
static void p_Delete(poly *p, const ring r)
#define omGetSpecBin(size)
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...
ideal idInit(int idsize, int rank)
initialise an ideal / module
#define p_LmEqual(p1, p2, r)
static void id_NextPotence(ideal given, ideal result, int begin, int end, int deg, int restdeg, poly ap, const ring r)
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
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
BOOLEAN p_DivisibleByRingCase(poly f, poly g, const ring r)
divisibility check over ground ring (which may contain zero divisors); TRUE iff LT(f) divides LT(g),...
ideal id_ResizeModule(ideal mod, int rows, int cols, const ring R)
The following sip_sideal structure has many different uses thoughout Singular. Basic use-cases for it...
static BOOLEAN rField_is_Ring(const ring r)
matrix id_Module2formatedMatrix(ideal mod, int rows, int cols, const ring R)
void pEnlargeSet(poly **p, int l, int increment)
void idInitChoise(int r, int beg, int end, BOOLEAN *endch, int *choise)
ideal id_Add(ideal h1, ideal h2, const ring r)
h1 + h2
long(* pFDegProc)(poly p, ring r)
#define omdebugAddrSize(addr, size)
static BOOLEAN length(leftv result, leftv arg)
ideal id_Head(ideal h, const ring r)
returns the ideals of initial terms
static int p_LtCmp(poly p, poly q, const ring r)
poly p_ChineseRemainder(poly *xx, number *x, number *q, int rl, CFArray &inv_cache, const ring R)
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
static void p_Setm(poly p, const ring r)
BOOLEAN id_IsZeroDim(ideal I, const ring r)
ideal id_CopyFirstK(const ideal ide, const int k, const ring r)
copies the first k (>= 1) entries of the given ideal/module and returns these as a new ideal/module (...
int idElem(const ideal F)
count non-zero elements
ideal id_Delete_Pos(const ideal I, const int p, const ring r)
int dReportError(const char *fmt,...)
int id_ReadOutPivot(ideal arg, int *comp, const ring r)
intvec * ivSolveKern(intvec *imat, int dimtr)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
void p_wrp(poly p, ring lmRing, ring tailRing)
poly pp_Jet(poly p, int m, const ring R)
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2),...
int id_MinDegW(ideal M, intvec *w, const ring r)
ideal id_Vec2Ideal(poly vec, const ring R)
static poly p_Add_q(poly p, poly q, const ring r)
#define omFreeBin(addr, bin)
#define IMATELEM(M, I, J)
void id_Compactify(ideal id, const ring r)
ideal id_Matrix2Module(matrix mat, const ring R)
converts mat to module, destroys mat
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
static poly p_Mult_q(poly p, poly q, const ring r)
poly p_Power(poly p, int i, const ring r)
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
#define MATELEM(mat, i, j)