51 #include <factory/factory.h> 57 #define TRANSEXT_PRIVATES 1 61 #define naTest(a) naDBTest(a,__FILE__,__LINE__,cf) 64 #define naTest(a) do {} while (0) 68 #define naRing cf->extRing 74 #define naCoeffs cf->extRing->cf 77 #define naMinpoly naRing->qideal->m[0] 129 if (p ==
NULL)
return;
130 number n =
n_Init(1, r->cf);
134 if (
n_IsOne(lc, r->cf))
return;
135 number lcInverse =
n_Invers(lc, r->cf);
228 { a = q; b =
p; aCorrespondsToP =
FALSE; }
232 if (aCorrespondsToP) { pFactor = aFactor; qFactor = bFactor; }
233 else { pFactor = bFactor; qFactor = aFactor; }
273 cf = cf->extRing->cf;
287 if (*a ==
NULL)
return;
348 if (i == 0)
return NULL;
379 if (aDeg>bDeg)
return TRUE;
380 if (aDeg<bDeg)
return FALSE;
398 const ring
A = cf->extRing;
407 const int P =
rVar(A);
410 Print(
"// %d parameter : ", P);
412 for (
int nop=0; nop <
P; nop ++)
417 const ideal I = A->qideal;
430 PrintS(
"// minpoly : ...");
452 return (number)aPlusB;
460 if (a ==
NULL)
return (number)minusB;
463 return (number)aMinusB;
474 return (number)aTimesB;
488 return (number)aDivB;
508 if (exp >= 0) *b =
NULL;
512 else if (exp == 0) { *b =
naInit(1, cf);
return; }
513 else if (exp == 1) { *b =
naCopy(a, cf);
return; }
514 else if (exp == -1) { *b =
naInvers(a, cf);
return; }
516 int expAbs =
exp;
if (expAbs < 0) expAbs = -expAbs;
523 for (
int i = 2;
i <= expAbs;
i++)
553 number n = (number)pow;
619 *a = (number)aAsPoly;
625 number naLcm(number
a, number
b,
const coeffs cf)
634 number theGcd =
naGcd(a, b, cf);
635 return naDiv(theProduct, theGcd, cf);
657 number
g =
ndGcd(a, b, cf);
704 const ideal mi =
naRing->qideal;
706 const ideal ii = e->
r->qideal;
723 if (a ==
NULL)
return -1;
730 while (aAsPoly !=
NULL)
734 if (d > theDegree) theDegree = d;
737 return theDegree + noOfTerms;
850 if( !
naIsOne((number)theGcd, cf) )
852 WerrorS(
"zero divisor found - your minpoly is not irreducible");
857 return (number)(aFactor);
864 assume(src->rep == dst->extRing->cf->rep);
876 p_SetCoeff(result, nMap(a, src, dst->extRing->cf), dst->extRing);
887 int n =
n_Int(a, src);
888 number q =
n_Init(n, dst->extRing->cf);
897 number naCopyMap(number
a,
const coeffs src,
const coeffs dst)
907 fraction fa=(fraction)a;
911 p =
p_Copy(NUM(fa),src->extRing);
914 q =
p_Copy(DEN(fa),src->extRing);
940 number t=
naDiv ((number)p,(number)q, dst);
945 WerrorS (
"mapping denominator to zero");
956 number q =
nlModP(a, src, dst->extRing->cf);
967 assume(src == dst->extRing->cf);
978 int n =
n_Int(a, src);
979 number q =
n_Init(n, dst->extRing->cf);
989 const ring rSrc = cf->extRing;
990 const ring rDst = dst->extRing;
1004 const ring rSrc = cf->extRing;
1005 const ring rDst = dst->extRing;
1008 fraction
f = (fraction)a;
1015 h =
prMapR(DEN(f), nMap, rSrc, rDst);
1019 result=
naDiv((number)g,(number)h,dst);
1026 n_Test((number)result, dst);
1056 if (src->ch == dst->ch)
return naMapPP;
1060 if (h != 1)
return NULL;
1072 else if ((nMap!=
NULL) && (strcmp(
rRingVar(0,src->extRing),
rRingVar(0,dst->extRing))==0) && (
rVar (src->extRing) ==
rVar (dst->extRing)))
1085 if (a ==
NULL)
return -1;
1087 return cf->extRing->pFDeg(aa,cf->extRing);
1095 const ring
R = cf->extRing;
1097 assume( 0 < iParameter && iParameter <=
rVar(R) );
1110 const ring
R = cf->extRing;
1123 const ring
R = cf->extRing;
1129 numberCollectionEnumerator.
Reset();
1131 if( !numberCollectionEnumerator.
MoveNext() )
1140 int s1;
int s=2147483647;
1144 int normalcount = 0;
1150 number& n = numberCollectionEnumerator.
Current();
1157 s1 =
p_Deg(cand1, R);
1163 }
while (numberCollectionEnumerator.
MoveNext() );
1170 numberCollectionEnumerator.
Reset();
1173 while (numberCollectionEnumerator.
MoveNext() )
1175 number& n = numberCollectionEnumerator.
Current();
1178 if( (--normalcount) <= 0)
1216 cand =
p_Neg(cand, R);
1218 c = (number)cand;
naTest(c);
1224 numberCollectionEnumerator.
Reset();
1227 while (numberCollectionEnumerator.
MoveNext() )
1229 number& n = numberCollectionEnumerator.
Current();
1325 const coeffs Q = cf->extRing->cf;
1331 c = (number)
p_NSet(n, cf->extRing);
1336 if ((--cf->extRing->ref) == 0)
1347 l+=(strlen(p[i])+1);
1351 snprintf(s,10+1,
"%d",r->ch);
1366 number *X=(number *)
omAlloc(rl*
sizeof(number));
1368 for(i=0;i<rl;i++) P[i]=
p_Copy((
poly)(x[
i]),cf->extRing);
1372 return ((number)result);
1379 return ((number)result);
1395 (e->
r->qideal->m[0] !=
NULL) );
1401 const ring
R = e->
r;
1428 cf->cfInpNeg =
naNeg;
1433 cf->cfExactDiv =
naDiv;
1465 cf->iNumberOfParameters =
rVar(R);
1466 cf->pParameterNames = (
const char**)R->names;
1468 cf->has_simple_Inverse= R->cf->has_simple_Inverse;
1484 #ifndef SINGULAR_4_1 1504 #define n2pTest(a) n2pDBTest(a,__FILE__,__LINE__,cf) 1507 #define n2pTest(a) do {} while (0) 1511 #define n2pRing cf->extRing 1517 #define n2pCoeffs cf->extRing->cf 1540 return (number)aTimesB;
1563 *a = (number)aAsPoly;
1595 l+=(strlen(p[i])+1);
1599 snprintf(s,10+1,
"%d",r->ch);
1615 const ring
A = cf->extRing;
1618 PrintS(
"// polynomial ring as coefficient ring :\n");
1652 const ring
R = e->
r;
1673 cf->cfInpNeg =
naNeg;
1709 cf->iNumberOfParameters =
rVar(R);
1710 cf->pParameterNames = (
const char**)R->names;
1712 cf->has_simple_Inverse=
FALSE;
void n2pNormalize(number &a, const coeffs cf)
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 char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
const CanonicalForm int s
const CanonicalForm int const CFList const Variable & y
void naDelete(number *a, const coeffs cf)
static void p_Monic(poly p, const ring r)
returns NULL if p == NULL, otherwise makes p monic by dividing by its leading coefficient (only done ...
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
BOOLEAN naIsZero(number a, const coeffs cf)
BOOLEAN naInitChar(coeffs cf, void *infoStruct)
Initialize the coeffs object.
void p_String0Long(const poly p, ring lmRing, ring tailRing)
print p in a long way
number n2pInvers(number a, const coeffs cf)
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
number naChineseRemainder(number *x, number *q, int rl, BOOLEAN, CFArray &inv_cache, const coeffs cf)
number naMapZ0(number a, const coeffs src, const coeffs dst)
void naKillChar(coeffs cf)
const char * n2pRead(const char *s, number *a, const coeffs cf)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
void naPower(number a, int exp, number *b, const coeffs cf)
static FORCE_INLINE BOOLEAN nCoeff_is_Q_or_BI(const coeffs r)
#define omFreeSize(addr, size)
number naSub(number a, number b, const coeffs cf)
static short rVar(const ring r)
#define rVar(r) (r->N)
poly singclap_gcd(poly f, poly g, const ring r)
destroys f and g
(), see rinteger.h, new impl.
const char * naRead(const char *s, number *a, const coeffs cf)
nMapFunc naSetMap(const coeffs src, const coeffs dst)
Get a mapping function from src into the domain of this type (n_algExt)
number naInit(long i, const coeffs cf)
number naParameter(const int iParameter, const coeffs cf)
return the specified parameter as a number in the given alg. field
static long p_Totaldegree(poly p, const ring r)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
number naMap00(number a, const coeffs src, const coeffs dst)
void WerrorS(const char *s)
long naInt(number &a, const coeffs cf)
BOOLEAN naGreater(number a, number b, const coeffs cf)
static FORCE_INLINE number n_NormalizeHelper(number a, number b, const coeffs r)
assume that r is a quotient field (otherwise, return 1) for arguments (a1/a2,b1/b2) return (lcm(a1...
static poly p_GcdHelper(poly &p, poly &q, const ring r)
see p_Gcd; additional assumption: deg(p) >= deg(q); must destroy p and q (unless one of them is retur...
Templated accessor interface for accessing individual data (for instance, of an enumerator).
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
char * naCoeffString(const coeffs r)
poly singclap_pdivide(poly f, poly g, const ring r)
#define n2pTest(a)
ABSTRACT: numbers as polys in the ring K[a] Assuming that we have a coeffs object cf...
static BOOLEAN naCoeffIsEqual(const coeffs cf, n_coeffType n, void *param)
static number p_SetCoeff(poly p, number n, ring r)
static BOOLEAN rCanShortOut(const ring r)
static poly p_Gcd(const poly p, const poly q, const ring r)
BOOLEAN n2pInitChar(coeffs cf, void *infoStruct)
static poly p_Copy(poly p, const ring r)
returns a copy of p
void n2pCoeffWrite(const coeffs cf, BOOLEAN details)
int naParDeg(number a, const coeffs cf)
char * n2pCoeffString(const coeffs r)
number naMapP0(number a, const coeffs src, const coeffs dst)
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
BOOLEAN naGreaterZero(number a, const coeffs cf)
forward declarations
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
virtual void Reset()=0
Sets the enumerator to its initial position: -1, which is before the first element in the collection...
number naFarey(number p, number n, const coeffs cf)
const char * p_Read(const char *st, poly &rc, const ring r)
static poly p_ExtGcdHelper(poly &p, poly &pFactor, poly &q, poly &qFactor, ring r)
static FORCE_INLINE void n_ClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Computes the content and (inplace) divides it out on a collection of numbers number c is the content ...
int naSize(number a, const coeffs cf)
long p_Deg(poly a, const ring r)
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
Coefficient rings, fields and other domains suitable for Singular polynomials.
number naCopyTrans2AlgExt(number a, const coeffs src, const coeffs dst)
number naMapPP(number a, const coeffs src, const coeffs dst)
poly p_Farey(poly p, number N, const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
int naIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
static FORCE_INLINE long n_Int(number &n, const coeffs r)
conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 ...
BOOLEAN naEqual(number a, number b, const coeffs cf)
number naConvFactoryNSingN(const CanonicalForm n, const coeffs cf)
Concrete implementation of enumerators over polynomials.
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
number naDiv(number a, number b, const coeffs cf)
number naGetDenom(number &a, const coeffs cf)
BOOLEAN naDBTest(number a, const char *f, const int l, const coeffs r)
static BOOLEAN p_IsConstant(const poly p, const ring r)
The main handler for Singular numbers which are suitable for Singular polynomials.
Templated enumerator interface for simple iteration over a generic collection of T's.
number n2pMult(number a, number b, const coeffs cf)
void StringAppendS(const char *st)
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
number naGenMap(number a, const coeffs cf, const coeffs dst)
number naMult(number a, number b, const coeffs cf)
number nlModP(number q, const coeffs Q, const coeffs Zp)
virtual reference Current()=0
Gets the current element in the collection (read and write).
number naGenTrans2AlgExt(number a, const coeffs cf, const coeffs dst)
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
number n2pDiv(number a, number b, const coeffs cf)
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 ...
BOOLEAN rSamePolyRep(ring r1, ring r2)
returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analo...
const char *const nDivBy0
poly p_ExtGcd(poly p, poly &pFactor, poly q, poly &qFactor, ring r)
assumes that p and q are univariate polynomials in r, mentioning the same variable; assumes a global ...
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
void heuristicReduce(poly &p, poly reducer, const coeffs cf)
void PrintS(const char *s)
static char * rRingVar(short i, const ring r)
static poly p_Mult_nn(poly p, number n, const ring r)
void naWriteLong(number a, const coeffs cf)
void rWrite(ring r, BOOLEAN details)
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise, if qr == 1, then qrideal equality is tested, as well
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
number naInvers(number a, const coeffs cf)
poly p_PolyDiv(poly &p, const poly divisor, const BOOLEAN needResult, const ring r)
assumes that p and divisor are univariate polynomials in r, mentioning the same variable; assumes div...
void naCoeffWrite(const coeffs cf, BOOLEAN details)
go into polynomials over an alg. extension recursively
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
static number ndGcd(number, number, const coeffs r)
static coeffs nCoeff_bottom(const coeffs r, int &height)
void p_Normalize(poly p, const ring r)
void p_Write0(poly p, ring lmRing, ring tailRing)
static void p_Delete(poly *p, const ring r)
number napNormalizeHelper(number b, const coeffs cf)
static BOOLEAN n2pCoeffIsEqual(const coeffs cf, n_coeffType n, void *param)
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
void n2pPower(number a, int exp, number *b, const coeffs cf)
number naLcmContent(number a, number b, const coeffs cf)
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
CanonicalForm convSingPFactoryP(poly p, const ring r)
number naAdd(number a, number b, const coeffs cf)
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
struct for passing initialization parameters to naInitChar
void rDelete(ring r)
unconditionally deletes fields in r
CanonicalForm naConvSingNFactoryN(number n, BOOLEAN, const coeffs cf)
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic ...
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...
virtual bool MoveNext()=0
Advances the enumerator to the next element of the collection. returns true if the enumerator was suc...
number naCopy(number a, const coeffs cf)
number naGcd(number a, number b, const coeffs cf)
void naClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
number naMap0P(number a, const coeffs src, const coeffs dst)
static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext(const coeffs r)
is it an alg. ext. of Q?
poly p_ChineseRemainder(poly *xx, number *x, number *q, int rl, CFArray &inv_cache, const ring R)
BOOLEAN singclap_extgcd(poly f, poly g, poly &res, poly &pa, poly &pb, const ring r)
static void p_Setm(poly p, const ring r)
void naClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
int dReportError(const char *fmt,...)
number naNeg(number a, const coeffs cf)
this is in-place, modifies a
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
static poly p_Neg(poly p, const ring r)
#define p_SetCoeff0(p, n, r)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static FORCE_INLINE BOOLEAN n_IsMOne(number n, const coeffs r)
TRUE iff 'n' represents the additive inverse of the one element, i.e. -1.
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
void definiteReduce(poly &p, poly reducer, const coeffs cf)
number naMapUP(number a, const coeffs src, const coeffs dst)
static poly p_Add_q(poly p, poly q, const ring r)
BOOLEAN naIsOne(number a, const coeffs cf)
Rational pow(const Rational &a, int e)
static poly p_Init(const ring r, omBin bin)
int p_Var(poly m, const ring r)
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
static poly p_Mult_q(poly p, poly q, const ring r)
poly p_Power(poly p, int i, const ring r)
BOOLEAN naIsMOne(number a, const coeffs cf)
void p_String0Short(const poly p, ring lmRing, ring tailRing)
print p in a short way, if possible
void naWriteShort(number a, const coeffs cf)
BOOLEAN n2pDBTest(number a, const char *f, const int l, const coeffs r)
void naNormalize(number &a, const coeffs cf)
const CanonicalForm const CanonicalForm const CanonicalForm const CanonicalForm & cand
static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &d, const coeffs r)
(inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient d...
used to represent polys as coeffcients
number naGetNumerator(number &a, const coeffs cf)