 |
My Project
UNKNOWN_GIT_VERSION
|
Go to the documentation of this file.
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)
81 #define ntRing cf->extRing
87 #define ntCoeffs cf->extRing->cf
95 BOOLEAN simpleTestsHaveAlreadyBeenPerformed);
145 if (IS0(a))
return TRUE;
147 const fraction t = (fraction)a;
159 Print(
"ERROR in %s:%d: non-integer Q coeff in num. poly\n",
f,
l);
164 const poly
den = DEN(t);
174 Print(
"ERROR in %s:%d: non-integer Q coeff in den. poly\n",
f,
l);
183 Print(
"ERROR in %s:%d: constant den. poly / Zp\n",
f,
l);
191 Print(
"ERROR in %s:%d: non-monic den. poly / Zp\n",
f,
l);
205 Print(
"ERROR in %s:%d: 1 != GCD between num. & den. poly\n",
f,
l);
223 Print(
"negative sign of DEN. of a fraction in %s:%d\n",
f,
l);
256 Print(
"rational coeff in num: %s:%d\n",
f,
l);
267 Print(
"rational coeff in den.:%s:%d\n",
f,
l);
301 cf =
cf->extRing->cf;
319 fraction
f = (fraction)(*a);
335 if (a ==
b)
return TRUE;
336 if ((IS0(a)) && (!IS0(
b)))
return FALSE;
337 if ((IS0(
b)) && (!IS0(a)))
return FALSE;
340 fraction
fa = (fraction)a;
341 fraction
fb = (fraction)
b;
348 if (DENIS1(
fa) && DENIS1(
fb))
return TRUE;
349 if (DENIS1(
fa) && !DENIS1(
fb))
return FALSE;
350 if (!DENIS1(
fa) && DENIS1(
fb))
return FALSE;
377 if (IS0(a))
return NULL;
378 fraction
f = (fraction)a;
422 number c; number tmp;
431 lcmOfDenominators = tmp;
440 lcmOfDenominators = tmp;
461 gcdOfCoefficients = tmp;
470 gcdOfCoefficients = tmp;
475 number inverseOfGcdOfCoefficients =
n_Invers(gcdOfCoefficients,
489 if ((DEN(
f) !=
NULL) &&
511 if (IS0(a))
return NULL;
515 fraction
f = (fraction)a;
585 fraction
f = (fraction)a;
607 if( DEN (
f) !=
NULL )
675 fraction
f = (fraction)a;
684 fraction
f = (fraction)a;
698 fraction
f = (fraction)a;
778 if (IS0(a))
return 0;
780 fraction
f = (fraction)a;
781 if (!DENIS1(
f))
return 0;
783 const poly aAsPoly =
NUM(
f);
801 if (IS0(a))
return FALSE;
802 fraction
f = (fraction)a;
816 fraction
fb = (fraction)
b;
821 fraction
fa = (fraction)a;
825 fraction
fa = (fraction)a;
828 number aDenCoeff =
NULL;
int aDenDeg = 0;
834 fraction
fb = (fraction)
b;
837 number bDenCoeff =
NULL;
int bDenDeg = 0;
843 if (aNumDeg-aDenDeg > bNumDeg-bDenDeg)
return TRUE;
844 if (aNumDeg-aDenDeg < bNumDeg-bDenDeg)
return FALSE;
861 const ring
A =
cf->extRing;
870 const int P =
rVar(
A);
875 for (
int nop=0; nop < P; nop ++)
878 if (nop!=P-1)
PrintS(
", ");
910 fraction t = (fraction) d;
913 WerrorS(
"expected differentiation by a variable");
919 WerrorS(
"expected differentiation by a variable");
925 fraction
fa = (fraction)a;
964 fraction
fa = (fraction)a;
965 fraction
fb = (fraction)
b;
1005 fraction
fa = (fraction)a;
1006 fraction
fb = (fraction)
b;
1042 if (IS0(a) || IS0(
b))
return NULL;
1044 fraction
fa = (fraction)a;
1045 fraction
fb = (fraction)
b;
1055 const poly da = DEN(
fa);
1056 const poly db = DEN(
fb);
1136 if (IS0(a))
return NULL;
1139 fraction
fa = (fraction)a;
1140 fraction
fb = (fraction)
b;
1185 fraction
f = (fraction)a;
1191 const poly
den = DEN(
f);
1256 int expAbs =
exp;
if (expAbs < 0) expAbs = -expAbs;
1259 number
pow; number t;
1263 for (
int i = 2;
i <= expAbs;
i++)
1284 expAbs = expAbs / 2;
1314 fraction
f = (fraction)a;
1334 if( DEN(
f) !=
NULL )
1378 }
while(i<ntRing->
N);
1396 BOOLEAN simpleTestsHaveAlreadyBeenPerformed)
1400 fraction
f = (fraction)a;
1403 if (
COM(
f)==0)
return;
1405 if (!simpleTestsHaveAlreadyBeenPerformed)
1535 if( DEN(
f) !=
NULL )
1560 fraction
f = (fraction)a;
1585 fraction
f = (fraction)a;
1620 if ((DEN((fraction)a)!=
NULL)
1658 fraction
fb = (fraction)
b;
1660 fraction
fa = (fraction)a;
1674 number contentpa, contentpb, tmp;
1741 fraction
fa = (fraction)a;
1742 fraction
fb = (fraction)
b;
1757 number contentpa, contentpb, tmp;
1811 if (IS0(a))
return 0;
1812 fraction
f = (fraction)a;
1814 unsigned long noOfTerms = 0;
1815 unsigned long numDegree = 0;
1821 unsigned long denDegree = 0;
1829 unsigned long t= ((numDegree + denDegree)*(numDegree + denDegree) + 1) * noOfTerms;
1830 if (t>INT_MAX)
return INT_MAX;
1840 assume(src->rep == dst->extRing->cf->rep);
1850 fraction ff=(fraction)
res;
1852 else DEN(ff)=
p_NSet(nn,dst->extRing);
1864 poly
p=
p_NSet(nMap(a, src,dst->extRing->cf), dst->extRing);
1878 int n =
n_Int(a, src);
1879 number q =
n_Init(n, dst->extRing->cf);
1892 if (IS0(a))
return NULL;
1894 const ring rSrc =
cf->extRing;
1895 const ring rDst = dst->extRing;
1900 fraction
f = (fraction)a;
1921 if (IS0(a))
return NULL;
1923 const ring rSrc =
cf->extRing;
1924 const ring rDst = dst->extRing;
1927 fraction
f = (fraction)a;
1959 h =
prMapR(DEN(
f), nMap, rSrc, rDst);
2010 return ntInit(
prMapR((poly)a, nMap,
cf->extRing, dst->extRing),dst);
2020 number q =
nlModP(a, src, dst->extRing->cf);
2028 poly
g =
p_NSet(q, dst->extRing);
2042 assume(src == dst->extRing->cf);
2043 poly
p =
p_One(dst->extRing);
2058 int n =
n_Int(a, src);
2059 number q =
n_Init(n, dst->extRing->cf);
2100 if (src->ch == dst->ch)
return ntMapPP;
2105 if (mpz_cmp(src->modNumber,bDst->modNumber)==0)
return ntMapPP;
2108 if (
h != 1)
return NULL;
2116 if (
rVar(src->extRing) >
rVar(dst->extRing))
2119 for (
int i = 0;
i <
rVar(src->extRing);
i++)
2125 if (src->extRing->cf==dst->extRing->cf)
2132 if (src->extRing->cf==dst->extRing->cf)
2144 if (n==
ntCopyAlg) printf(
"n=ntCopyAlg\n");
2145 else if (n==
ntCopyMap) printf(
"n=ntCopyMap\n");
2146 else if (n==
ntMapUP) printf(
"n=ntMapUP\n");
2147 else if (n==
ntMap0P) printf(
"n=ntMap0P\n");
2148 else if (n==
ntMapP0) printf(
"n=ntMapP0\n");
2149 else if (n==
ntMap00) printf(
"n=ntMap00\n");
2150 else if (n==
NULL) printf(
"n=NULL\n");
2151 else printf(
"n=?\n");
2158 if ((--
cf->extRing->ref) == 0)
2178 fraction
f = (fraction)n;
2185 if (IS0(a))
return -1;
2186 fraction
fa = (fraction)a;
2187 return cf->extRing->pFDeg(
NUM(
fa),
cf->extRing);
2195 const ring
R =
cf->extRing;
2197 assume( 0 < iParameter && iParameter <=
rVar(
R) );
2218 const ring
R =
cf->extRing;
2221 fraction
f = (fraction)
m;
2223 if( DEN(
f) !=
NULL )
2234 return NUM((fraction)n);
2246 const ring
R =
cf->extRing;
2253 numberCollectionEnumerator.
Reset();
2255 if( !numberCollectionEnumerator.
MoveNext() )
2268 number &n = numberCollectionEnumerator.
Current();
2272 fraction
f = (fraction)n;
2276 const poly
den = DEN(
f);
2294 while( numberCollectionEnumerator.
MoveNext() ) ;
2303 numberCollectionEnumerator.
Reset();
2304 while (numberCollectionEnumerator.
MoveNext() )
2306 number &n = numberCollectionEnumerator.
Current();
2307 const number t =
ntDiv(n, c,
cf);
2338 numberCollectionEnumerator.
Reset();
2340 if( !numberCollectionEnumerator.
MoveNext() )
2351 const ring
R =
cf->extRing;
2360 number &n = numberCollectionEnumerator.
Current();
2395 while( numberCollectionEnumerator.
MoveNext() );
2405 numberCollectionEnumerator.
Reset();
2409 while (numberCollectionEnumerator.
MoveNext() )
2411 number &n = numberCollectionEnumerator.
Current();
2418 fraction
f = (fraction)t;
2421 const poly
den = DEN(
f);
2440 numberCollectionEnumerator.
Reset();
2441 while (numberCollectionEnumerator.
MoveNext() )
2443 number &n = numberCollectionEnumerator.
Current();
2444 fraction
f = (fraction)n;
2448 const poly
den = DEN(
f);
2480 poly *P=(poly*)
omAlloc(rl*
sizeof(poly*));
2481 number *X=(number *)
omAlloc(rl*
sizeof(number));
2544 cf->factoryVarOffset =
R->cf->factoryVarOffset +
rVar(
R);
2597 cf->iNumberOfParameters =
rVar(
R);
2598 cf->pParameterNames = (
const char**)
R->names;
2600 cf->has_simple_Inverse=
FALSE;
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
@ n_rep_gap_rat
(number), see longrat.h
static poly p_LmFreeAndNext(poly p, ring)
static number ntGenAlg(number a, const coeffs cf, const coeffs dst)
static number ntAdd(number a, number b, const coeffs cf)
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
struct for passing initialization parameters to naInitChar
void StringAppendS(const char *st)
static BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
static number ntNormalizeHelper(number a, number b, const coeffs cf)
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 BOOLEAN ntGreater(number a, number b, const coeffs cf)
void p_Normalize(poly p, const ring r)
static number ntMult(number a, number b, const coeffs cf)
virtual reference Current()=0
Gets the current element in the collection (read and write).
static BOOLEAN rCanShortOut(const ring r)
static void p_ExpVectorDiff(poly pr, poly p1, poly p2, const ring r)
char * naCoeffName(const coeffs r)
static number ntInvers(number a, const coeffs cf)
#define omGetSpecBin(size)
static number ntNeg(number a, const coeffs cf)
this is in-place, modifies a
static number ntMapUP(number a, const coeffs src, const coeffs dst)
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)
int p_Var(poly m, const ring r)
static coeffs nCoeff_bottom(const coeffs r, int &height)
static poly p_Neg(poly p, const ring r)
static int ntParDeg(number a, const coeffs cf)
poly p_ChineseRemainder(poly *xx, number *x, number *q, int rl, CFArray &inv_cache, const ring R)
poly singclap_pdivide(poly f, poly g, const ring r)
static FORCE_INLINE BOOLEAN nlIsInteger(number q, const coeffs r)
static BOOLEAN p_IsOne(const poly p, const ring R)
either poly(1) or gen(k)?!
static FORCE_INLINE BOOLEAN nCoeff_is_Q_or_BI(const coeffs r)
static void ntCoeffWrite(const coeffs cf, BOOLEAN details)
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static number ntDiv(number a, number b, const coeffs cf)
void p_wrp(poly p, ring lmRing, ring tailRing)
@ n_Q
rational (GMP) numbers
static CanonicalForm ntConvSingNFactoryN(number n, BOOLEAN, const coeffs cf)
number ntDiff(number a, number d, const coeffs cf)
const CanonicalForm CFMap CFMap & N
static void ntNormalize(number &a, const coeffs cf)
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
static number ntChineseRemainder(number *x, number *q, int rl, BOOLEAN, CFArray &inv_cache, 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 BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
static void ntClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
#define ADD_COMPLEXITY
complexity increase due to + and -
static number ntCopyAlg(number a, const coeffs cf, const coeffs dst)
#define __p_Mult_nn(p, n, r)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
void p_String0Short(const poly p, ring lmRing, ring tailRing)
print p in a short way, if possible
static number ntGenMap(number a, const coeffs cf, const coeffs dst)
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,...
poly gcd_over_Q(poly f, poly g, const ring r)
helper routine for calling singclap_gcd_r
static BOOLEAN ntIsOne(number a, const coeffs cf)
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
virtual void Reset()=0
Sets the enumerator to its initial position: -1, which is before the first element in the collection.
static unsigned pLength(poly a)
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise,...
@ n_rep_rat_fct
(fraction), see transext.h
static BOOLEAN ntEqual(number a, number b, const coeffs cf)
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
static poly p_Copy(poly p, const ring r)
returns a copy of p
static short rVar(const ring r)
#define rVar(r) (r->N)
static number ntMap0P(number a, const coeffs src, const coeffs dst)
static poly convert(const number &n)
poly p_Sub(poly p1, poly p2, const ring r)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
static number ntMapPP(number a, const coeffs src, const coeffs dst)
static void ntClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
static void ntNormalizeDen(fraction result, const ring R)
static BOOLEAN ntCoeffIsEqual(const coeffs cf, n_coeffType n, void *param)
const char *const nDivBy0
void PrintS(const char *s)
#define omFreeSize(addr, size)
static number ntCopyMap(number a, const coeffs cf, const coeffs dst)
static char * rRingVar(short i, const ring r)
static number ntSub(number a, number b, const coeffs cf)
poly p_Div_nn(poly p, const number n, const ring r)
void p_String0Long(const poly p, ring lmRing, ring tailRing)
print p in a long way
poly p_Farey(poly p, number N, const ring r)
static number ntGetNumerator(number &a, const coeffs cf)
TODO: normalization of a!?
static poly pp_Mult_qq(poly p, poly q, const ring r)
void p_Write(poly p, ring lmRing, ring tailRing)
BOOLEAN fa(leftv res, leftv args)
poly p_Cleardenom(poly p, const ring r)
char * naCoeffString(const coeffs 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
static number ntConvFactoryNSingN(const CanonicalForm n, const coeffs cf)
const char * p_Read(const char *st, poly &rc, const ring r)
number nlModP(number q, const coeffs, const coeffs Zp)
static number ntGcd(number a, number b, const coeffs cf)
static BOOLEAN ntIsZero(number a, const coeffs cf)
static void handleNestedFractionsOverQ(fraction f, const coeffs cf)
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
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 number ntFarey(number p, number n, const coeffs cf)
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
static void ntWriteLong(number a, const coeffs cf)
BOOLEAN ntInitChar(coeffs cf, void *infoStruct)
Initialize the coeffs object.
CanonicalForm convSingPFactoryP(poly p, const ring r)
gmp_float exp(const gmp_float &a)
static number ntMapP0(number a, const coeffs src, const coeffs dst)
void rDelete(ring r)
unconditionally deletes fields in r
const CanonicalForm const CanonicalForm const CanonicalForm const CanonicalForm & cand
int ntIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
number ntInit(long i, const coeffs cf)
static void p_Delete(poly *p, const ring r)
static poly p_Add_q(poly p, poly q, const ring r)
static number ntGetDenom(number &a, const coeffs cf)
TODO: normalization of a!?
#define BOUND_COMPLEXITY
maximum complexity of a number
virtual bool MoveNext()=0
Advances the enumerator to the next element of the collection. returns true if the enumerator was suc...
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 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 p_EqualPolys(poly p1, poly p2, const ring r)
static BOOLEAN ntDBTest(number a, const char *f, const int l, const coeffs r)
#define DIFF_COMPLEXITY
complexity increase due to * and /
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...
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
poly singclap_gcd_r(poly f, poly g, const ring r)
static void ntDelete(number *a, const coeffs cf)
static number p_SetCoeff(poly p, number n, ring r)
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),...
static number ntParameter(const int iParameter, const coeffs cf)
return the specified parameter as a number in the given trans.ext.
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Rational pow(const Rational &a, int e)
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,...
void WerrorS(const char *s)
static void ntPower(number a, int exp, number *b, const coeffs cf)
static number ntMap00(number a, const coeffs src, const coeffs dst)
static const char * ntRead(const char *s, number *a, const coeffs cf)
static FORCE_INLINE BOOLEAN nCoeff_is_Zn(const coeffs r)
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
static void definiteGcdCancellation(number a, const coeffs cf, BOOLEAN simpleTestsHaveAlreadyBeenPerformed)
modifies a
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 ....
static void p_Setm(poly p, const ring r)
static long p_Totaldegree(poly p, const ring r)
static number ntMapZ0(number a, const coeffs src, const coeffs dst)
static BOOLEAN p_IsConstant(const poly p, const ring r)
static long ntInt(number &a, const coeffs cf)
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...
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
static void ntKillChar(coeffs cf)
static BOOLEAN ntIsMOne(number a, const coeffs cf)
void p_Norm(poly p1, 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)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
static void heuristicGcdCancellation(number a, const coeffs cf)
forward declarations
#define omFreeBin(addr, bin)
#define MULT_COMPLEXITY
complexity increase due to * and /
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 ntWriteShort(number a, const coeffs cf)
static BOOLEAN ntGreaterZero(number a, const coeffs cf)
static number ntCopy(number a, const coeffs cf)
nMapFunc ntSetMap(const coeffs src, const coeffs dst)
Get a mapping function from src into the domain of this type (n_transExt)
static int ntSize(number a, const coeffs cf)
#define NUMIS1(f)
TRUE iff num. represents 1.
poly prCopyR(poly p, ring src_r, ring dest_r)
poly convFactoryPSingP(const CanonicalForm &f, 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)
go into polynomials over an alg. extension recursively
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.
BOOLEAN fb(leftv res, leftv args)
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
poly p_Diff(poly a, int k, const ring r)
@ n_rep_gap_gmp
(), see rinteger.h, new impl.