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 "factory/factory.h"
#include "coeffs/si_gmp.h"
#include "coeffs/Enumerator.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_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_polyExt , n_algExt ,   n_transExt , n_long_C , n_nTupel , n_Z ,   n_Zn , n_Znm , n_Z2m , n_FlintQrat ,   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...
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 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 coeffs	n_CoeffRingQuot1 (number c, const coeffs r)
static FORCE_INLINE int	n_DivComp (number a, number b, const coeffs r)
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 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' always: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a 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) always: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a n_IntMod(a,b,r) >=0 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...
number	ndCopyMap (number a, const coeffs src, const coeffs dst)
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_PtoM (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, CFArray &inv_cache, 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_Z (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_Zn (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_Q_or_BI (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 is empty operation. 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, const ssiInfo *f, const coeffs r)
	io via ssi: More...
static FORCE_INLINE number	n_ReadFd (const ssiInfo *f, const coeffs r)
	io via ssi: More...
static FORCE_INLINE number	n_convFactoryNSingN (const CanonicalForm n, const coeffs r)
static FORCE_INLINE 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
const unsigned short	fftable []
EXTERN_VAR 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

GFInfo

struct GFInfo

Creation data needed for finite fields.

Definition at line 92 of file coeffs.h.

Data Fields
int	GFChar
int	GFDegree
const char *	GFPar_name

LongComplexInfo

struct LongComplexInfo

Definition at line 99 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

ALLOC0_RNUMBER

#define ALLOC0_RNUMBER

(

)

(number)omAlloc0Bin(rnumber_bin)

Definition at line 88 of file coeffs.h.

ALLOC_RNUMBER

#define ALLOC_RNUMBER

(

)

(number)omAllocBin(rnumber_bin)

Definition at line 87 of file coeffs.h.

FREE_RNUMBER

#define FREE_RNUMBER

(

x

)

omFreeBin((void *)x, rnumber_bin)

Definition at line 86 of file coeffs.h.

n_Test

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

BOOLEAN n_Test(number a, const coeffs r)

Definition at line 709 of file coeffs.h.

Typedef Documentation

ICoeffsEnumerator

typedef IEnumerator<number> ICoeffsEnumerator

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

Definition at line 78 of file coeffs.h.

nCoeffsEnumeratorFunc

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 82 of file coeffs.h.

nMapFunc

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

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

Definition at line 73 of file coeffs.h.

numberfunc

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

Definition at line 70 of file coeffs.h.

Enumeration Type Documentation

n_coeffRep

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 107 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 */
};

n_coeffType

enum n_coeffType

Enumerator
n_unknown
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_polyExt	used to represent polys as coeffcients
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_nTupel	n-tupel of cf: ZZ/p1,... ZZ/pn, R, long_R
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_FlintQrat	rational funtion field over Q
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_polyExt, /**< used to represent polys as coeffcients */
  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_nTupel, /**< n-tupel of cf: ZZ/p1,... ZZ/pn, R, long_R */
  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_FlintQrat, /**< rational funtion field over Q */
  n_CF /**< ? */
};

Function Documentation

getCoeffType()

static FORCE_INLINE n_coeffType getCoeffType ( const coeffs  r )

static

Returns the type of coeffs domain.

Definition at line 422 of file coeffs.h.

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

mpz2number()

static FORCE_INLINE number mpz2number ( mpz_t  m, coeffs  c  )

static

Definition at line 985 of file coeffs.h.

{ return n_InitMPZ(m, c); }

n_Add()

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 647 of file coeffs.h.

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

n_Ann()

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 676 of file coeffs.h.

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

n_ChineseRemainderSym()

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

static

Definition at line 761 of file coeffs.h.

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

n_ClearContent() [1/2]

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

static

Definition at line 941 of file coeffs.h.

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

n_ClearContent() [2/2]

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 925 of file coeffs.h.

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

n_ClearDenominators() [1/2]

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

static

Definition at line 944 of file coeffs.h.

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

n_ClearDenominators() [2/2]

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 932 of file coeffs.h.

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

n_CoeffRingQuot1()

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

static

Definition at line 515 of file coeffs.h.

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

n_CoeffWrite()

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

static

output the coeff description

Definition at line 716 of file coeffs.h.

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

n_convFactoryNSingN()

static FORCE_INLINE number n_convFactoryNSingN ( const CanonicalForm  n, const coeffs  r  )

static

Definition at line 975 of file coeffs.h.

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

n_convSingNFactoryN()

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

static

Definition at line 978 of file coeffs.h.

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

n_Copy()

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

static

return a copy of 'n'

Definition at line 448 of file coeffs.h.

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

n_DBTest()

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 706 of file coeffs.h.

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

n_Delete()

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

static

delete 'p'

Definition at line 452 of file coeffs.h.

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

n_Div()

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' always: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a

Definition at line 612 of file coeffs.h.

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

n_DivBy()

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 750 of file coeffs.h.

{ 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);
}

n_DivComp()

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

static

Definition at line 519 of file coeffs.h.

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

n_Equal()

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 457 of file coeffs.h.

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

n_EucNorm()

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

static

Definition at line 672 of file coeffs.h.

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

n_ExactDiv()

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 619 of file coeffs.h.

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

n_ExtGcd()

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 668 of file coeffs.h.

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

n_Farey()

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

static

Definition at line 764 of file coeffs.h.

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

n_Gcd()

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 661 of file coeffs.h.

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

n_GetChar()

static FORCE_INLINE int n_GetChar ( const coeffs  r )

static

Return the characteristic of the coeff. domain.

Definition at line 441 of file coeffs.h.

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

n_GetDenom()

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 600 of file coeffs.h.

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

n_GetNumerator()

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 605 of file coeffs.h.

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

n_GetUnit()

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.

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

n_Greater()

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 508 of file coeffs.h.

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

n_GreaterZero()

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 491 of file coeffs.h.

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

n_ImPart()

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

static

Definition at line 790 of file coeffs.h.

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

n_Init()

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 535 of file coeffs.h.

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

n_InitMPZ()

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

static

conversion of a GMP integer to number

Definition at line 539 of file coeffs.h.

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

n_InpAdd()

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.

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

n_InpMult()

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.

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

n_InpNeg()

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 554 of file coeffs.h.

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

n_Int()

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 544 of file coeffs.h.

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

n_IntMod()

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

static

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

Definition at line 625 of file coeffs.h.

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

n_Invers()

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 561 of file coeffs.h.

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

n_IsMOne()

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 469 of file coeffs.h.

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

n_IsOne()

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

static

TRUE iff 'n' represents the one element.

Definition at line 465 of file coeffs.h.

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

n_IsUnit()

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 512 of file coeffs.h.

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

n_IsZero()

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

static

TRUE iff 'n' represents the zero element.

Definition at line 461 of file coeffs.h.

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

n_Lcm()

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 687 of file coeffs.h.

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

n_MPZ()

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 548 of file coeffs.h.

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

n_Mult()

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.

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

n_Normalize()

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 575 of file coeffs.h.

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

n_NormalizeHelper()

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 692 of file coeffs.h.

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

n_NumberOfParameters()

static FORCE_INLINE int n_NumberOfParameters ( const coeffs  r )

static

Returns the number of parameters.

Definition at line 771 of file coeffs.h.

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

n_Param()

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 780 of file coeffs.h.

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

n_ParameterNames()

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

static

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

Definition at line 775 of file coeffs.h.

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

n_ParDeg()

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

static

Definition at line 767 of file coeffs.h.

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

n_Power()

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.

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

n_Print()

void n_Print	(	number &	a,
		const coeffs	r
	)

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

Definition at line 667 of file numbers.cc.

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

n_QuotRem()

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

static

Definition at line 678 of file coeffs.h.

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

n_Random()

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

static

Definition at line 963 of file coeffs.h.

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

n_Read()

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 595 of file coeffs.h.

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

n_ReadFd()

static FORCE_INLINE number n_ReadFd ( const ssiInfo *  f, const coeffs  r  )

static

io via ssi:

Definition at line 971 of file coeffs.h.

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

n_RePart()

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

static

Definition at line 787 of file coeffs.h.

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

n_SetMap()

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 697 of file coeffs.h.

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

n_Size()

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 567 of file coeffs.h.

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

n_Sub()

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 652 of file coeffs.h.

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

n_SubringGcd()

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

static

Definition at line 663 of file coeffs.h.

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

n_Write()

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

static

Definition at line 588 of file coeffs.h.

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

n_WriteFd()

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

static

io via ssi:

Definition at line 967 of file coeffs.h.

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

n_WriteLong()

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 580 of file coeffs.h.

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

n_WriteShort()

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 585 of file coeffs.h.

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

n_XExtGcd()

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 670 of file coeffs.h.

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

nCoeff_has_simple_Alloc()

static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc ( const coeffs  r )

static

TRUE if n_Delete is empty operation.

Definition at line 903 of file coeffs.h.

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

nCoeff_has_simple_inverse()

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 899 of file coeffs.h.

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

nCoeff_has_Units()

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 794 of file coeffs.h.

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

nCoeff_is_algExt()

static FORCE_INLINE BOOLEAN nCoeff_is_algExt ( const coeffs  r )

static

TRUE iff r represents an algebraic extension field.

Definition at line 907 of file coeffs.h.

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

nCoeff_is_CF()

static FORCE_INLINE BOOLEAN nCoeff_is_CF ( const coeffs  r )

static

Definition at line 894 of file coeffs.h.

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

nCoeff_is_Domain()

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 736 of file coeffs.h.

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

nCoeff_is_Extension()

static FORCE_INLINE BOOLEAN nCoeff_is_Extension ( const coeffs  r )

static

Definition at line 843 of file coeffs.h.

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

nCoeff_is_GF() [1/2]

static FORCE_INLINE BOOLEAN nCoeff_is_GF ( const coeffs  r )

static

Definition at line 836 of file coeffs.h.

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

nCoeff_is_GF() [2/2]

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

static

Definition at line 839 of file coeffs.h.

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

nCoeff_is_long_C()

static FORCE_INLINE BOOLEAN nCoeff_is_long_C ( const coeffs  r )

static

Definition at line 891 of file coeffs.h.

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

nCoeff_is_long_R()

static FORCE_INLINE BOOLEAN nCoeff_is_long_R ( const coeffs  r )

static

Definition at line 888 of file coeffs.h.

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

nCoeff_is_numeric()

static FORCE_INLINE BOOLEAN nCoeff_is_numeric ( const coeffs  r )

static

Definition at line 829 of file coeffs.h.

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

nCoeff_is_Q()

static FORCE_INLINE BOOLEAN nCoeff_is_Q ( const coeffs  r )

static

Definition at line 803 of file coeffs.h.

{
  assume(r != NULL);
  #if SI_INTEGER_VARIANT==1
  return getCoeffType(r)==n_Q && (r->is_field);
  #else
  return getCoeffType(r)==n_Q;
  #endif
}

nCoeff_is_Q_a()

static FORCE_INLINE BOOLEAN nCoeff_is_Q_a ( const coeffs  r )

static

Definition at line 882 of file coeffs.h.

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

nCoeff_is_Q_algext()

static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext ( const coeffs  r )

static

is it an alg. ext. of Q?

Definition at line 911 of file coeffs.h.

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

nCoeff_is_Q_or_BI()

static FORCE_INLINE BOOLEAN nCoeff_is_Q_or_BI ( const coeffs  r )

static

Definition at line 826 of file coeffs.h.

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

nCoeff_is_R()

static FORCE_INLINE BOOLEAN nCoeff_is_R ( const coeffs  r )

static

Definition at line 833 of file coeffs.h.

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

nCoeff_is_Ring()

static FORCE_INLINE BOOLEAN nCoeff_is_Ring ( const coeffs  r )

static

Definition at line 727 of file coeffs.h.

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

nCoeff_is_Ring_2toM()

static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM ( const coeffs  r )

static

Definition at line 721 of file coeffs.h.

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

nCoeff_is_Ring_PtoM()

static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM ( const coeffs  r )

static

Definition at line 724 of file coeffs.h.

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

nCoeff_is_transExt()

static FORCE_INLINE BOOLEAN nCoeff_is_transExt ( const coeffs  r )

static

TRUE iff r represents a transcendental extension field.

Definition at line 915 of file coeffs.h.

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

nCoeff_is_Z()

static FORCE_INLINE BOOLEAN nCoeff_is_Z ( const coeffs  r )

static

Definition at line 813 of file coeffs.h.

{
  assume(r != NULL);
  #if SI_INTEGER_VARIANT==1
  return ((getCoeffType(r)==n_Q) && (!r->is_field));
  #else
  return getCoeffType(r)==n_Z;
  #endif
}

nCoeff_is_Zn()

static FORCE_INLINE BOOLEAN nCoeff_is_Zn ( const coeffs  r )

static

Definition at line 823 of file coeffs.h.

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

nCoeff_is_Zp() [1/2]

static FORCE_INLINE BOOLEAN nCoeff_is_Zp ( const coeffs  r )

static

Definition at line 797 of file coeffs.h.

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

nCoeff_is_Zp() [2/2]

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

static

Definition at line 800 of file coeffs.h.

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

nCoeff_is_Zp_a() [1/2]

static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a ( const coeffs  r )

static

Definition at line 856 of file coeffs.h.

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

nCoeff_is_Zp_a() [2/2]

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

static

Definition at line 869 of file coeffs.h.

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

nCoeffName()

static FORCE_INLINE char * nCoeffName ( const coeffs  cf )

static

Definition at line 960 of file coeffs.h.

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

nCoeffString()

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 956 of file coeffs.h.

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

nCopyCoeff()

static FORCE_INLINE coeffs nCopyCoeff ( const coeffs  r )

static

"copy" coeffs, i.e. increment ref

Definition at line 430 of file coeffs.h.

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

ndCopyMap()

number ndCopyMap	(	number	a,
		const coeffs	src,
		const coeffs	dst
	)

Definition at line 291 of file numbers.cc.

{
  // aRing and r need not be the same, but must be the same representation
  assume(aRing->rep==r->rep);
  if ( nCoeff_has_simple_Alloc(r) && nCoeff_has_simple_Alloc(aRing) )
    return a;
  else
    return r->cfCopy(a, r);
}

nInitChar()

coeffs nInitChar	(	n_coeffType	t,
		void *	parameter
	)

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

Definition at line 413 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;
    n->cfCoeffWrite = ndCoeffWrite;
    n->cfCoeffName = ndCoeffName; // should alway be changed!
    n->cfInpAdd=ndInpAdd;
    n->cfInpMult=ndInpMult;
    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->cfQuotRem = ndQuotRem;
    n->cfInvers = ndInvers;
    n->cfRandom = ndRandom;
 
    n->cfKillChar = ndKillChar; /* dummy */
    n->cfSetChar = ndSetChar; /* dummy */
    // temp. removed to catch all the coeffs which miss to implement this!
 
    n->cfChineseRemainder = ndChineseRemainder; /* not implemented */
    n->cfFarey = ndFarey; /* not implemented */
    n->cfParDeg = ndParDeg; /* not implemented */
    n->cfReadFd = ndReadFd; /* not implemented */
    n->cfWriteFd = ndWriteFd; /* not implemented */
 
    n->cfParameter = ndParameter;
 
    n->cfClearContent = ndClearContent;
    n->cfClearDenominators = ndClearDenominators;
 
    n->cfEucNorm = ndEucNorm;
#ifdef HAVE_RINGS
    n->cfDivComp = ndDivComp;
    n->cfDivBy = ndDivBy;
    n->cfExtGcd = ndExtGcd;
    n->cfXExtGcd = ndXExtGcd;
    //n->cfGetUnit = ndGetUnit_Ring;// set afterwards
#endif
 
    // report error, if not redefined
    n->cfRead=ndRead;
    n->cfSetMap=ndSetMap;
 
#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;
    if (n->cfWriteShort==NULL) n->cfWriteShort = n->cfWriteLong;
    if (n->cfIsUnit==NULL)
    {
      if (n->is_field) n->cfIsUnit=ndIsUnit_Field;
      else             n->cfIsUnit=ndIsUnit_Ring;
    }
    #ifdef HAVE_RINGS
    if (n->cfGetUnit==NULL)
    {
      if (n->is_field) n->cfGetUnit=n->cfCopy;
      else             n->cfGetUnit=ndGetUnit_Ring;
    }
    if ((n->cfInvers==ndInvers)&&(n->is_field))
    {
      n->cfInvers=ndInvers_Ring;
    }
    #endif
 
 
    if(n->cfMult==NULL)  PrintS("cfMult missing\n");
    if(n->cfSub==NULL)  PrintS("cfSub missing\n");
    if(n->cfAdd==NULL) PrintS("cfAdd missing\n");
    if(n->cfDiv==NULL) PrintS("cfDiv missing\n");
    if(n->cfExactDiv==NULL) PrintS("cfExactDiv missing\n");
    if(n->cfInit==NULL) PrintS("cfInit missing\n");
    if(n->cfInt==NULL) PrintS("cfInt missing\n");
    if(n->cfIsUnit==NULL) PrintS("cfIsUnit missing\n");
    if(n->cfGetUnit==NULL) PrintS("cfGetUnit missing\n");
    if(n->cfInpNeg==NULL)  PrintS("cfInpNeg missing\n");
    if(n->cfXExtGcd==NULL)  PrintS("cfXExtGcd missing\n");
    if(n->cfAnn==NULL)  PrintS("cfAnn missing\n");
    if(n->cfWriteLong==NULL) PrintS("cfWriteLong missing\n");
 
    assume(n->iNumberOfParameters>= 0);
 
    assume( (n->iNumberOfParameters == 0 && n->pParameterNames == NULL) ||
            (n->iNumberOfParameters >  0 && n->pParameterNames != NULL) );
 
 
    if(n->cfGreater==NULL) PrintS("cfGreater missing\n");
    if(n->cfEqual==NULL) PrintS("cfEqual missing\n");
    if(n->cfIsZero==NULL) PrintS("cfIsZero missing\n");
    if(n->cfIsOne==NULL) PrintS("cfIsOne missing\n");
    if(n->cfIsMOne==NULL) PrintS("cfIsMOne missing\n");
    if(n->cfGreaterZero==NULL) PrintS("cfGreaterZero missing\n");
    /* error reporter:
    if(n->cfRead==ndRead) PrintS("cfRead missing\n");
    if(n->cfSetMap==ndSetMap) PrintS("cfSetMap missing\n");
    */
 
    assume(n->type==t);
 
#ifndef SING_NDEBUG
    if(n->cfWriteLong==NULL) Warn("cfWrite is NULL for coeff %d",t);
    if(n->cfWriteShort==NULL) Warn("cfWriteShort is NULL for coeff %d",t);
#endif
  }
  else
  {
    n->ref++;
  }
  return n;

nKillChar()

void nKillChar

(

coeffs

r

)

undo all initialisations

Definition at line 568 of file numbers.cc.

{
  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;
        assume (r->cfKillChar!=NULL); r->cfKillChar(r);
        omFreeSize((void *)r, sizeof(n_Procs_s));
        r=NULL;
      }
      else
      {
        WarnS("cf_root list destroyed");
      }
    }
  }

nSetChar()

static FORCE_INLINE void nSetChar ( const coeffs  r )

static

initialisations after each ring change

Definition at line 437 of file coeffs.h.

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

number2mpz()

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

static

Definition at line 984 of file coeffs.h.

{ n_MPZ(m, n, c); }

Variable Documentation

fftable

const unsigned short fftable[]

extern

Definition at line 27 of file ffields.cc.

rnumber_bin

EXTERN_VAR omBin rnumber_bin

Definition at line 84 of file coeffs.h.