 |
My Project
debian-1:4.1.1-p2+ds-4
|
Go to the documentation of this file.
37 ideal
idInit(
int idsize,
int rank)
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++)
242 void id_Norm(ideal
id,
const ring r)
247 if (id->m[
i] !=
NULL)
322 if (id->m[
i] !=
NULL)
326 if ((id->m[
j] !=
NULL)
350 if (id->m[
i] !=
NULL)
404 ideal
id_Copy(ideal h1,
const ring r)
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)
727 ideal
id_Mult (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++;
913 int binom (
int n,
int r)
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))
1111 ideal
id_Head(ideal
h,
const ring r)
1122 ideal
id_Homogen(ideal
h,
int varnum,
const ring r)
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;
1283 ideal
id_Subst(ideal
id,
int n, poly e,
const ring r)
1288 res->rank =
id->rank;
1308 long cmax=1,order=0,ord,*
diff,diffmin=32000;
1328 iscom = (
int *)
omAlloc0(cmax*
sizeof(
int));
1368 ord =
R->pFDeg(
p,
R);
1405 for (
i=1;
i<cmax;
i++) (**
w)[
i-1]=(int)(
diff[
i]);
1406 for (
i=1;
i<cmax;
i++)
1412 for (
i=1;
i<cmax;
i++)
1414 (**w)[
i-1]=(int)(
diff[
i]-diffmin);
1421 ideal
id_Jet(
const ideal
i,
int d,
const ring
R)
1423 ideal r=
idInit((
i->nrows)*(
i->ncols),
i->rank);
1428 for(
int k=(
i->nrows)*(
i->ncols)-1;
k>=0;
k--)
1439 WerrorS(
"cannot compute weighted jets now");
1460 if (
idIs0(arg))
return -1;
1461 int i=0,
j, generator=-1;
1462 int rk_arg=arg->rank;
1463 int * componentIsUsed =(
int *)
omAlloc((rk_arg+1)*
sizeof(int));
1466 while ((generator<0) && (
i<
IDELEMS(arg)))
1468 memset(componentIsUsed,0,(rk_arg+1)*
sizeof(
int));
1473 if (componentIsUsed[
j]==0)
1479 componentIsUsed[
j] = 1;
1483 componentIsUsed[
j] = -1;
1486 else if (componentIsUsed[
j]>0)
1488 (componentIsUsed[
j])++;
1496 for (
j=0;
j<=rk_arg;
j++)
1498 if (componentIsUsed[
j]>0)
1500 if ((*
comp==-1) || (componentIsUsed[
j]<
i))
1503 i= componentIsUsed[
j];
1512 static void idDeleteComp(ideal arg,
int red_comp)
1539 int in=
IDELEMS(
id)-1, ready=0, all=0,
1540 coldim=
rVar(r), rowmax=2*coldim;
1541 if (in<0)
return NULL;
1553 for (
k=1;
k<=coldim;
k++)
1605 for(
i=I->nrows*I->ncols-1;
i>=0;
i--)
1619 if(-1<d0&&((d0<d)||(d==-1)))
1631 ideal
id_Transp(ideal a,
const ring rRing)
1633 int r = a->rank, c =
IDELEMS(a);
1692 const int n = rRing->N;
1700 for(
int i = 0;
i <
k;
i++ )
1702 poly pTempSum =
NULL;
1727 if( cc == 0) cc =
m;
1728 int vv = 1 + (gen - cc) /
m;
1740 assume( (cc + (vv-1)*
m) == gen );
1747 pTempSum =
p_Add_q(pTempSum,
h, rRing);
1752 idTemp->m[
i] = pTempSum;
1757 ideal idResult =
id_Transp(idTemp, rRing);
1766 int cnt=0;
int rw=0;
int cl=0;
1769 for(
j=rl-1;
j>=0;
j--)
1773 if (xx[
j]->
nrows >rw) rw=xx[
j]->nrows;
1778 WerrorS(
"format mismatch in CRT");
1784 number *
x=(number *)
omAlloc(rl*
sizeof(number));
1785 poly *
p=(poly *)
omAlloc(rl*
sizeof(poly));
1790 for(
i=cnt-1;
i>=0;
i--)
1792 for(
j=rl-1;
j>=0;
j--)
1800 for(
j=rl-1;
j>=0;
j--)
#define omdebugAddrSize(addr, size)
ideal id_FreeModule(int i, const ring r)
the free module of rank i
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
BOOLEAN id_HomModule(ideal m, ideal Q, intvec **w, const ring R)
int dReportError(const char *fmt,...)
ideal id_Homogen(ideal h, int varnum, const ring r)
#define omCheckAddrSize(addr, size)
void sBucketClearMerge(sBucket_pt bucket, poly *p, int *length)
int idElem(const ideal F)
count non-zero elements
poly p_Subst(poly p, int n, poly e, const ring r)
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
#define pGetComp(p)
Component.
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 p_Normalize(poly p, const ring r)
static int p_Comp_RevLex(poly a, poly b, BOOLEAN nolex, const ring R)
for idSort: compare a and b revlex inclusive module comp.
ideal id_Matrix2Module(matrix mat, const ring R)
converts mat to module, destroys mat
#define MATELEM(mat, i, j)
#define omGetSpecBin(size)
BOOLEAN idInsertPolyOnPos(ideal I, poly p, int pos)
insert p into I on position pos
void id_Norm(ideal id, const ring r)
ideal id = (id[i]), result is leadcoeff(id[i]) = 1
ideal id_ChineseRemainder(ideal *xx, number *q, int rl, const ring r)
void pEnlargeSet(poly **p, int l, int increment)
long(* pFDegProc)(poly p, ring r)
static poly p_Head(poly p, const ring r)
ideal id_TensorModuleMult(const int m, const ideal M, const ring rRing)
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
int id_PosConstant(ideal id, const ring r)
index of generator with leading term in ground ring (if any); otherwise -1
static void p_SetCompP(poly p, int i, ring r)
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
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:
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_MaxIdeal(const ring r)
initialise the maximal ideal (at 0)
poly p_Homogen(poly p, int varnum, const ring r)
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
intvec * id_QHomWeight(ideal id, const ring r)
short * iv2array(intvec *iv, const ring R)
static BOOLEAN length(leftv result, leftv arg)
poly p_ChineseRemainder(poly *xx, number *x, number *q, int rl, CFArray &inv_cache, const ring R)
#define __p_GetComp(p, r)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
void p_wrp(poly p, ring lmRing, ring tailRing)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
const CanonicalForm CFMap CFMap & N
void id_Shift(ideal M, int s, const ring r)
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
void id_ShallowDelete(ideal *h, ring r)
Shallowdeletes an ideal/matrix.
BOOLEAN p_IsHomogeneous(poly p, const ring r)
BOOLEAN id_HomIdeal(ideal id, ideal Q, const ring r)
#define p_LmEqual(p1, p2, 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!
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
static unsigned pLength(poly a)
static poly p_Copy(poly p, const ring r)
returns a copy of p
poly p_Power(poly p, int i, const ring r)
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
static short rVar(const ring r)
#define rVar(r) (r->N)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)
void PrintS(const char *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.
#define omFreeSize(addr, size)
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!
poly id_Array2Vector(poly *m, unsigned n, const ring R)
for julia: convert an array of poly to vector
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static BOOLEAN rField_is_Ring(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
matrix id_Module2Matrix(ideal mod, const ring R)
sBucket_pt sBucketCreate(const ring r)
static void makemonoms(int vars, int actvar, int deg, int monomdeg, const 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
void ivTriangIntern(intvec *imat, int &ready, int &all)
static poly pp_Mult_qq(poly p, poly q, const ring r)
static int p_LtCmp(poly p, poly q, const ring r)
ideal id_Jet(const ideal i, int d, const ring R)
static BOOLEAN p_DivisibleBy(poly a, poly b, const ring r)
int p_MinDeg(poly p, intvec *w, const ring R)
void idGetNextChoise(int r, int end, BOOLEAN *endch, int *choise)
static BOOLEAN p_IsUnit(const poly p, const ring r)
ideal id_Power(ideal given, int exp, const ring r)
void p_ShallowDelete(poly *p, const ring r)
matrix mpNew(int r, int c)
create a r x c zero-matrix
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
poly pp_JetW(poly p, int m, short *w, const ring R)
gmp_float exp(const gmp_float &a)
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
poly pp_Jet(poly p, int m, const ring R)
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
#define IMATELEM(M, I, J)
static void p_Delete(poly *p, const ring r)
static poly p_Add_q(poly p, poly q, const ring r)
ideal id_Delete_Pos(const ideal I, const int p, const ring r)
The following sip_sideal structure has many different uses thoughout Singular. Basic use-cases for it...
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
static int si_max(const int a, const int b)
void idInitChoise(int r, int beg, int end, BOOLEAN *endch, int *choise)
#define rRing_has_Comp(r)
ideal id_JetW(const ideal i, int d, intvec *iv, const ring R)
ideal id_Vec2Ideal(poly vec, const ring R)
ideal idInit(int idsize, int rank)
initialise an ideal / module
#define pp_Test(p, lmRing, tailRing)
void p_Vec2Polys(poly v, poly **p, int *len, 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),...
#define id_TestTail(A, lR, tR)
void WerrorS(const char *s)
static long p_GetExpDiff(poly p1, poly p2, int i, ring r)
static BOOLEAN rField_has_simple_inverse(const ring r)
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
int id_ReadOutPivot(ideal arg, int *comp, 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 (...
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...
static void p_Setm(poly p, const ring r)
static void id_NextPotence(ideal given, ideal result, int begin, int end, int deg, int restdeg, poly ap, const ring r)
static long p_IncrExp(poly p, int v, ring r)
int id_MinDegW(ideal M, intvec *w, const ring r)
static long p_Totaldegree(poly p, const ring r)
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
const CanonicalForm int s
void p_Norm(poly p1, const ring r)
matrix id_Module2formatedMatrix(ideal mod, int rows, int cols, const ring R)
int comp(const CanonicalForm &A, const CanonicalForm &B)
compare polynomials
static poly p_Mult_q(poly p, poly q, const ring r)
void id_Compactify(ideal id, const ring r)
ideal id_Add(ideal h1, ideal h2, const ring r)
h1 + h2
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
intvec * ivSolveKern(intvec *imat, int dimtr)
ideal id_Transp(ideal a, const ring rRing)
transpose a module
BOOLEAN _pp_Test(poly p, ring lmRing, ring tailRing, int level)
void sBucketDestroy(sBucket_pt *bucket)
#define omFreeBin(addr, bin)
ideal id_Head(ideal h, const ring r)
returns the ideals of initial terms
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
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),...
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 pReverse(poly p)
static poly p_SortMerge(poly p, const ring r, BOOLEAN revert=FALSE)
void omPrintAddrInfo(FILE *fd, void *addr, const char *s)
ideal id_Subst(ideal id, int n, poly e, const ring r)
void id_Normalize(ideal I, const ring r)
normialize all polys in id
BOOLEAN id_IsZeroDim(ideal I, const ring r)
int idGetNumberOfChoise(int t, int d, int begin, int end, int *choise)