coeffs.h File Reference

Coefficient rings, fields and other domains suitable for Singular polynomials. More...

#include <misc/auxiliary.h>
#include <omalloc/omalloc.h>
#include <misc/sirandom.h>
#include <reporter/reporter.h>
#include <reporter/s_buff.h>
#include <coeffs/si_gmp.h>
#include <coeffs/Enumerator.h>
#include <coeffs/numstats.h>

Go to the source code of this file.

Data Structures
struct	GFInfo
	Creation data needed for finite fields. More...
struct	LongComplexInfo
struct	coeffs

Macros
#define	FREE_RNUMBER(x)   omFreeBin((void *)x, rnumber_bin)
#define	ALLOC_RNUMBER()   (number)omAllocBin(rnumber_bin)
#define	ALLOC0_RNUMBER()   (number)omAlloc0Bin(rnumber_bin)
#define	n_New(n, r)   nNew(n)
#define	n_Test(a, r)   n_DBTest(a, __FILE__, __LINE__, r)
	BOOLEAN n_Test(number a, const coeffs r) More...

Typedefs
typedef number(*	numberfunc) (number a, number b, const coeffs r)
typedef number(*	nMapFunc) (number a, const coeffs src, const coeffs dst)
	maps "a", which lives in src, into dst More...
typedef IEnumerator< number >	ICoeffsEnumerator
	Abstract interface for an enumerator of number coefficients for an object, e.g. a polynomial. More...
typedef void(*	nCoeffsEnumeratorFunc) (ICoeffsEnumerator &numberCollectionEnumerator, number &output, const coeffs r)
	goes over coeffs given by the ICoeffsEnumerator and changes them. Additionally returns a number; More...

Enumerations
enum	n_coeffType {   n_unknown =0, n_Zp, n_Q, n_R,   n_GF, n_long_R, n_algExt, n_transExt,   n_long_C, n_Z, n_Zn, n_Znm,   n_Z2m, n_CF }
enum	n_coeffRep {   n_rep_unknown =0, n_rep_int, n_rep_gap_rat, n_rep_gap_gmp,   n_rep_poly, n_rep_rat_fct, n_rep_gmp, n_rep_float,   n_rep_gmp_float, n_rep_gmp_complex, n_rep_gf }

Functions
static FORCE_INLINE n_coeffType	getCoeffType (const coeffs r)
	Returns the type of coeffs domain. More...
coeffs	nInitChar (n_coeffType t, void *parameter)
	one-time initialisations for new coeffs in case of an error return NULL More...
static FORCE_INLINE coeffs	nCopyCoeff (const coeffs r)
	"copy" coeffs, i.e. increment ref More...
void	nKillChar (coeffs r)
	undo all initialisations More...
static FORCE_INLINE void	nSetChar (const coeffs r)
	initialisations after each ring change More...
void	nNew (number *a)
static FORCE_INLINE int	n_GetChar (const coeffs r)
	Return the characteristic of the coeff. domain. More...
static FORCE_INLINE number	n_Copy (number n, const coeffs r)
	return a copy of 'n' More...
static FORCE_INLINE void	n_Delete (number *p, const coeffs r)
	delete 'p' More...
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. More...
static FORCE_INLINE BOOLEAN	n_IsZero (number n, const coeffs r)
	TRUE iff 'n' represents the zero element. More...
static FORCE_INLINE BOOLEAN	n_IsOne (number n, const coeffs r)
	TRUE iff 'n' represents the one element. More...
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. More...
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 More...
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 long's representing More...
static FORCE_INLINE int	n_DivComp (number a, number b, const coeffs r)
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. More...
static FORCE_INLINE number	n_GetUnit (number n, const coeffs r)
	in Z: 1 in Z/kZ (where k is not a prime): largest divisor of n (taken in Z) that is co-prime with k in Z/2^kZ: largest odd divisor of n (taken in Z) other cases: not implemented More...
static FORCE_INLINE coeffs	n_CoeffRingQuot1 (number c, const coeffs r)
static FORCE_INLINE number	n_Init (long i, const coeffs r)
	a number representing i in the given coeff field/ring r More...
static FORCE_INLINE number	n_InitMPZ (mpz_t n, const coeffs r)
	conversion of a GMP integer to number More...
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 .. p/2] More...
static FORCE_INLINE void	n_MPZ (mpz_t result, number &n, const coeffs r)
	conversion of n to a GMP integer; 0 if not possible More...
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) More...
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 More...
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 for pivot strategies in matrix computations with entries from r) More...
static FORCE_INLINE void	n_Normalize (number &n, const coeffs r)
	inplace-normalization of n; produces some canonical representation of n; More...
static FORCE_INLINE void	n_WriteLong (number &n, const coeffs r)
	write to the output buffer of the currently used reporter More...
static FORCE_INLINE void	n_WriteShort (number &n, const coeffs r)
	write to the output buffer of the currently used reporter in a shortest possible way, e.g. in K(a): a2 instead of a^2 More...
static FORCE_INLINE void	n_Write (number &n, const coeffs r, const BOOLEAN bShortOut=TRUE)
static FORCE_INLINE const char *	n_Read (const char *s, number *a, const coeffs r)
	!!! Recommendation: This method is too cryptic to be part of the user- !!! interface. As defined here, it is merely a helper !!! method for parsing number input strings. More...
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) More...
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) More...
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 exception in Z: raises an error if 'a' is not divisible by 'b' More...
static FORCE_INLINE number	n_ExactDiv (number a, number b, const coeffs r)
	assume that there is a canonical subring in cf and we know that division is possible for these a and b in the subring, n_ExactDiv performs it, may skip additional tests. Can always be substituted by n_Div at the cost of larger computing time. More...
static FORCE_INLINE number	n_IntMod (number a, number b, const coeffs r)
	for r a field, return n_Init(0,r) otherwise: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a More...
static FORCE_INLINE void	n_Power (number a, int b, number *res, const coeffs r)
	fill res with the power a^b More...
static FORCE_INLINE number	n_Mult (number a, number b, const coeffs r)
	return the product of 'a' and 'b', i.e., a*b More...
static FORCE_INLINE void	n_InpMult (number &a, number b, const coeffs r)
	multiplication of 'a' and 'b'; replacement of 'a' by the product a*b More...
static FORCE_INLINE void	n_InpAdd (number &a, number b, const coeffs r)
	addition of 'a' and 'b'; replacement of 'a' by the sum a+b More...
static FORCE_INLINE number	n_Add (number a, number b, const coeffs r)
	return the sum of 'a' and 'b', i.e., a+b More...
static FORCE_INLINE number	n_Sub (number a, number b, const coeffs r)
	return the difference of 'a' and 'b', i.e., a-b More...
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, C, R: not implemented in Q: return the gcd of the numerators of 'a' and 'b' in K(a)/<p(a)>: not implemented in K(t_1, ..., t_n): not implemented More...
static FORCE_INLINE number	n_SubringGcd (number a, number b, const coeffs r)
static FORCE_INLINE number	n_ExtGcd (number a, number b, number *s, number *t, const coeffs r)
	beware that ExtGCD is only relevant for a few chosen coeff. domains and may perform something unexpected in some cases... More...
static FORCE_INLINE number	n_XExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
static FORCE_INLINE number	n_EucNorm (number a, const coeffs r)
static FORCE_INLINE number	n_Ann (number a, const coeffs r)
	if r is a ring with zero divisors, return an annihilator!=0 of b otherwise return NULL More...
static FORCE_INLINE number	n_QuotRem (number a, number b, number *q, const coeffs r)
static FORCE_INLINE number	n_Lcm (number a, number b, const coeffs r)
	in Z: return the lcm of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ, C, R: not implemented in K(a)/<p(a)>: not implemented in K(t_1, ..., t_n): not implemented More...
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,b2)/1) More...
static FORCE_INLINE nMapFunc	n_SetMap (const coeffs src, const coeffs dst)
	set the mapping function pointers for translating numbers from src to dst More...
static FORCE_INLINE BOOLEAN	n_DBTest (number n, const char *filename, const int linenumber, const coeffs r)
	test whether n is a correct number; only used if LDEBUG is defined More...
static FORCE_INLINE void	n_CoeffWrite (const coeffs r, BOOLEAN details=TRUE)
	output the coeff description More...
static FORCE_INLINE BOOLEAN	nCoeff_is_Ring_2toM (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_Ring_ModN (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_Ring_PtoM (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_Ring_Z (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_Ring (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_Domain (const coeffs r)
	returns TRUE, if r is a field or r has no zero divisors (i.e is a domain) More...
static FORCE_INLINE BOOLEAN	n_DivBy (number a, number b, const coeffs r)
	test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z: TRUE iff 'b' divides 'a' (with remainder = zero) in Z/nZ: TRUE iff (a = 0 and b divides n in Z) or (a != 0 and b/gcd(a, b) is co-prime with n, i.e. a unit in Z/nZ) in Z/2^kZ: TRUE iff ((a = 0 mod 2^k) and (b = 0 or b is a power of 2)) or ((a, b <> 0) and (b/gcd(a, b) is odd)) More...
static FORCE_INLINE number	n_ChineseRemainderSym (number *a, number *b, int rl, BOOLEAN sym, const coeffs r)
static FORCE_INLINE number	n_Farey (number a, number b, const coeffs r)
static FORCE_INLINE int	n_ParDeg (number n, const coeffs r)
static FORCE_INLINE int	n_NumberOfParameters (const coeffs r)
	Returns the number of parameters. More...
static FORCE_INLINE char const **	n_ParameterNames (const coeffs r)
	Returns a (const!) pointer to (const char*) names of parameters. More...
static FORCE_INLINE number	n_Param (const int iParameter, const coeffs r)
	return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1..n_NumberOfParameters(...) More...
static FORCE_INLINE number	n_RePart (number i, const coeffs cf)
static FORCE_INLINE number	n_ImPart (number i, const coeffs cf)
static FORCE_INLINE BOOLEAN	nCoeff_has_Units (const coeffs r)
	returns TRUE, if r is not a field and r has non-trivial units More...
static FORCE_INLINE BOOLEAN	nCoeff_is_Zp (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_Zp (const coeffs r, int p)
static FORCE_INLINE BOOLEAN	nCoeff_is_Q (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_numeric (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_R (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_GF (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_GF (const coeffs r, int q)
static FORCE_INLINE BOOLEAN	nCoeff_is_Extension (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_Zp_a (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_Zp_a (const coeffs r, int p)
static FORCE_INLINE BOOLEAN	nCoeff_is_Q_a (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_long_R (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_long_C (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_CF (const coeffs r)
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. More...
static FORCE_INLINE BOOLEAN	nCoeff_has_simple_Alloc (const coeffs r)
	TRUE if n_Delete/n_New are empty operations. More...
static FORCE_INLINE BOOLEAN	nCoeff_is_algExt (const coeffs r)
	TRUE iff r represents an algebraic extension field. More...
static FORCE_INLINE BOOLEAN	nCoeff_is_Q_algext (const coeffs r)
	is it an alg. ext. of Q? More...
static FORCE_INLINE BOOLEAN	nCoeff_is_transExt (const coeffs r)
	TRUE iff r represents a transcendental extension field. More...
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 (i.e. the GCD of all the coeffs, which we divide out inplace) NOTE: it assumes all coefficient numbers to be integer!!! NOTE/TODO: see also the description by Hans TODO: rename into n_ClearIntegerContent. More...
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 denominators (i.e. the number with which all the number coeffs. were multiplied) NOTE/TODO: see also the description by Hans More...
static FORCE_INLINE void	n_ClearContent (ICoeffsEnumerator &numberCollectionEnumerator, const coeffs r)
static FORCE_INLINE void	n_ClearDenominators (ICoeffsEnumerator &numberCollectionEnumerator, const coeffs r)
void	n_Print (number &a, const coeffs r)
	print a number (BEWARE of string buffers!) mostly for debugging More...
static FORCE_INLINE char *	nCoeffString (const coeffs cf)
	TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar. More...
static FORCE_INLINE char *	nCoeffName (const coeffs cf)
static FORCE_INLINE number	n_Random (siRandProc p, number p1, number p2, const coeffs cf)
static FORCE_INLINE void	n_WriteFd (number a, FILE *f, const coeffs r)
	io via ssi: More...
static FORCE_INLINE number	n_ReadFd (s_buff f, const coeffs r)
	io via ssi: More...
number	n_convFactoryNSingN (const CanonicalForm n, const coeffs r)
CanonicalForm	n_convSingNFactoryN (number n, BOOLEAN setChar, const coeffs r)
static FORCE_INLINE void	number2mpz (number n, coeffs c, mpz_t m)
static FORCE_INLINE number	mpz2number (mpz_t m, coeffs c)

Variables
unsigned short	fftable []
omBin	rnumber_bin

Detailed Description

Coefficient rings, fields and other domains suitable for Singular polynomials.

The main interface for Singular coefficients: coeffs is the main handler for Singular numbers

Definition in file coeffs.h.

---

Data Structure Documentation

struct GFInfo

Creation data needed for finite fields.

Definition at line 90 of file coeffs.h.

Data Fields
int	GFChar
int	GFDegree
const char *	GFPar_name

struct LongComplexInfo

Definition at line 97 of file coeffs.h.

Data Fields
short	float_len	additional char-flags, rInit
short	float_len2	additional char-flags, rInit
const char *	par_name	parameter name

Macro Definition Documentation

#define ALLOC0_RNUMBER

(

)

(number)omAlloc0Bin(rnumber_bin)

Definition at line 86 of file coeffs.h.

#define ALLOC_RNUMBER

(

)

(number)omAllocBin(rnumber_bin)

Definition at line 85 of file coeffs.h.

#define FREE_RNUMBER

(

x

)

omFreeBin((void *)x, rnumber_bin)

Definition at line 84 of file coeffs.h.

#define n_New	(		n,
			r
	)		nNew(n)

Definition at line 440 of file coeffs.h.

#define n_Test	(		a,
			r
	)		n_DBTest(a, __FILE__, __LINE__, r)

BOOLEAN n_Test(number a, const coeffs r)

Definition at line 918 of file coeffs.h.

Typedef Documentation

typedef IEnumerator<number> ICoeffsEnumerator

Abstract interface for an enumerator of number coefficients for an object, e.g. a polynomial.

Definition at line 76 of file coeffs.h.

typedef void(* nCoeffsEnumeratorFunc) (ICoeffsEnumerator &numberCollectionEnumerator, number &output, const coeffs r)

goes over coeffs given by the ICoeffsEnumerator and changes them. Additionally returns a number;

Definition at line 80 of file coeffs.h.

typedef number(* nMapFunc) (number a, const coeffs src, const coeffs dst)

maps "a", which lives in src, into dst

Definition at line 71 of file coeffs.h.

typedef number(* numberfunc) (number a, number b, const coeffs r)

Definition at line 68 of file coeffs.h.

Enumeration Type Documentation

enum n_coeffRep

Enumerator
n_rep_unknown
n_rep_int	(int), see modulop.h
n_rep_gap_rat	(number), see longrat.h
n_rep_gap_gmp	(), see rinteger.h, new impl.
n_rep_poly	(poly), see algext.h
n_rep_rat_fct	(fraction), see transext.h
n_rep_gmp	(mpz_ptr), see rmodulon,h
n_rep_float	(float), see shortfl.h
n_rep_gmp_float	(gmp_float), see
n_rep_gmp_complex	(gmp_complex), see gnumpc.h
n_rep_gf	(int), see ffields.h

Definition at line 105 of file coeffs.h.

{
  n_rep_unknown=0,
  n_rep_int,      /**< (int), see modulop.h */
  n_rep_gap_rat,  /**< (number), see longrat.h */
  n_rep_gap_gmp,  /**< (), see rinteger.h, new impl. */
  n_rep_poly,     /**< (poly), see algext.h */
  n_rep_rat_fct,  /**< (fraction), see transext.h */
  n_rep_gmp,      /**< (mpz_ptr), see rmodulon,h */
  n_rep_float,    /**< (float), see shortfl.h */
  n_rep_gmp_float,  /**< (gmp_float), see  */
  n_rep_gmp_complex,/**< (gmp_complex), see gnumpc.h */
  n_rep_gf        /**< (int), see ffields.h */
};

enum n_coeffType

Enumerator
n_unknown
n_Zp	{p < 2^31}
n_Q	rational (GMP) numbers
n_R	single prescision (6,6) real numbers
n_GF	{p^n < 2^16}
n_long_R	real floating point (GMP) numbers
n_algExt	used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
n_transExt	used for all transcendental extensions, i.e., the top-most extension in an extension tower is transcendental
n_long_C	complex floating point (GMP) numbers
n_Z	only used if HAVE_RINGS is defined: ?
n_Zn	only used if HAVE_RINGS is defined: ?
n_Znm	only used if HAVE_RINGS is defined: ?
n_Z2m	only used if HAVE_RINGS is defined: ?
n_CF	?

Definition at line 26 of file coeffs.h.

{
  n_unknown=0,
  n_Zp, /**< \F{p < 2^31} */
  n_Q,  /**< rational (GMP) numbers */
  n_R,  /**< single prescision (6,6) real numbers */
  n_GF, /**< \GF{p^n < 2^16} */
  n_long_R, /**< real floating point (GMP) numbers */
  n_algExt,  /**< used for all algebraic extensions, i.e.,
                the top-most extension in an extension tower
                is algebraic */
  n_transExt,  /**< used for all transcendental extensions, i.e.,
                  the top-most extension in an extension tower
                  is transcendental */
  n_long_C, /**< complex floating point (GMP) numbers */
  n_Z, /**< only used if HAVE_RINGS is defined: ? */
  n_Zn, /**< only used if HAVE_RINGS is defined: ? */
  n_Znm, /**< only used if HAVE_RINGS is defined: ? */
  n_Z2m, /**< only used if HAVE_RINGS is defined: ? */
  n_CF /**< ? */
};

Function Documentation

static FORCE_INLINE n_coeffType getCoeffType ( const coeffs  r )

static

Returns the type of coeffs domain.

Definition at line 421 of file coeffs.h.

{ assume(r != NULL); return r->type; }

static FORCE_INLINE number mpz2number ( mpz_t  m, coeffs  c  )

static

Definition at line 987 of file coeffs.h.

{ return n_InitMPZ(m, c); }

static FORCE_INLINE number n_Add ( number  a, number  b, const coeffs  r  )

static

return the sum of 'a' and 'b', i.e., a+b

Definition at line 653 of file coeffs.h.

{ STATISTIC(n_Add); assume(r != NULL); assume(r->cfAdd!=NULL); const number sum = r->cfAdd(a, b, r);

#ifdef HAVE_NUMSTATS
  // avoid double counting
  if( r->cfIsZero(sum,r) ) STATISTIC(n_CancelOut);
#endif

 return sum;
}

static FORCE_INLINE number n_Ann ( number  a, const coeffs  r  )

static

if r is a ring with zero divisors, return an annihilator!=0 of b otherwise return NULL

Definition at line 698 of file coeffs.h.

{ STATISTIC(n_Ann); assume(r != NULL); return r->cfAnn (a,r); }

static FORCE_INLINE number n_ChineseRemainderSym ( number *  a, number *  b, int  rl, BOOLEAN  sym, const coeffs  r  )

static

Definition at line 780 of file coeffs.h.

{ STATISTIC(n_ChineseRemainderSym); assume(r != NULL); assume(r->cfChineseRemainder != NULL); return r->cfChineseRemainder(a,b,rl,sym,r); }

static FORCE_INLINE void n_ClearContent ( ICoeffsEnumerator &  numberCollectionEnumerator, number &  c, const coeffs  r  )

static

Computes the content and (inplace) divides it out on a collection of numbers number c is the content (i.e. the GCD of all the coeffs, which we divide out inplace) NOTE: it assumes all coefficient numbers to be integer!!! NOTE/TODO: see also the description by Hans TODO: rename into n_ClearIntegerContent.

Definition at line 927 of file coeffs.h.

{ STATISTIC(n_ClearContent); assume(r != NULL); r->cfClearContent(numberCollectionEnumerator, c, r); }

static FORCE_INLINE void n_ClearContent ( ICoeffsEnumerator &  numberCollectionEnumerator, const coeffs  r  )

static

Definition at line 943 of file coeffs.h.

{ STATISTIC(n_ClearContent); number c; n_ClearContent(numberCollectionEnumerator, c, r); n_Delete(&c, r); }

static FORCE_INLINE void n_ClearDenominators ( ICoeffsEnumerator &  numberCollectionEnumerator, number &  d, const coeffs  r  )

static

(inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient denominators (i.e. the number with which all the number coeffs. were multiplied) NOTE/TODO: see also the description by Hans

Definition at line 934 of file coeffs.h.

{ STATISTIC(n_ClearDenominators); assume(r != NULL); r->cfClearDenominators(numberCollectionEnumerator, d, r); }

static FORCE_INLINE void n_ClearDenominators ( ICoeffsEnumerator &  numberCollectionEnumerator, const coeffs  r  )

static

Definition at line 946 of file coeffs.h.

{ STATISTIC(n_ClearDenominators); assume(r != NULL); number d; n_ClearDenominators(numberCollectionEnumerator, d, r); n_Delete(&d, r); }

static FORCE_INLINE coeffs n_CoeffRingQuot1 ( number  c, const coeffs  r  )

static

Definition at line 532 of file coeffs.h.

{ STATISTIC(n_CoeffRingQuot1); assume(r != NULL); assume(r->cfQuot1 != NULL); return r->cfQuot1(c, r); }

static FORCE_INLINE void n_CoeffWrite ( const coeffs  r, BOOLEAN  details = TRUE  )

static

output the coeff description

Definition at line 735 of file coeffs.h.

{ STATISTIC(n_CoeffWrite); assume(r != NULL); assume(r->cfCoeffWrite != NULL); r->cfCoeffWrite(r, details); }

number n_convFactoryNSingN	(	const CanonicalForm	n,
		const coeffs	r
	)

Definition at line 549 of file numbers.cc.

{ STATISTIC(n_convFactoryNSingN); assume(r != NULL); assume(r->convFactoryNSingN != NULL); return r->convFactoryNSingN(n, r); }

CanonicalForm n_convSingNFactoryN	(	number	n,
		BOOLEAN	setChar,
		const coeffs	r
	)

Definition at line 554 of file numbers.cc.

{ STATISTIC(n_convSingNFactoryN); assume(r != NULL); assume(r->convSingNFactoryN != NULL); return r->convSingNFactoryN(n, setChar, r); }

static FORCE_INLINE number n_Copy ( number  n, const coeffs  r  )

static

return a copy of 'n'

Definition at line 451 of file coeffs.h.

{ STATISTIC(n_Copy);   assume(r != NULL); assume(r->cfCopy!=NULL); return r->cfCopy(n, r); }

static FORCE_INLINE BOOLEAN n_DBTest ( number  n, const char *  filename, const int  linenumber, const coeffs  r  )

static

test whether n is a correct number; only used if LDEBUG is defined

Definition at line 724 of file coeffs.h.

{ STATISTIC(n_Test); assume(r != NULL); assume(r->cfDBTest != NULL); return r->cfDBTest(n, filename, linenumber, r); }

static FORCE_INLINE void n_Delete ( number *  p, const coeffs  r  )

static

delete 'p'

Definition at line 455 of file coeffs.h.

{ STATISTIC(n_Delete);   assume(r != NULL); assume(r->cfDelete!= NULL); r->cfDelete(p, r); }

static FORCE_INLINE number n_Div ( number  a, number  b, const coeffs  r  )

static

return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exception in Z: raises an error if 'a' is not divisible by 'b'

Definition at line 613 of file coeffs.h.

{ STATISTIC(n_Div); assume(r != NULL); assume(r->cfDiv!=NULL); return r->cfDiv(a,b,r); }

static FORCE_INLINE BOOLEAN n_DivBy ( number  a, number  b, const coeffs  r  )

static

test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z: TRUE iff 'b' divides 'a' (with remainder = zero) in Z/nZ: TRUE iff (a = 0 and b divides n in Z) or (a != 0 and b/gcd(a, b) is co-prime with n, i.e. a unit in Z/nZ) in Z/2^kZ: TRUE iff ((a = 0 mod 2^k) and (b = 0 or b is a power of 2)) or ((a, b <> 0) and (b/gcd(a, b) is odd))

Definition at line 769 of file coeffs.h.

{ STATISTIC(n_DivBy); assume(r != NULL);
#ifdef HAVE_RINGS
  if( nCoeff_is_Ring(r) )
  {
    assume(r->cfDivBy!=NULL); return r->cfDivBy(a,b,r);
  }
#endif
  return !n_IsZero(b, r);
}

static FORCE_INLINE int n_DivComp ( number  a, number  b, const coeffs  r  )

static

Definition at line 515 of file coeffs.h.

{ STATISTIC(n_DivComp); assume(r != NULL); assume(r->cfDivComp!=NULL); return r->cfDivComp (a,b,r); }

static FORCE_INLINE BOOLEAN n_Equal ( number  a, number  b, const coeffs  r  )

static

TRUE iff 'a' and 'b' represent the same number; they may have different representations.

Definition at line 460 of file coeffs.h.

{ STATISTIC(n_Equal); assume(r != NULL); assume(r->cfEqual!=NULL); return r->cfEqual(a, b, r); }

static FORCE_INLINE number n_EucNorm ( number  a, const coeffs  r  )

static

Definition at line 694 of file coeffs.h.

{ STATISTIC(n_EucNorm); assume(r != NULL); assume(r->cfEucNorm!=NULL); return r->cfEucNorm (a,r); }

static FORCE_INLINE number n_ExactDiv ( number  a, number  b, const coeffs  r  )

static

assume that there is a canonical subring in cf and we know that division is possible for these a and b in the subring, n_ExactDiv performs it, may skip additional tests. Can always be substituted by n_Div at the cost of larger computing time.

Definition at line 620 of file coeffs.h.

{ STATISTIC(n_ExactDiv); assume(r != NULL); assume(r->cfExactDiv!=NULL); return r->cfExactDiv(a,b,r); }

static FORCE_INLINE number n_ExtGcd ( number  a, number  b, number *  s, number *  t, const coeffs  r  )

static

beware that ExtGCD is only relevant for a few chosen coeff. domains and may perform something unexpected in some cases...

Definition at line 690 of file coeffs.h.

{ STATISTIC(n_ExtGcd); assume(r != NULL); assume(r->cfExtGcd!=NULL); return r->cfExtGcd (a,b,s,t,r); }

static FORCE_INLINE number n_Farey ( number  a, number  b, const coeffs  r  )

static

Definition at line 783 of file coeffs.h.

{ STATISTIC(n_Farey); assume(r != NULL); assume(r->cfFarey != NULL); return r->cfFarey(a,b,r); }

static FORCE_INLINE number n_Gcd ( number  a, number  b, const coeffs  r  )

static

in Z: return the gcd of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ, C, R: not implemented in Q: return the gcd of the numerators of 'a' and 'b' in K(a)/<p(a)>: not implemented in K(t_1, ..., t_n): not implemented

Definition at line 683 of file coeffs.h.

{ STATISTIC(n_Gcd); assume(r != NULL); assume(r->cfGcd!=NULL); return r->cfGcd(a,b,r); }

static FORCE_INLINE int n_GetChar ( const coeffs  r )

static

Return the characteristic of the coeff. domain.

Definition at line 444 of file coeffs.h.

{ STATISTIC(n_GetChar); assume(r != NULL); return r->ch; }

static FORCE_INLINE number n_GetDenom ( number &  n, const coeffs  r  )

static

return the denominator of n (if elements of r are by nature not fractional, result is 1)

Definition at line 602 of file coeffs.h.

{ STATISTIC(n_GetDenom); assume(r != NULL); assume(r->cfGetDenom!=NULL); return r->cfGetDenom(n, r); }

static FORCE_INLINE number n_GetNumerator ( number &  n, const coeffs  r  )

static

return the numerator of n (if elements of r are by nature not fractional, result is n)

Definition at line 607 of file coeffs.h.

{ STATISTIC(n_GetNumerator); assume(r != NULL); assume(r->cfGetNumerator!=NULL); return r->cfGetNumerator(n, r); }

static FORCE_INLINE number n_GetUnit ( number  n, const coeffs  r  )

static

in Z: 1 in Z/kZ (where k is not a prime): largest divisor of n (taken in Z) that is co-prime with k in Z/2^kZ: largest odd divisor of n (taken in Z) other cases: not implemented

Definition at line 529 of file coeffs.h.

{ STATISTIC(n_GetUnit); assume(r != NULL); assume(r->cfGetUnit!=NULL); return r->cfGetUnit(n,r); }

static FORCE_INLINE BOOLEAN n_Greater ( number  a, number  b, const coeffs  r  )

static

ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the long's representing

in C: TRUE iff (Im(a) > Im(b)) in K(a)/<p(a)>: TRUE iff (a != 0 and (b == 0 or deg(a) > deg(b)) in K(t_1, ..., t_n): TRUE only if one or both numerator polynomials are zero or if their degrees are equal. In this case, TRUE if LC(numerator(a)) > LC(numerator(b)) in Z/2^kZ: TRUE if n_DivBy(a, b) in Z/mZ: TRUE iff the internal mpz's fulfill the relation '>' in Z: TRUE iff a > b

!!! Recommendation: remove implementations for unordered fields !!! and raise errors instead, in these cases

Definition at line 511 of file coeffs.h.

{ STATISTIC(n_Greater); assume(r != NULL); assume(r->cfGreater!=NULL); return r->cfGreater(a,b,r); }

static FORCE_INLINE BOOLEAN n_GreaterZero ( number  n, const coeffs  r  )

static

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

!!! Recommendation: remove implementations for unordered fields !!! and raise errors instead, in these cases !!! Do not follow this recommendation: while writing polys, !!! between 2 monomials will be an additional + iff !n_GreaterZero(next coeff) Then change definition to include n_GreaterZero => printing does NOT start with -

Definition at line 494 of file coeffs.h.

{ STATISTIC(n_GreaterZero); assume(r != NULL); assume(r->cfGreaterZero!=NULL); return r->cfGreaterZero(n,r); }

static FORCE_INLINE number n_ImPart ( number  i, const coeffs  cf  )

static

Definition at line 809 of file coeffs.h.

{ STATISTIC(n_ImPart); assume(cf != NULL); assume(cf->cfImPart!=NULL); return cf->cfImPart(i,cf); }

static FORCE_INLINE number n_Init ( long  i, const coeffs  r  )

static

a number representing i in the given coeff field/ring r

Definition at line 537 of file coeffs.h.

{ STATISTIC(n_Init); assume(r != NULL); assume(r->cfInit!=NULL); return r->cfInit(i,r); }

static FORCE_INLINE number n_InitMPZ ( mpz_t  n, const coeffs  r  )

static

conversion of a GMP integer to number

Definition at line 541 of file coeffs.h.

{ STATISTIC(n_InitMPZ); assume(r != NULL); assume(r->cfInitMPZ != NULL); return r->cfInitMPZ(n,r); }

static FORCE_INLINE void n_InpAdd ( number &  a, number  b, const coeffs  r  )

static

addition of 'a' and 'b'; replacement of 'a' by the sum a+b

Definition at line 643 of file coeffs.h.

{ STATISTIC(n_InpAdd); assume(r != NULL); assume(r->cfInpAdd!=NULL); r->cfInpAdd(a,b,r);

#ifdef HAVE_NUMSTATS
  // avoid double counting
  if( r->cfIsZero(a,r) ) STATISTIC(n_CancelOut);
#endif
}

static FORCE_INLINE void n_InpMult ( number &  a, number  b, const coeffs  r  )

static

multiplication of 'a' and 'b'; replacement of 'a' by the product a*b

Definition at line 638 of file coeffs.h.

{ STATISTIC(n_InpMult); assume(r != NULL); assume(r->cfInpMult!=NULL); r->cfInpMult(a,b,r); }

static FORCE_INLINE number n_InpNeg ( number  n, const coeffs  r  )

static

in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)

Definition at line 556 of file coeffs.h.

{ STATISTIC(n_InpNeg); assume(r != NULL); assume(r->cfInpNeg!=NULL); return r->cfInpNeg(n,r); }

static FORCE_INLINE long n_Int ( number &  n, const coeffs  r  )

static

conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 .. p/2]

Definition at line 546 of file coeffs.h.

{ STATISTIC(n_Int); assume(r != NULL); assume(r->cfInt!=NULL); return r->cfInt(n,r); }

static FORCE_INLINE number n_IntMod ( number  a, number  b, const coeffs  r  )

static

for r a field, return n_Init(0,r) otherwise: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a

Definition at line 625 of file coeffs.h.

{ STATISTIC(n_IntMod); assume(r != NULL); return r->cfIntMod(a,b,r); }

static FORCE_INLINE number n_Invers ( number  a, const coeffs  r  )

static

return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible

!!! Recommendation: rename to 'n_Inverse'

Definition at line 563 of file coeffs.h.

{ STATISTIC(n_Invers); assume(r != NULL); assume(r->cfInvers!=NULL); return r->cfInvers(a,r); }

static FORCE_INLINE BOOLEAN n_IsMOne ( number  n, const coeffs  r  )

static

TRUE iff 'n' represents the additive inverse of the one element, i.e. -1.

Definition at line 472 of file coeffs.h.

{ STATISTIC(n_IsMOne); assume(r != NULL); assume(r->cfIsMOne!=NULL); return r->cfIsMOne(n,r); }

static FORCE_INLINE BOOLEAN n_IsOne ( number  n, const coeffs  r  )

static

TRUE iff 'n' represents the one element.

Definition at line 468 of file coeffs.h.

{ STATISTIC(n_IsOne); assume(r != NULL); assume(r->cfIsOne!=NULL); return r->cfIsOne(n,r); }

static FORCE_INLINE BOOLEAN n_IsUnit ( number  n, const coeffs  r  )

static

TRUE iff n has a multiplicative inverse in the given coeff field/ring r.

Definition at line 519 of file coeffs.h.

{ STATISTIC(n_IsUnit); assume(r != NULL); assume(r->cfIsUnit!=NULL); return r->cfIsUnit(n,r); }

static FORCE_INLINE BOOLEAN n_IsZero ( number  n, const coeffs  r  )

static

TRUE iff 'n' represents the zero element.

Definition at line 464 of file coeffs.h.

{ STATISTIC(n_IsZero); assume(r != NULL); assume(r->cfIsZero!=NULL); return r->cfIsZero(n,r); }

static FORCE_INLINE number n_Lcm ( number  a, number  b, const coeffs  r  )

static

in Z: return the lcm of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ, C, R: not implemented in K(a)/<p(a)>: not implemented in K(t_1, ..., t_n): not implemented

Definition at line 709 of file coeffs.h.

{ STATISTIC(n_Lcm); assume(r != NULL); assume(r->cfLcm!=NULL); return r->cfLcm(a,b,r); }

static FORCE_INLINE void n_MPZ ( mpz_t  result, number &  n, const coeffs  r  )

static

conversion of n to a GMP integer; 0 if not possible

Definition at line 550 of file coeffs.h.

{ STATISTIC(n_MPZ); assume(r != NULL); assume(r->cfMPZ!=NULL); r->cfMPZ(result, n, r); }

static FORCE_INLINE number n_Mult ( number  a, number  b, const coeffs  r  )

static

return the product of 'a' and 'b', i.e., a*b

Definition at line 633 of file coeffs.h.

{ STATISTIC(n_Mult); assume(r != NULL); assume(r->cfMult!=NULL); return r->cfMult(a, b, r); }

static FORCE_INLINE void n_Normalize ( number &  n, const coeffs  r  )

static

inplace-normalization of n; produces some canonical representation of n;

!!! Recommendation: remove this method from the user-interface, i.e., !!! this should be hidden

Definition at line 577 of file coeffs.h.

{ STATISTIC(n_Normalize); assume(r != NULL); assume(r->cfNormalize!=NULL); r->cfNormalize(n,r); }

static FORCE_INLINE number n_NormalizeHelper ( number  a, number  b, const coeffs  r  )

static

assume that r is a quotient field (otherwise, return 1) for arguments (a1/a2,b1/b2) return (lcm(a1,b2)/1)

Definition at line 714 of file coeffs.h.

{ STATISTIC(n_NormalizeHelper); assume(r != NULL); assume(r->cfNormalizeHelper!=NULL); return r->cfNormalizeHelper(a,b,r); }

static FORCE_INLINE int n_NumberOfParameters ( const coeffs  r )

static

Returns the number of parameters.

Definition at line 790 of file coeffs.h.

{ STATISTIC(n_NumberOfParameters); assume(r != NULL); return r->iNumberOfParameters; }

static FORCE_INLINE number n_Param ( const int  iParameter, const coeffs  r  )

static

return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1..n_NumberOfParameters(...)

Definition at line 799 of file coeffs.h.

{ assume(r != NULL);
  assume((iParameter >= 1) || (iParameter <= n_NumberOfParameters(r)));
  assume(r->cfParameter != NULL);
  STATISTIC(n_Param); return r->cfParameter(iParameter, r);
}

static FORCE_INLINE char const* * n_ParameterNames ( const coeffs  r )

static

Returns a (const!) pointer to (const char*) names of parameters.

Definition at line 794 of file coeffs.h.

{ STATISTIC(n_ParameterNames); assume(r != NULL); return r->pParameterNames; }

static FORCE_INLINE int n_ParDeg ( number  n, const coeffs  r  )

static

Definition at line 786 of file coeffs.h.

{ STATISTIC(n_ParDeg); assume(r != NULL); assume(r->cfParDeg != NULL); return r->cfParDeg(n,r); }

static FORCE_INLINE void n_Power ( number  a, int  b, number *  res, const coeffs  r  )

static

fill res with the power a^b

Definition at line 629 of file coeffs.h.

{ STATISTIC(n_Power); assume(r != NULL); assume(r->cfPower!=NULL); r->cfPower(a,b,res,r); }

void n_Print	(	number &	a,
		const coeffs	r
	)

print a number (BEWARE of string buffers!) mostly for debugging

Definition at line 538 of file numbers.cc.

{
   assume(r != NULL);
   n_Test(a,r);

   StringSetS("");
   n_Write(a, r);
   { char* s = StringEndS(); Print("%s", s); omFree(s); }

static FORCE_INLINE number n_QuotRem ( number  a, number  b, number *  q, const coeffs  r  )

static

Definition at line 700 of file coeffs.h.

{ STATISTIC(n_QuotRem); assume(r != NULL); assume(r->cfQuotRem!=NULL); return r->cfQuotRem (a,b,q,r); }

static FORCE_INLINE number n_Random ( siRandProc  p, number  p1, number  p2, const coeffs  cf  )

static

Definition at line 965 of file coeffs.h.

{ STATISTIC(n_Random); assume( cf != NULL ); assume( cf->cfRandom != NULL );  return cf->cfRandom(p, p1, p2, cf); }

static FORCE_INLINE const char* n_Read ( const char *  s, number *  a, const coeffs  r  )

static

!!! Recommendation: This method is too cryptic to be part of the user- !!! interface. As defined here, it is merely a helper !!! method for parsing number input strings.

Definition at line 597 of file coeffs.h.

{ STATISTIC(n_Read); assume(r != NULL); assume(r->cfRead!=NULL); return r->cfRead(s, a, r); }

static FORCE_INLINE number n_ReadFd ( s_buff  f, const coeffs  r  )

static

io via ssi:

Definition at line 973 of file coeffs.h.

{ STATISTIC(n_ReadFd); assume(r != NULL); assume(r->cfReadFd != NULL); return r->cfReadFd(f, r); }

static FORCE_INLINE number n_RePart ( number  i, const coeffs  cf  )

static

Definition at line 806 of file coeffs.h.

{ STATISTIC(n_RePart); assume(cf != NULL); assume(cf->cfRePart!=NULL); return cf->cfRePart(i,cf); }

static FORCE_INLINE nMapFunc n_SetMap ( const coeffs  src, const coeffs  dst  )

static

set the mapping function pointers for translating numbers from src to dst

Definition at line 718 of file coeffs.h.

{ STATISTIC(n_SetMap); assume(src != NULL && dst != NULL); assume(dst->cfSetMap!=NULL); return dst->cfSetMap(src,dst); }

static FORCE_INLINE int n_Size ( number  n, const coeffs  r  )

static

return a non-negative measure for the complexity of n; return 0 only when n represents zero; (used for pivot strategies in matrix computations with entries from r)

Definition at line 569 of file coeffs.h.

{ STATISTIC(n_Size); assume(r != NULL); assume(r->cfSize!=NULL); return r->cfSize(n,r); }

static FORCE_INLINE number n_Sub ( number  a, number  b, const coeffs  r  )

static

return the difference of 'a' and 'b', i.e., a-b

Definition at line 666 of file coeffs.h.

{ STATISTIC(n_Sub); assume(r != NULL); assume(r->cfSub!=NULL); const number d = r->cfSub(a, b, r);

#ifdef HAVE_NUMSTATS
  // avoid double counting
  if( r->cfIsZero(d,r) ) STATISTIC(n_CancelOut);
#endif

  return d;
}

static FORCE_INLINE number n_SubringGcd ( number  a, number  b, const coeffs  r  )

static

Definition at line 685 of file coeffs.h.

{ STATISTIC(n_SubringGcd); assume(r != NULL); assume(r->cfSubringGcd!=NULL); return r->cfSubringGcd(a,b,r); }

static FORCE_INLINE void n_Write ( number &  n, const coeffs  r, const BOOLEAN  bShortOut = TRUE  )

static

Definition at line 590 of file coeffs.h.

{ STATISTIC(n_Write); if (bShortOut) n_WriteShort(n, r); else n_WriteLong(n, r); }

static FORCE_INLINE void n_WriteFd ( number  a, FILE *  f, const coeffs  r  )

static

io via ssi:

Definition at line 969 of file coeffs.h.

{ STATISTIC(n_WriteFd); assume(r != NULL); assume(r->cfWriteFd != NULL); return r->cfWriteFd(a, f, r); }

static FORCE_INLINE void n_WriteLong ( number &  n, const coeffs  r  )

static

write to the output buffer of the currently used reporter

Definition at line 582 of file coeffs.h.

{ STATISTIC(n_WriteLong); assume(r != NULL); assume(r->cfWriteLong!=NULL); r->cfWriteLong(n,r); }

static FORCE_INLINE void n_WriteShort ( number &  n, const coeffs  r  )

static

write to the output buffer of the currently used reporter in a shortest possible way, e.g. in K(a): a2 instead of a^2

Definition at line 587 of file coeffs.h.

{ STATISTIC(n_WriteShort); assume(r != NULL); assume(r->cfWriteShort!=NULL); r->cfWriteShort(n,r); }

static FORCE_INLINE number n_XExtGcd ( number  a, number  b, number *  s, number *  t, number *  u, number *  v, const coeffs  r  )

static

Definition at line 692 of file coeffs.h.

{ STATISTIC(n_XExtGcd); assume(r != NULL); assume(r->cfXExtGcd!=NULL); return r->cfXExtGcd (a,b,s,t,u,v,r); }

static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc ( const coeffs  r )

static

TRUE if n_Delete/n_New are empty operations.

Definition at line 902 of file coeffs.h.

{ assume(r != NULL); return r->has_simple_Alloc; }

static FORCE_INLINE BOOLEAN nCoeff_has_simple_inverse ( const coeffs  r )

static

TRUE, if the computation of the inverse is fast, i.e. prefer leading coeff. 1 over content.

Definition at line 898 of file coeffs.h.

{ assume(r != NULL); return r->has_simple_Inverse; }

static FORCE_INLINE BOOLEAN nCoeff_has_Units ( const coeffs  r )

static

returns TRUE, if r is not a field and r has non-trivial units

Definition at line 813 of file coeffs.h.

{ assume(r != NULL); return ((getCoeffType(r)==n_Zn) || (getCoeffType(r)==n_Z2m) || (getCoeffType(r)==n_Znm)); }

static FORCE_INLINE BOOLEAN nCoeff_is_algExt ( const coeffs  r )

static

TRUE iff r represents an algebraic extension field.

Definition at line 906 of file coeffs.h.

{ assume(r != NULL); return (getCoeffType(r)==n_algExt); }

static FORCE_INLINE BOOLEAN nCoeff_is_CF ( const coeffs  r )

static

Definition at line 893 of file coeffs.h.

{ assume(r != NULL); return getCoeffType(r)==n_CF; }

static FORCE_INLINE BOOLEAN nCoeff_is_Domain ( const coeffs  r )

static

returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)

Definition at line 755 of file coeffs.h.

{
  assume(r != NULL);
  return (r->is_domain);
}

static FORCE_INLINE BOOLEAN nCoeff_is_Extension ( const coeffs  r )

static

Definition at line 839 of file coeffs.h.

{
  assume(r != NULL);
  return (getCoeffType(r)==n_algExt) || (getCoeffType(r)==n_transExt);
}

static FORCE_INLINE BOOLEAN nCoeff_is_GF ( const coeffs  r )

static

Definition at line 832 of file coeffs.h.

{ assume(r != NULL); return getCoeffType(r)==n_GF; }

static FORCE_INLINE BOOLEAN nCoeff_is_GF ( const coeffs  r, int  q  )

static

Definition at line 835 of file coeffs.h.

{ assume(r != NULL); return (getCoeffType(r)==n_GF) && (r->ch == q); }

static FORCE_INLINE BOOLEAN nCoeff_is_long_C ( const coeffs  r )

static

Definition at line 890 of file coeffs.h.

{ assume(r != NULL); return getCoeffType(r)==n_long_C; }

static FORCE_INLINE BOOLEAN nCoeff_is_long_R ( const coeffs  r )

static

Definition at line 887 of file coeffs.h.

{ assume(r != NULL); return getCoeffType(r)==n_long_R; }

static FORCE_INLINE BOOLEAN nCoeff_is_numeric ( const coeffs  r )

static

Definition at line 825 of file coeffs.h.

{ assume(r != NULL);  return (getCoeffType(r)==n_R) || (getCoeffType(r)==n_long_R) || (getCoeffType(r)==n_long_C); }

static FORCE_INLINE BOOLEAN nCoeff_is_Q ( const coeffs  r )

static

Definition at line 822 of file coeffs.h.

{ assume(r != NULL); return getCoeffType(r)==n_Q && (r->is_field); }

static FORCE_INLINE BOOLEAN nCoeff_is_Q_a ( const coeffs  r )

static

Definition at line 878 of file coeffs.h.

{
  assume(r != NULL);
  return ((n_GetChar(r) == 0) && nCoeff_is_Extension(r));
}

static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext ( const coeffs  r )

static

is it an alg. ext. of Q?

Definition at line 910 of file coeffs.h.

{ assume(r != NULL); return ((n_GetChar(r) == 0) && nCoeff_is_algExt(r)); }

static FORCE_INLINE BOOLEAN nCoeff_is_R ( const coeffs  r )

static

Definition at line 829 of file coeffs.h.

{ assume(r != NULL); return getCoeffType(r)==n_R; }

static FORCE_INLINE BOOLEAN nCoeff_is_Ring ( const coeffs  r )

static

Definition at line 751 of file coeffs.h.

{ assume(r != NULL); return (r->is_field==0); }

static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM ( const coeffs  r )

static

Definition at line 739 of file coeffs.h.

{ assume(r != NULL); return (getCoeffType(r)==n_Z2m); }

static FORCE_INLINE BOOLEAN nCoeff_is_Ring_ModN ( const coeffs  r )

static

Definition at line 742 of file coeffs.h.

{ assume(r != NULL); return (getCoeffType(r)==n_Zn); }

static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM ( const coeffs  r )

static

Definition at line 745 of file coeffs.h.

{ assume(r != NULL); return (getCoeffType(r)==n_Znm); }

static FORCE_INLINE BOOLEAN nCoeff_is_Ring_Z ( const coeffs  r )

static

Definition at line 748 of file coeffs.h.

{ assume(r != NULL); return (getCoeffType(r)==n_Z); }

static FORCE_INLINE BOOLEAN nCoeff_is_transExt ( const coeffs  r )

static

TRUE iff r represents a transcendental extension field.

Definition at line 914 of file coeffs.h.

{ assume(r != NULL); return (getCoeffType(r)==n_transExt); }

static FORCE_INLINE BOOLEAN nCoeff_is_Zp ( const coeffs  r )

static

Definition at line 816 of file coeffs.h.

{ assume(r != NULL); return getCoeffType(r)==n_Zp; }

static FORCE_INLINE BOOLEAN nCoeff_is_Zp ( const coeffs  r, int  p  )

static

Definition at line 819 of file coeffs.h.

{ assume(r != NULL); return ((getCoeffType(r)==n_Zp) && (r->ch == p)); }

static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a ( const coeffs  r )

static

Definition at line 852 of file coeffs.h.

{
  assume(r != NULL);
  return ((!nCoeff_is_Ring(r)) && (n_GetChar(r) != 0) && nCoeff_is_Extension(r));
}

static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a ( const coeffs  r, int  p  )

static

Definition at line 865 of file coeffs.h.

{
  assume(r != NULL);
  assume(p != 0);
  return ((!nCoeff_is_Ring(r)) && (n_GetChar(r) == p) && nCoeff_is_Extension(r));
}

static FORCE_INLINE char* nCoeffName ( const coeffs  cf )

static

Definition at line 962 of file coeffs.h.

{ STATISTIC(nCoeffName); assume( cf != NULL ); return cf->cfCoeffName(cf); }

static FORCE_INLINE char* nCoeffString ( const coeffs  cf )

static

TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.

Definition at line 958 of file coeffs.h.

{ STATISTIC(nCoeffString); assume( cf != NULL ); return cf->cfCoeffString(cf); }

static FORCE_INLINE coeffs nCopyCoeff ( const coeffs  r )

static

"copy" coeffs, i.e. increment ref

Definition at line 429 of file coeffs.h.

{ assume(r!=NULL); r->ref++; return r;}

coeffs nInitChar	(	n_coeffType	t,
		void *	parameter
	)

one-time initialisations for new coeffs in case of an error return NULL

Definition at line 316 of file numbers.cc.

{
  n_Procs_s *n=cf_root;

  while((n!=NULL) && (n->nCoeffIsEqual!=NULL) && (!n->nCoeffIsEqual(n,t,parameter)))
      n=n->next;

  if (n==NULL)
  {
    n=(n_Procs_s*)omAlloc0(sizeof(n_Procs_s));
    n->next=cf_root;
    n->ref=1;
    n->type=t;

    // default entries (different from NULL) for some routines:
    n->nCoeffIsEqual = ndCoeffIsEqual;
    n->cfSize = ndSize;
    n->cfGetDenom= ndGetDenom;
    n->cfGetNumerator= ndGetNumerator;
    n->cfImPart=ndReturn0;
    n->cfDelete= ndDelete;
    n->cfAnn = ndAnn;
    n->cfCoeffString = ndCoeffString; // should alway be changed!
    n->cfInpMult=ndInpMult;
    n->cfInpAdd=ndInpAdd;
    n->cfCopy = ndCopy;
    n->cfIntMod=ndIntMod; /* dummy !! */
    n->cfNormalize=ndNormalize;
    n->cfGcd  = ndGcd;
    n->cfNormalizeHelper  = ndGcd; /* tricky, isn't it ?*/
    n->cfLcm  = ndGcd; /* tricky, isn't it ?*/
    n->cfInitMPZ = ndInitMPZ;
    n->cfMPZ = ndMPZ;
    n->cfPower = ndPower;
    n->cfCoeffName = ndCoeffName;

    n->cfKillChar = ndKillChar; /* dummy */
    n->cfSetChar = ndSetChar; /* dummy */
    // temp. removed to catch all the coeffs which miss to implement this!

    n->cfChineseRemainder = ndChineseRemainder;
    n->cfFarey = ndFarey;
    n->cfParDeg = ndParDeg;

    n->cfParameter = ndParameter;

    n->cfClearContent = ndClearContent;
    n->cfClearDenominators = ndClearDenominators;

#ifdef HAVE_RINGS
    n->cfDivComp = ndDivComp;
    n->cfDivBy = ndDivBy;
    n->cfIsUnit = ndIsUnit;
    n->cfExtGcd = ndExtGcd;
    //n->cfGetUnit = (nMapFunc)NULL;
#endif

#ifdef LDEBUG
    n->cfDBTest=ndDBTest;
#endif

    n->convSingNFactoryN=ndConvSingNFactoryN;
    n->convFactoryNSingN=ndConvFactoryNSingN;

    BOOLEAN nOK=TRUE;
    // init
    if ((t<=nLastCoeffs) && (nInitCharTable[t]!=NULL))
      nOK = (nInitCharTable[t])(n,parameter);
    else
       Werror("Sorry: the coeff type [%d] was not registered: it is missing in nInitCharTable", (int)t);
    if (nOK)
    {
      omFreeSize(n,sizeof(*n));
      return NULL;
    }
    cf_root=n;
    // post init settings:
    if (n->cfRePart==NULL) n->cfRePart=n->cfCopy;
    if (n->cfExactDiv==NULL) n->cfExactDiv=n->cfDiv;
    if (n->cfSubringGcd==NULL) n->cfSubringGcd=n->cfGcd;

#ifdef HAVE_RINGS
    if (n->cfGetUnit==NULL) n->cfGetUnit=n->cfCopy;
#endif

    if(n->cfWriteShort==NULL)
      n->cfWriteShort = n->cfWriteLong;

    assume(n->nCoeffIsEqual!=NULL);
    assume(n->cfSetChar!=NULL);
    assume(n->cfCoeffString!=ndCoeffString);
    assume(n->cfMult!=NULL);
    assume(n->cfSub!=NULL);
    assume(n->cfAdd!=NULL);
    assume(n->cfDiv!=NULL);
    assume(n->cfIntMod!=NULL);
    assume(n->cfExactDiv!=NULL);
    assume(n->cfInit!=NULL);
    assume(n->cfInitMPZ!=NULL);
    assume(n->cfSize!=NULL);
    assume(n->cfInt!=NULL);
    assume(n->cfMPZ!=NULL);
    //assume(n->n->cfDivComp!=NULL);
    //assume(n->cfIsUnit!=NULL);
    //assume(n->cfGetUnit!=NULL);
    //assume(n->cfExtGcd!=NULL);
    assume(n->cfInpNeg!=NULL);
    assume(n->cfCopy!=NULL);

    assume(n->cfWriteLong!=NULL);
    assume(n->cfWriteShort!=NULL);

    assume(n->iNumberOfParameters>= 0);

    assume( (n->iNumberOfParameters == 0 && n->pParameterNames == NULL) ||
            (n->iNumberOfParameters >  0 && n->pParameterNames != NULL) );

    assume(n->cfParameter!=NULL);
    assume(n->cfParDeg!=NULL);

    assume(n->cfRead!=NULL);
    assume(n->cfNormalize!=NULL);
    assume(n->cfGreater!=NULL);
    //assume(n->cfDivBy!=NULL);
    assume(n->cfEqual!=NULL);
    assume(n->cfIsZero!=NULL);
    assume(n->cfIsOne!=NULL);
    assume(n->cfIsMOne!=NULL);
    assume(n->cfGreaterZero!=NULL);
    assume(n->cfGetDenom!=NULL);
    assume(n->cfGetNumerator!=NULL);
    assume(n->cfGcd!=NULL);
    assume(n->cfNormalizeHelper!=NULL);
    assume(n->cfDelete!=NULL);
    assume(n->cfSetMap!=NULL);
    assume(n->cfInpMult!=NULL);
//    assume(n->cfInit_bigint!=NULL);
    assume(n->cfCoeffWrite != NULL);

    assume(n->cfClearContent != NULL);
    assume(n->cfClearDenominators != NULL);

    assume(n->type==t);

#ifndef SING_NDEBUG
    if(n->cfKillChar==NULL) Warn("cfKillChar is NULL for coeff %d",t);
    if(n->cfWriteLong==NULL) Warn("cfWrite is NULL for coeff %d",t);
    if(n->cfWriteShort==NULL) Warn("cfWriteShort is NULL for coeff %d",t);
    if(n->cfCoeffString==ndCoeffString) Warn("cfCoeffString is undefined for coeff %d",t);
#endif

   if( n->nNULL == NULL )
     n->nNULL = n->cfInit(0, n); // may still remain NULL
  }
  else
  {
    n->ref++;
  }
  return n;

void nKillChar

(

coeffs

r

)

undo all initialisations

Definition at line 477 of file numbers.cc.

{
  STATISTIC(nKillChar);
  if (r!=NULL)
  {
    r->ref--;
    if (r->ref<=0)
    {
      n_Procs_s tmp;
      n_Procs_s* n=&tmp;
      tmp.next=cf_root;
      while((n->next!=NULL) && (n->next!=r)) n=n->next;
      if (n->next==r)
      {
        n->next=n->next->next;
        if (cf_root==r) cf_root=n->next;
        n_Delete(&(r->nNULL),r);
        assume (r->cfKillChar!=NULL); r->cfKillChar(r); // STATISTIC(nKillChar);
        omFreeSize((void *)r, sizeof(n_Procs_s));
        r=NULL;
      }
      else
      {
        WarnS("cf_root list destroyed");
      }
    }
  }

void nNew

(

number *

a

)

Definition at line 49 of file numbers.cc.

{ *d=NULL; }

static FORCE_INLINE void nSetChar ( const coeffs  r )

static

initialisations after each ring change

Definition at line 436 of file coeffs.h.

{ STATISTIC(nSetChar);  assume(r!=NULL); assume(r->cfSetChar != NULL); r->cfSetChar(r); }

static FORCE_INLINE void number2mpz ( number  n, coeffs  c, mpz_t  m  )

static

Definition at line 986 of file coeffs.h.

{ n_MPZ(m, n, c); }

Variable Documentation

unsigned short fftable[]

Definition at line 61 of file ffields.cc.

omBin rnumber_bin

Definition at line 23 of file longrat0.cc.