40 assume( idsize >= 0 && rank >= 0 );
68 Print(
"Module of rank %ld,real rank %ld and %d generators.\n",
71 int j = (
id->ncols*
id->nrows) - 1;
72 while ((j > 0) && (
id->m[
j]==
NULL)) j--;
73 for (
int i = 0;
i <=
j;
i++)
87 const poly *
m =
id->m +
N;
89 for (
int k = N;
k >= 0; --
k, --
m)
104 for (
int l=
rVar(r)-1;
l>=0;
l--)
122 const int elems = (*h)->nrows * (*h)->ncols;
154 elems=j=(*h)->nrows*(*h)->ncols;
180 if (ide->m[k] !=
NULL)
185 ide->m[
j] = ide->m[
k];
199 for (k=j+1; k<
IDELEMS(ide); k++)
216 if ((F->m)[
j]!=
NULL) i++;
232 ideal newI =
idInit(k, ide->rank);
234 for (
int i = 0;
i <
k;
i++)
246 if (id->m[
i] !=
NULL)
325 if (id->m[i] !=
NULL)
329 if ((id->m[j] !=
NULL)
353 if (id->m[i] !=
NULL)
433 const int n = (h1->ncols * h1->nrows);
437 if( h1->m !=
NULL && n > 0 )
443 for (
int i=n - 1;
i >= 0;
i--)
447 if (k > new_rk) new_rk =
k;
452 assume( !( h1->nrows == h1->rank && h1->nrows > 1 && new_rk > 0 ) );
454 if(new_rk > h1->rank)
457 h1->rank, new_rk, f,l);
464 Print(
"error: ideal==NULL in %s:%d\n",f,l);
473 if (b==
NULL)
return 1;
474 if (a==
NULL)
return -1;
510 int i,
j, actpos=0, newpos;
511 int diff, olddiff, lastcomp, newcomp;
520 diff = (actpos+1) / 2;
522 lastcomp =
p_Comp_RevLex(id->m[i],id->m[(*result)[newpos]],nolex,r);
536 while (notFound && (newpos>=0) && (newpos<actpos))
538 newcomp =
p_Comp_RevLex(id->m[i],id->m[(*result)[newpos]],nolex,r);
546 && (newpos+diff>=actpos))
548 diff = actpos-newpos-1;
550 else if ((newcomp==-1)
559 if ((olddiff==1) && (lastcomp>0))
566 if ((olddiff==1) && (lastcomp<0))
581 if (diff==0) notFound=
FALSE;
583 if (newpos<0) newpos = 0;
584 if (newpos>actpos) newpos = actpos;
585 while ((newpos<actpos) && (
p_Comp_RevLex(id->m[i],id->m[(*result)[newpos]],nolex,r)==0))
587 for (j=actpos;j>newpos;j--)
589 (*result)[
j] = (*result)[j-1];
591 (*result)[newpos] =
i;
595 for (j=0;j<actpos;j++) (*result)[
j]++;
608 if (res->rank<h1->rank) res->rank=h1->rank;
614 if (res->rank<h2->rank) res->rank=h2->rank;
619 while ((j >= 0) && (h1->m[j] ==
NULL)) j--;
622 while ((i >= 0) && (h2->m[i] ==
NULL)) i--;
624 const int r =
si_max(h1->rank, h2->rank);
631 result->m[l] =
p_Copy(h1->m[l],R);
634 for (l=i; l>=0; l--, j--)
635 result->m[j] =
p_Copy(h2->m[l],R);
649 while ((j >= 0) && (h1->m[j] ==
NULL)) j--;
668 const poly h2,
const bool zeroOk,
const bool duplicateOk,
const ring
r)
673 if ((!zeroOk) && (h2 ==
NULL))
return FALSE;
676 bool h2FoundInH1 =
false;
678 while ((i < validEntries) && (!h2FoundInH1))
683 if (h2FoundInH1)
return FALSE;
685 if (validEntries ==
IDELEMS(h1))
690 h1->m[validEntries] = h2;
695 ideal
id_Add (ideal h1,ideal h2,
const ring
r)
714 while ((j > 0) && (h1->m[j-1] ==
NULL)) j--;
717 while ((i > 0) && (h2->m[i-1] ==
NULL)) i--;
720 int r =
si_max( h2->rank, h1->rank );
731 if (h1->m[i] !=
NULL)
735 if (h2->m[j] !=
NULL)
776 const long k =
p_MaxComp(*p, lmRing, tailRing);
839 while ((i >= 0) && (choise[i] == end))
849 for (j=i+1; j<
r; j++)
851 choise[
j] = choise[
i]+j-
i;
868 localchoise=(
int*)
omAlloc((d-1)*
sizeof(int));
874 while ((i<t) && (localchoise[i]==choise[i])) i++;
878 while ((i<d) && (localchoise[i-1]==choise[i])) i++;
899 if (n-r<r)
return binom(n,n-r);
906 WarnS(
"overflow in binomials");
921 for (
int j=0;
j<
i;
j++)
943 static void makemonoms(
int vars,
int actvar,
int deg,
int monomdeg,
const ring
r)
948 if ((idpowerpoint == 0) && (actvar ==1))
957 p_Setm(idpower[idpowerpoint],r);
963 p_SetExp(idpower[idpowerpoint],actvar,deg-monomdeg,r);
964 p_Setm(idpower[idpowerpoint],r);
965 p_Test(idpower[idpowerpoint],r);
971 p =
p_Copy(idpower[idpowerpoint],r);
976 p_SetExp(idpower[idpowerpoint],actvar,
p_GetExp(idpower[idpowerpoint],actvar,r)+1,r);
977 p_Setm(idpower[idpowerpoint],r);
978 p_Test(idpower[idpowerpoint],r);
990 WarnS(
"maxideal: power must be non-negative");
1004 int i =
binom(vars+deg-1,deg);
1005 if (i<=0)
return idInit(1,1);
1016 int begin,
int end,
int deg,
int restdeg,
poly ap,
const ring
r)
1026 if (result->nrows >=
IDELEMS(result))
1031 if (begin == end)
return;
1032 for (i=restdeg-1;i>0;i--)
1036 id_NextPotence(given, result, begin+1, end, deg, restdeg-i, p,r);
1074 while ((! b) && (i>=0))
1108 for (i=
IDELEMS(h)-1;i>=0; i--)
1138 for (i=1;i<=mr ;i++)
1183 Print(
"## inv. rank %ld -> %ld\n",mod->rank,cp);
1184 int k,
l,o=mod->rank;
1187 for (l=1; l<=o; l++)
1189 for (k=1; k<=
IDELEMS(mod); k++)
1213 if (r>rows) r = rows;
1214 if (c>cols) c = cols;
1248 res->
rank =
id->rank;
1268 long cmax=1,
order=0,ord,*
diff,diffmin=32000;
1280 for (i=length-1;i>=0;i--)
1286 diff = (
long *)
omAlloc0(cmax*
sizeof(
long));
1288 iscom = (
int *)
omAlloc0(cmax*
sizeof(
int));
1297 if ((p==
NULL) && (i<length))
1306 while ((i<length) && (F[i]==
NULL)) i++;
1307 if (i>=length)
break;
1328 ord = R->pFDeg(p,R);
1365 for (i=1;i<cmax;i++) (**w)[i-1]=(int)(diff[i]);
1366 for (i=1;i<cmax;i++)
1368 if (diff[i]<diffmin) diffmin=diff[
i];
1372 for (i=1;i<cmax;i++)
1374 (**w)[i-1]=(int)(diff[i]-diffmin);
1383 ideal
r=
idInit((i->nrows)*(i->ncols),i->rank);
1384 r->nrows = i->
nrows;
1385 r->ncols = i->
ncols;
1388 for(
int k=(i->nrows)*(i->ncols)-1;
k>=0;
k--)
1399 WerrorS(
"cannot compute weighted jets now");
1420 if (
idIs0(arg))
return -1;
1421 int i=0,
j, generator=-1;
1422 int rk_arg=arg->rank;
1423 int * componentIsUsed =(
int *)
omAlloc((rk_arg+1)*
sizeof(int));
1426 while ((generator<0) && (i<
IDELEMS(arg)))
1428 memset(componentIsUsed,0,(rk_arg+1)*
sizeof(
int));
1433 if (componentIsUsed[
j]==0)
1444 componentIsUsed[
j] = 1;
1448 componentIsUsed[
j] = -1;
1451 else if (componentIsUsed[
j]>0)
1453 (componentIsUsed[
j])++;
1461 for (
j=0;
j<=rk_arg;
j++)
1463 if (componentIsUsed[
j]>0)
1465 if ((*comp==-1) || (componentIsUsed[
j]<i))
1468 i= componentIsUsed[
j];
1477 static void idDeleteComp(ideal arg,
int red_comp)
1482 for (i=
IDELEMS(arg)-1;i>=0;i--)
1504 int in=
IDELEMS(
id)-1, ready=0, all=0,
1505 coldim=
rVar(r), rowmax=2*coldim;
1506 if (in<0)
return NULL;
1518 for (k=1;k<=coldim;k++)
1558 for(i=
rVar(r)-1;i>=0;i--)
1570 for(i=I->nrows*I->ncols-1;i>=0;i--)
1584 if(-1<d0&&((d0<d)||(d==-1)))
1598 int r = a->rank, c =
IDELEMS(a);
1616 for (i=
IDELEMS(b)-1; i>=0; i--)
1657 const int n = rRing->N;
1659 assume(M->rank <= m * n);
1663 ideal idTemp =
idInit(k,m);
1665 for(
int i = 0; i <
k; i++ )
1692 if( cc == 0) cc =
m;
1693 int vv = 1 + (gen - cc) / m;
1705 assume( (cc + (vv-1)*m) == gen );
1712 pTempSum =
p_Add_q(pTempSum, h, rRing);
1717 idTemp->m[
i] = pTempSum;
1722 ideal idResult =
id_Transp(idTemp, rRing);
1731 int cnt=0;
int rw=0;
int cl=0;
1734 for(j=rl-1;j>=0;j--)
1738 if (xx[j]->
nrows >rw) rw=xx[
j]->nrows;
1739 if (xx[j]->
ncols >cl) cl=xx[
j]->ncols;
1743 WerrorS(
"format mismatch in CRT");
1749 number *
x=(number *)
omAlloc(rl*
sizeof(number));
1752 for(i=cnt-1;i>=0;i--)
1754 for(j=rl-1;j>=0;j--)
1762 for(j=rl-1;j>=0;j--)
1769 for(i=rl-1;i>=0;i--)
id_Delete(&(xx[i]),r);
1780 for(
int i=
IDELEMS(M)-1; i>=0;i--)
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)
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.
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
BEGIN_NAMESPACE_SINGULARXX const ring lmRing
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!
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
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)
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 int pLength(poly a)
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)
ideal id_JetW(ideal i, int d, intvec *iv, const ring R)
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 : 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 p_LmCmp(poly p, poly q, const ring r)
static int si_max(const int a, const int b)
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)
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 : 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_Jet(ideal i, int d, 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)
ideal id_Head(ideal h, const ring r)
returns the ideals of initial terms
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
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), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0
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)
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)