 |
My Project
debian-1:4.1.1-p2+ds-4build1
|
Go to the documentation of this file.
41 #define SM_MIN_LENGTH_BUCKET MIN_LENGTH_BUCKET - 5
43 #define SM_MIN_LENGTH_BUCKET MAX_INT_VAL
61 static void sm_ExpMultDiv(poly,
const poly,
const poly,
const ring);
62 static void sm_PolyDivN(poly,
const number,
const ring);
65 static void sm_FindRef(poly *, poly *, poly,
const ring);
87 p =
currRing->p_Procs->pp_Mult_Coeff_mm_DivSelectMult(
p,
m, a,
b,
197 al = di*
sizeof(long);
199 bl = ra*
sizeof(long);
201 for (
i=di-1;
i>=0;
i--)
254 for (
i=pos;
i<d;
i++) c[
i] = c[
i+1];
264 int *block0=(
int*)
omAlloc0(3*
sizeof(
int));
265 int *block1=(
int*)
omAlloc0(3*
sizeof(
int));
274 tmpR->bitmask = 2*
bound;
275 tmpR->wvhdl = (
int **)
omAlloc0((3) *
sizeof(
int*));
281 if (origR->qideal!=
NULL)
286 Print(
"[%ld:%d]", (
long) tmpR->bitmask, tmpR->ExpL_Size);
293 for(
int i=r->N-1;
i>=0;
i--)
omFree(r->names[
i]);
359 if (I->ncols != I->rank)
361 Werror(
"det of %ld x %d module (matrix)",I->rank,I->ncols);
523 for (
i=
v->rows()-1;
i>=0;
i--)
715 if ((wr<0.25) || (wc<0.25))
756 float wc, wp,
w, hp =
piv->f;
794 float wopt = 1.0e30, hp =
piv->f;
797 int i, copt, ropt,
f, e =
crd;
816 if ((wr<0.25) || (wc<0.25))
893 else if (a->pos >
b->pos)
980 else if (a->pos >
b->pos)
1063 }
while (r !=
NULL);
1092 }
while (a->pos <
rpiv);
1108 if ((a ==
NULL) || (a->pos >
rpiv))
1120 else if (a->pos ==
rpiv)
1197 if (
i >
act)
return;
1227 if (
i >
act)
return;
1272 }
while ((a !=
NULL) && (a->pos <=
tored));
1288 if ((a ==
NULL) || (a->pos >
tored))
break;
1291 if ((
k >
i) && (a->pos <=
tored))
1298 }
while ((a !=
NULL) && (a->pos <=
tored));
1308 while ((a !=
NULL) && (a->pos <=
tored))
1461 }
while (a !=
NULL);
1480 }
while (a !=
NULL);
1501 }
while (a !=
NULL);
1541 }
while (a !=
NULL);
1615 void sm_PolyDiv(poly a, poly
b,
const ring
R)
1636 }
while (a !=
NULL);
1660 }
while (t !=
NULL);
1675 poly smMultDiv(poly a, poly b, const poly c)
1681 if ((c == NULL) || pLmIsConstantComp(c))
1683 return pp_Mult_qq(a, b);
1686 pqLength(a, b, la, lb, SM_MIN_LENGTH_BUCKET);
1688 // we iter over b, so, make sure b is the shortest
1689 // such that we minimize our iterations
1704 pSetCoeff0(e,pGetCoeff(b));
1705 if (smIsNegQuot(e, b, c))
1707 lead = pLmDivisibleByNoComp(e, a);
1708 r = smSelectCopy_ExpMultDiv(a, e, b, c);
1713 r = pp_Mult__mm(a, e);
1719 smFindRef(&pa, &res, r);
1729 res = p_Add_q(res, r);
1738 if (!TEST_OPT_NOT_BUCKETS && lb >= SM_MIN_LENGTH_BUCKET)
1740 // use buckets if minimum length is smaller than threshold
1743 // find the last monomial before pa
1747 pNext(append) = res;
1752 while (pNext(append) != pa)
1754 assume(pNext(append) != NULL);
1758 kBucket_pt bucket = kBucketCreate(currRing);
1759 kBucketInit(bucket, pNext(append), 0);
1762 pSetCoeff0(e,pGetCoeff(b));
1763 if (smIsNegQuot(e, b, c))
1766 r = pp_Mult_Coeff_mm_DivSelect_MultDiv(a, lr, e, b, c);
1767 if (pLmDivisibleByNoComp(e, a))
1768 append = kBucket_ExtractLarger_Add_q(bucket, append, r, &lr);
1770 kBucket_Add_q(bucket, r, &lr);
1774 r = pp_Mult__mm(a, e);
1775 append = kBucket_ExtractLarger_Add_q(bucket, append, r, &la);
1778 } while (b != NULL);
1779 pNext(append) = kBucketClear(bucket);
1780 kBucketDestroy(&bucket);
1788 pSetCoeff0(e,pGetCoeff(b));
1789 if (smIsNegQuot(e, b, c))
1791 r = smSelectCopy_ExpMultDiv(a, e, b, c);
1792 if (pLmDivisibleByNoComp(e, a))
1793 smCombineChain(&pa, r);
1799 r = pp_Mult__mm(a, e);
1800 smCombineChain(&pa, r);
1803 } while (b != NULL);
1814 poly
sm_MultDiv(poly a, poly
b,
const poly c,
const ring
R)
1884 }
while (
b !=
NULL);
1986 static void sm_ExpMultDiv(poly t,
const poly
b,
const poly c,
const ring
R)
2004 static void sm_PolyDivN(poly a,
const number
x,
const ring
R)
2014 }
while (a !=
NULL);
2075 static void sm_FindRef(poly *ref, poly *px, poly r,
const ring
R)
2079 poly pa = *px,
pp =
NULL;
2143 memcpy(r, a,
sizeof(
smprec));
2255 return res+(float)
i;
2290 if (!sw)
return res;
2379 WerrorS(
"symbol in equation");
2395 WerrorS(
"singular problem for linsolv");
2457 if (
sing != 0)
return;
2468 if (
sing != 0)
return;
2662 }
while (
b !=
NULL);
2665 if (a->pos <
b->pos)
2670 else if (a->pos >
b->pos)
2702 }
while (r !=
NULL);
2731 }
while (a->pos <
rpiv);
2747 if ((a ==
NULL) || (a->pos >
rpiv))
2759 else if (a->pos ==
rpiv)
2892 memcpy(r, a,
sizeof(
smnrec));
2946 if ((
i == 0) || (
i != I->rank-1))
2948 WerrorS(
"wrong dimensions for linsolv");
2953 if(I->m[
i-1] ==
NULL)
2955 WerrorS(
"singular input for linsolv");
static BOOLEAN sm_IsNegQuot(poly, const poly, const poly, const ring)
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
static float sm_PolyWeight(smpoly, const ring)
void p_Normalize(poly p, const ring r)
static smpoly smElemCopy(smpoly)
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
void smToIntvec(intvec *)
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
const CanonicalForm int const CFList const Variable & y
#define omGetSpecBin(size)
static poly p_Neg(poly p, const ring r)
static poly sm_Smpoly2Poly(smpoly, const ring)
ideal sm_CallSolv(ideal I, const ring R)
void rKillModifiedRing(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
static void smMinSelect(long *, int, int)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static poly pp_Mult_mm(poly p, poly m, const ring r)
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
ring sm_RingChange(const ring origR, long bound)
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
static BOOLEAN smCheckSolv(ideal)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
static long p_SubExp(poly p, int v, long ee, ring r)
static poly pp_Mult_Coeff_mm_DivSelect(poly p, const poly m, const ring r)
static smnumber sm_Poly2Smnumber(poly, const ring)
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 smpoly sm_Poly2Smpoly(poly, const ring)
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
poly prMoveR(poly &p, ring src_r, ring dest_r)
static unsigned pLength(poly a)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
void sm_CallBareiss(ideal I, int x, int y, ideal &M, intvec **iv, const ring R)
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of 'a' and 'b', i.e., a+b
static short rVar(const ring r)
#define rVar(r) (r->N)
poly kBucketExtractLm(kBucket_pt bucket)
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
void kBucket_Add_q(kBucket_pt bucket, poly q, int *l)
Add to Bucket a poly ,i.e. Bpoly == q+Bpoly.
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
void kBucketDestroy(kBucket_pt *bucket_pt)
static poly sm_Smnumber2Poly(number, const ring)
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
#define TEST_OPT_NOT_BUCKETS
void PrintS(const char *s)
#define omFreeSize(addr, size)
void kBucketInit(kBucket_pt bucket, poly lm, int length)
static void sm_FindRef(poly *, poly *, poly, const ring)
static BOOLEAN smSmaller(poly, poly)
poly sm_MultDiv(poly a, poly b, const poly c, const ring R)
void smNewBareiss(int, int)
static void p_LmDelete(poly p, const ring r)
static poly p_New(const ring, omBin bin)
static void sm_NumberDelete(smnumber *, const ring R)
static poly pp_Mult_qq(poly p, poly q, const ring r)
poly p_Cleardenom(poly p, const ring r)
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
void sm_SpecialPolyDiv(poly a, poly b, const ring R)
static void sm_CombineChain(poly *, poly, const ring)
static poly p_Init(const ring r, omBin bin)
static int p_LmCmp(poly p, poly q, const ring r)
void sm_KillModifiedRing(ring r)
sparse_number_mat(ideal, const ring)
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
static void sm_PolyDivN(poly, const number, const ring)
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 number sm_Cleardenom(ideal, const ring)
static void p_LmFree(poly p, ring)
static void p_Delete(poly *p, const ring r)
static poly p_Add_q(poly p, poly q, const ring r)
static poly pp_Mult_Coeff_mm_DivSelect_MultDiv(poly p, int &lp, poly m, poly a, poly b, const ring currRing)
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible
static void sm_ElemDelete(smpoly *, const ring)
static poly sm_SelectCopy_ExpMultDiv(poly p, poly m, poly a, poly b, const ring currRing)
static int si_max(const int a, const int b)
static CanonicalForm bound(const CFMatrix &M)
static void sm_ExpMultDiv(poly, const poly, const poly, const ring)
void Werror(const char *fmt,...)
ideal idInit(int idsize, int rank)
initialise an ideal / module
static BOOLEAN rOrd_is_Comp_dp(const ring r)
static number p_SetCoeff(poly p, number n, 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 SM_MIN_LENGTH_BUCKET
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
void WerrorS(const char *s)
poly sm_CallDet(ideal I, const ring R)
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
static void p_Setm(poly p, const ring r)
const Variable & v
< [in] a sqrfree bivariate poly
static void sm_ExactPolyDiv(poly, poly, const ring)
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff 'a' and 'b' represent the same number; they may have different representations.
sparse_mat(ideal, const ring)
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
static BOOLEAN p_IsConstant(const poly p, const ring r)
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
const CanonicalForm int s
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
long sm_ExpBound(ideal m, int di, int ra, int t, const ring currRing)
static BOOLEAN sm_HaveDenom(poly, const ring)
static smnumber smNumberCopy(smnumber)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
static FORCE_INLINE int n_Size(number n, const coeffs r)
return a non-negative measure for the complexity of n; return 0 only when n represents zero; (used fo...
#define omFreeBin(addr, bin)
static BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, const ring r)
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
static FORCE_INLINE number n_GetDenom(number &n, const coeffs r)
return the denominator of n (if elements of r are by nature not fractional, result is 1)
static poly p_Mult_nn(poly p, number n, const ring r)
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
BOOLEAN sm_CheckDet(ideal I, int d, BOOLEAN sw, const ring r)
static BOOLEAN rField_is_Q(const ring r)
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...