33 #define TRANSEXT_PRIVATES 38 #include <factory/factory.h> 62 #define ADD_COMPLEXITY 1 63 #define MULT_COMPLEXITY 2 64 #define DIFF_COMPLEXITY 2 65 #define BOUND_COMPLEXITY 10 68 #define NUMIS1(f) (p_IsOne(NUM(f), cf->extRing)) 70 #define COM(f) f->complexity 77 #define ntTest(a) n_Test(a, cf) 84 #define ntRing cf->extRing 90 #define ntCoeffs cf->extRing->cf 128 BOOLEAN simpleTestsHaveAlreadyBeenPerformed);
179 if (IS0(a))
return TRUE;
181 const fraction t = (fraction)a;
193 Print(
"ERROR in %s:%d: non-integer Q coeff in num. poly\n",f,l);
208 Print(
"ERROR in %s:%d: non-integer Q coeff in den. poly\n",f,l);
217 Print(
"ERROR in %s:%d: constant den. poly / Zp\n",f,l);
225 Print(
"ERROR in %s:%d: non-monic den. poly / Zp\n",f,l);
239 Print(
"ERROR in %s:%d: 1 != GCD between num. & den. poly\n",f,l);
252 Print(
"?/1 in %s:%d\n",f,l);
257 Print(
"negative sign of DEN. of a fraction in %s:%d\n",f,l);
287 if (!(
SR_HDL(n) & SR_INT))
290 Print(
"rational coeff in num: %s:%d\n",f,l);
301 Print(
"rational coeff in den.:%s:%d\n",f,l);
322 cf = cf->extRing->cf;
340 fraction
f = (fraction)(*a);
356 if (a == b)
return TRUE;
357 if ((IS0(a)) && (!IS0(b)))
return FALSE;
358 if ((IS0(b)) && (!IS0(a)))
return FALSE;
361 fraction fa = (fraction)a;
362 fraction fb = (fraction)b;
363 if ((
COM(fa) == 1) && (
COM(fb) == 1))
369 if (DENIS1(fa) && DENIS1(fb))
return TRUE;
370 if (DENIS1(fa) && !DENIS1(fb))
return FALSE;
371 if (!DENIS1(fa) && DENIS1(fb))
return FALSE;
398 if (IS0(a))
return NULL;
399 fraction
f = (fraction)a;
404 NUM(result) =
p_Copy(g,cf->extRing);
405 DEN(result) =
p_Copy(h,cf->extRing);
416 if (IS0(a))
return NULL;
420 fraction
f = (fraction)a;
423 const BOOLEAN denis1= DENIS1 (f);
490 fraction
f = (fraction)a;
494 const BOOLEAN denis1 = DENIS1 (f);
512 if( DEN (f) !=
NULL )
580 fraction
f = (fraction)a;
589 fraction
f = (fraction)a;
590 if ((f==
NULL) || (!DENIS1(f)))
return FALSE;
603 fraction
f = (fraction)a;
689 if (IS0(a))
return 0;
691 fraction
f = (fraction)a;
692 if (!DENIS1(f))
return 0;
694 const poly aAsPoly = NUM(f);
719 number aNumCoeff =
NULL;
int aNumDeg = 0;
720 number aDenCoeff =
NULL;
int aDenDeg = 0;
721 number bNumCoeff =
NULL;
int bNumDeg = 0;
722 number bDenCoeff =
NULL;
int bDenDeg = 0;
725 fraction fa = (fraction)a;
737 fraction fb = (fraction)b;
747 if (aNumDeg-aDenDeg > bNumDeg-bDenDeg)
return TRUE;
748 if (aNumDeg-aDenDeg < bNumDeg-bDenDeg)
return FALSE;
770 if (IS0(a))
return FALSE;
771 fraction
f = (fraction)a;
780 const ring
A = cf->extRing;
789 const int P =
rVar(A);
792 Print(
"// %d parameter : ", P);
794 for (
int nop=0; nop <
P; nop ++)
799 PrintS(
"\n// minpoly : 0\n");
826 fraction t = (fraction) d;
829 WerrorS(
"expected differentiation by a variable");
835 WerrorS(
"expected differentiation by a variable");
839 if (IS0(a))
return ntCopy(a, cf);
841 fraction fa = (fraction)a;
847 if (NUM(result)==
NULL)
861 if (NUM(result)==
NULL)
return(
NULL);
878 if (IS0(a))
return ntCopy(b, cf);
879 if (IS0(b))
return ntCopy(a, cf);
881 fraction fa = (fraction)a;
882 fraction fb = (fraction)b;
893 if (DENIS1(fa) && DENIS1(fb)) f =
NULL;
894 else if (!DENIS1(fa) && DENIS1(fb)) f =
p_Copy(DEN(fa),
ntRing);
895 else if (DENIS1(fa) && !DENIS1(fb)) f =
p_Copy(DEN(fb),
ntRing);
920 if (IS0(b))
return ntCopy(a, cf);
922 fraction fa = (fraction)a;
923 fraction fb = (fraction)b;
934 if (DENIS1(fa) && DENIS1(fb)) f =
NULL;
935 else if (!DENIS1(fa) && DENIS1(fb)) f =
p_Copy(DEN(fa),
ntRing);
936 else if (DENIS1(fa) && !DENIS1(fb)) f =
p_Copy(DEN(fb),
ntRing);
959 if (IS0(a) || IS0(b))
return NULL;
961 fraction fa = (fraction)a;
962 fraction fb = (fraction)b;
972 const poly da = DEN(fa);
973 const poly db = DEN(fb);
1027 && (DEN(result)!=
NULL))
1034 NUM(result)=
p_Mult_nn(NUM(result),inv,R);
1053 if (IS0(a))
return NULL;
1056 fraction fa = (fraction)a;
1057 fraction fb = (fraction)b;
1104 if (exp >= 0) *b =
NULL;
1107 else if (exp == 0) { *b =
ntInit(1, cf);
return;}
1108 else if (exp == 1) { *b =
ntCopy(a, cf);
return;}
1109 else if (exp == -1) { *b =
ntInvers(a, cf);
return;}
1111 int expAbs =
exp;
if (expAbs < 0) expAbs = -expAbs;
1114 number
pow; number t;
1118 for (
int i = 2;
i <= expAbs;
i++)
1134 t =
ntMult(pow, factor, cf);
1139 expAbs = expAbs / 2;
1142 t =
ntMult(factor, factor, cf);
1195 number c; number tmp;
1204 lcmOfDenominators = tmp;
1213 lcmOfDenominators = tmp;
1234 gcdOfCoefficients = tmp;
1243 gcdOfCoefficients = tmp;
1248 number inverseOfGcdOfCoefficients =
n_Invers(gcdOfCoefficients,
1262 if ((DEN(f) !=
NULL) &&
1269 if( DEN(f) !=
NULL )
1285 fraction
f = (fraction)a;
1287 if (DENIS1(f) ||
NUMIS1(f)) {
COM(f) = 0;
return; }
1305 if( DEN(f) !=
NULL )
1349 }
while(i<ntRing->
N);
1367 BOOLEAN simpleTestsHaveAlreadyBeenPerformed)
1371 fraction
f = (fraction)a;
1375 if (!simpleTestsHaveAlreadyBeenPerformed)
1497 if( DEN(f) !=
NULL )
1522 fraction
f = (fraction)a;
1547 fraction
f = (fraction)a;
1582 if ((DEN((fraction)a)!=
NULL)
1620 fraction fb = (fraction)b;
1622 fraction fa = (fraction)a;
1637 number contentpa, contentpb, tmp;
1710 fraction fa = (fraction)a;
1711 fraction fb = (fraction)b;
1726 number contentpa, contentpb, tmp;
1783 if (IS0(a))
return -1;
1788 fraction
f = (fraction)a;
1804 return numDegree + denDegree + noOfTerms;
1816 fraction
f = (fraction)a;
1842 DEN(result) = num_f;
1871 assume(src->rep == dst->extRing->cf->rep);
1881 fraction ff=(fraction)res;
1883 else DEN(ff)=
p_NSet(nn,dst->extRing);
1895 poly p=
p_NSet(nMap(a, src,dst->extRing->cf), dst->extRing);
1909 int n =
n_Int(a, src);
1910 number q =
n_Init(n, dst->extRing->cf);
1923 if (IS0(a))
return NULL;
1925 const ring rSrc = cf->extRing;
1926 const ring rDst = dst->extRing;
1931 fraction
f = (fraction)a;
1937 h =
prCopyR(DEN(f), rSrc, rDst);
1945 n_Test((number)result, dst);
1952 if (IS0(a))
return NULL;
1954 const ring rSrc = cf->extRing;
1955 const ring rDst = dst->extRing;
1958 fraction
f = (fraction)a;
1990 h =
prMapR(DEN(f), nMap, rSrc, rDst);
2024 n_Test((number)result, dst);
2051 number q =
nlModP(a, src, dst->extRing->cf);
2073 assume(src == dst->extRing->cf);
2089 int n =
n_Int(a, src);
2090 number q =
n_Init(n, dst->extRing->cf);
2097 p =
p_One(dst->extRing);
2131 if (src->ch == dst->ch)
return ntMapPP;
2135 if (h != 1)
return NULL;
2143 if (
rVar(src->extRing) >
rVar(dst->extRing))
2146 for (
int i = 0;
i <
rVar(src->extRing);
i++)
2152 if (src->extRing->cf==dst->extRing->cf)
2159 if (src->extRing->cf==dst->extRing->cf)
2171 if (n==
ntCopyAlg) printf(
"n=ntCopyAlg\n");
2172 else if (n==
ntCopyMap) printf(
"n=ntCopyMap\n");
2173 else if (n==
ntMapUP) printf(
"n=ntMapUP\n");
2174 else if (n==
ntMap0P) printf(
"n=ntMap0P\n");
2175 else if (n==
ntMapP0) printf(
"n=ntMapP0\n");
2176 else if (n==
ntMap00) printf(
"n=ntMap00\n");
2177 else if (n==
NULL) printf(
"n=NULL\n");
2178 else printf(
"n=?\n");
2185 if ((--cf->extRing->ref) == 0)
2205 fraction
f = (fraction)n;
2212 if (IS0(a))
return -1;
2213 fraction fa = (fraction)a;
2214 return cf->extRing->pFDeg(NUM(fa),cf->extRing);
2222 const ring
R = cf->extRing;
2224 assume( 0 < iParameter && iParameter <=
rVar(R) );
2245 const ring
R = cf->extRing;
2248 fraction
f = (fraction)m;
2250 if( DEN(f) !=
NULL )
2253 return p_Var( NUM(f), R );
2261 return NUM((fraction)n);
2273 const ring
R = cf->extRing;
2280 numberCollectionEnumerator.
Reset();
2282 if( !numberCollectionEnumerator.
MoveNext() )
2295 number &n = numberCollectionEnumerator.
Current();
2299 fraction
f = (fraction)n;
2317 while( numberCollectionEnumerator.
MoveNext() ) ;
2326 numberCollectionEnumerator.
Reset();
2327 while (numberCollectionEnumerator.
MoveNext() )
2329 number &n = numberCollectionEnumerator.
Current();
2330 const number t =
ntDiv(n, c, cf);
2347 number gg =
ntMult(g, c, cf);
2361 numberCollectionEnumerator.
Reset();
2363 if( !numberCollectionEnumerator.
MoveNext() )
2374 const ring
R = cf->extRing;
2383 number &n = numberCollectionEnumerator.
Current();
2418 while( numberCollectionEnumerator.
MoveNext() );
2428 numberCollectionEnumerator.
Reset();
2432 while (numberCollectionEnumerator.
MoveNext() )
2434 number &n = numberCollectionEnumerator.
Current();
2435 number t =
ntMult(n, c, cf);
2441 fraction
f = (fraction)t;
2463 numberCollectionEnumerator.
Reset();
2464 while (numberCollectionEnumerator.
MoveNext() )
2466 number &n = numberCollectionEnumerator.
Current();
2467 fraction
f = (fraction)n;
2491 NUM((fraction)c) =
p_Mult_nn(NUM((fraction)c), d, R);
2504 number *X=(number *)
omAlloc(rl*
sizeof(number));
2508 for(i=0;i<rl;i++) P[i]=
p_Copy(NUM((fraction)(x[
i])),cf->extRing);
2513 P[
i]=
p_Copy(DEN((fraction)(x[i])),cf->extRing);
2526 return ((number)result);
2533 NUM(result)=
p_Farey(
p_Copy(NUM((fraction)p),cf->extRing),n,cf->extRing);
2534 DEN(result)=
p_Farey(
p_Copy(DEN((fraction)p),cf->extRing),n,cf->extRing);
2536 return ((number)result);
2567 cf->factoryVarOffset = R->cf->factoryVarOffset +
rVar(R);
2581 cf->cfInpNeg =
ntNeg;
2586 cf->cfExactDiv =
ntDiv;
2603 cf->cfSubringGcd =
ntGcd;
2619 cf->iNumberOfParameters =
rVar(R);
2620 cf->pParameterNames = (
const char**)R->names;
2622 cf->has_simple_Inverse=
FALSE;
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 number n_GetNumerator(number &n, const coeffs r)
return the numerator of n (if elements of r are by nature not fractional, result is n) ...
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ...
long ntInt(number &a, const coeffs cf)
const CanonicalForm int s
poly p_Diff(poly a, int k, const ring r)
#define BOUND_COMPLEXITY
maximum complexity of a number
poly singclap_gcd_r(poly f, poly g, const ring r)
poly singclap_gcd_and_divide(poly &f, poly &g, const ring r)
clears denominators of f and g, divides by gcd(f,g)
number ntNormalizeHelper(number a, number b, const coeffs cf)
static void ntNormalizeDen(fraction result, const ring R)
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
number ntDiff(number a, number d, const coeffs cf)
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
number ntMap00(number a, const coeffs src, const coeffs dst)
number ntMapUP(number a, const coeffs src, const coeffs dst)
poly prCopyR(poly p, ring src_r, ring dest_r)
number ntGenMap(number a, const coeffs cf, const coeffs dst)
number ntImPart(number a, const coeffs cf)
void ntWriteLong(number a, const coeffs cf)
void ntDelete(number *a, const coeffs cf)
static poly convert(const number &n)
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
#define DIFF_COMPLEXITY
complexity increase due to * and /
void p_String0Long(const poly p, ring lmRing, ring tailRing)
print p in a long way
number ntDiv(number a, number b, const coeffs cf)
static FORCE_INLINE BOOLEAN nlIsInteger(number q, const coeffs r)
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)
BOOLEAN ntIsMOne(number a, const coeffs cf)
number ntMult(number a, number b, 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
static FORCE_INLINE BOOLEAN nCoeff_is_Q_or_BI(const coeffs r)
#define omFreeSize(addr, size)
number ntSub(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.
static FORCE_INLINE BOOLEAN nCoeff_has_simple_inverse(const coeffs r)
TRUE, if the computation of the inverse is fast, i.e. prefer leading coeff. 1 over content...
poly p_Div_nn(poly p, const number n, const ring r)
int ntSize(number a, const coeffs cf)
void handleNestedFractionsOverQ(fraction f, const coeffs cf)
static long p_Totaldegree(poly p, const ring r)
BOOLEAN ntIsZero(number a, const coeffs cf)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
void ntWriteShort(number a, const coeffs cf)
BOOLEAN ntDBTest(number a, const char *f, const int l, const coeffs r)
void WerrorS(const char *s)
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...
(fraction), see transext.h
nMapFunc ntSetMap(const coeffs src, const coeffs dst)
Get a mapping function from src into the domain of this type (n_transExt)
void p_Norm(poly p1, const ring r)
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)
static number p_SetCoeff(poly p, number n, ring r)
poly p_Sub(poly p1, poly p2, const ring r)
static coeffs nCoeff_bottom(const coeffs r, int &height)
static BOOLEAN rCanShortOut(const ring r)
static int pLength(poly a)
BOOLEAN ntIsOne(number a, const coeffs cf)
static poly p_Copy(poly p, const ring r)
returns a copy of p
void ntNormalize(number &a, const coeffs cf)
poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
number ntInvers(number a, const coeffs cf)
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
BOOLEAN ntGreater(number a, number b, const coeffs cf)
static int ntParDeg(number a, const coeffs cf)
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...
const char * p_Read(const char *st, poly &rc, const ring r)
number ntCopyMap(number a, const coeffs cf, const coeffs dst)
const char * ntRead(const char *s, number *a, const coeffs cf)
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 ...
static void ntClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
number ntMapPP(number a, const coeffs src, const coeffs dst)
Coefficient rings, fields and other domains suitable for Singular polynomials.
poly p_Farey(poly p, number N, const ring r)
CanonicalForm ntConvSingNFactoryN(number n, BOOLEAN, const coeffs cf)
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 ...
const CanonicalForm CFMap CFMap & N
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:
This is a polynomial enumerator for simple iteration over coefficients of polynomials.
number ntInit(long i, const coeffs cf)
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 ntFarey(number p, number n, const coeffs cf)
number ntGetDenom(number &a, const coeffs cf)
TODO: normalization of a!?
number ntGenAlg(number a, const coeffs cf, const coeffs dst)
static poly pp_Mult_qq(poly p, poly q, const ring r)
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 ntMapP0(number a, const coeffs src, const coeffs dst)
static const n_coeffType ID
Our own type!
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 ntNeg(number a, const coeffs cf)
this is in-place, modifies a
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
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 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 BOOLEAN ntCoeffIsEqual(const coeffs cf, n_coeffType n, void *param)
#define NUMIS1(f)
TRUE iff num. represents 1.
struct for passing initialization parameters to naInitChar
const char *const nDivBy0
static BOOLEAN p_IsOne(const poly p, const ring R)
either poly(1) or gen(k)?!
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)
BOOLEAN ntGreaterZero(number a, const coeffs cf)
forward declarations
number ntChineseRemainder(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs cf)
number ntRePart(number a, const coeffs cf)
static poly p_LmFreeAndNext(poly p, ring)
void definiteGcdCancellation(number a, const coeffs cf, BOOLEAN simpleTestsHaveAlreadyBeenPerformed)
modifies a
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
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)
number ntCopy(number a, const coeffs cf)
static void ntClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
void p_Normalize(poly p, const ring r)
static void p_Delete(poly *p, const ring r)
#define omGetSpecBin(size)
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, 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
void heuristicGcdCancellation(number a, 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 ntAdd(number a, number b, const coeffs cf)
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
static number ntParameter(const int iParameter, const coeffs cf)
return the specified parameter as a number in the given trans.ext.
void rDelete(ring r)
unconditionally deletes fields in r
BOOLEAN ntEqual(number a, number b, const coeffs cf)
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 ntMapZ0(number a, const coeffs src, const coeffs dst)
void ntPower(number a, int exp, number *b, const coeffs cf)
poly p_ChineseRemainder(poly *xx, number *x, number *q, int rl, CFArray &inv_cache, const ring R)
void ntKillChar(coeffs cf)
number ntConvFactoryNSingN(const CanonicalForm n, const coeffs cf)
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 void p_Setm(poly p, const ring r)
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
number ntGetNumerator(number &a, const coeffs cf)
TODO: normalization of a!?
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
int ntIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
static poly p_Neg(poly p, const ring r)
number ntMap0P(number a, const coeffs src, const coeffs dst)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
void p_wrp(poly p, ring lmRing, ring tailRing)
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.
void p_Write(poly p, ring lmRing, ring tailRing)
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
#define ADD_COMPLEXITY
complexity increase due to + and -
static poly p_Add_q(poly p, poly q, const ring r)
#define omFreeBin(addr, bin)
Rational pow(const Rational &a, int e)
number ntCopyAlg(number a, const coeffs cf, const coeffs dst)
number ntGcd(number a, number b, const coeffs cf)
int p_Var(poly m, const ring r)
#define MULT_COMPLEXITY
complexity increase due to * and /
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)
void ntCoeffWrite(const coeffs cf, BOOLEAN details)
void p_String0Short(const poly p, ring lmRing, ring tailRing)
print p in a short way, if possible
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...
BOOLEAN ntInitChar(coeffs cf, void *infoStruct)
Initialize the coeffs object.