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)
#define	ALLOC_RNUMBER()
#define	ALLOC0_RNUMBER()
#define	n_Test(a, r)
	BOOLEAN n_Test(number a, const coeffs r).

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
typedef IEnumerator< number >	ICoeffsEnumerator
	Abstract interface for an enumerator of number coefficients for an object, e.g. a polynomial.
typedef void(*	nCoeffsEnumeratorFunc) (ICoeffsEnumerator &numberCollectionEnumerator, number &output, const coeffs r)
	goes over coeffs given by the ICoeffsEnumerator and changes them. Additionally returns a number;

Enumerations
enum	n_coeffType {   n_unknown =0 , n_Zp =1 , n_Q =2 , n_R =3 ,   n_GF =4 , n_long_R =5 , n_polyExt =6 , n_algExt =7 ,   n_transExt =8 , n_long_C =9 , n_nTupel =10 , n_Z =11 ,   n_Zn =12 , n_Znm =13 , n_Z2m =14 , n_FlintQrat =15 ,   n_CF =16 , n_Nemo_AnticNumberField =17 , n_Nemo_QQField =18 , n_Nemo_ZZRing =19 ,   n_Nemo_FqPolyRepField =20 , n_Nemo_fqPolyRepField =21 , n_Nemo_Field =22 , n_Nemo_Ring =23 }
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.
coeffs	nInitChar (n_coeffType t, void *parameter)
	one-time initialisations for new coeffs in case of an error return NULL
static FORCE_INLINE coeffs	nCopyCoeff (const coeffs r)
	"copy" coeffs, i.e. increment ref
void	nKillChar (coeffs r)
	undo all initialisations
static FORCE_INLINE void	nSetChar (const coeffs r)
	initialisations after each ring change
static FORCE_INLINE int	n_GetChar (const coeffs r)
	Return the characteristic of the coeff. domain.
static FORCE_INLINE number	n_Copy (number n, const coeffs r)
	return a copy of 'n'
static FORCE_INLINE void	n_Delete (number *p, const coeffs r)
	delete 'p'
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.
static FORCE_INLINE BOOLEAN	n_IsZero (number n, const coeffs r)
	TRUE iff 'n' represents the zero element.
static FORCE_INLINE BOOLEAN	n_IsOne (number n, const coeffs r)
	TRUE iff 'n' represents the one element.
static FORCE_INLINE BOOLEAN	n_IsMOne (number n, const coeffs r)
	TRUE iff 'n' represents the additive inverse of the one element, i.e. -1.
static FORCE_INLINE BOOLEAN	n_GreaterZero (number n, const coeffs r)
	ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0
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
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.
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
static FORCE_INLINE number	n_Init (long i, const coeffs r)
	a number representing i in the given coeff field/ring r
static FORCE_INLINE number	n_InitMPZ (mpz_t n, const coeffs r)
	conversion of a GMP integer to number
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]
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
static FORCE_INLINE number	n_InpNeg (number n, const coeffs r)
	in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
static FORCE_INLINE number	n_Invers (number a, const coeffs r)
	return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible
static FORCE_INLINE 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)
static FORCE_INLINE void	n_Normalize (number &n, const coeffs r)
	inplace-normalization of n; produces some canonical representation of n;
static FORCE_INLINE void	n_WriteLong (number n, const coeffs r)
	write to the output buffer of the currently used reporter
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
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.
static FORCE_INLINE number	n_GetDenom (number &n, const coeffs r)
	return the denominator of n (if elements of r are by nature not fractional, result is 1)
static FORCE_INLINE number	n_GetNumerator (number &n, const coeffs r)
	return the numerator of n (if elements of r are by nature not fractional, result is n)
static FORCE_INLINE number	n_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
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.
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
static FORCE_INLINE void	n_Power (number a, int b, number *res, const coeffs r)
	fill res with the power a^b
static FORCE_INLINE number	n_Mult (number a, number b, const coeffs r)
	return the product of 'a' and 'b', i.e., a*b
static FORCE_INLINE void	n_InpMult (number &a, number b, const coeffs r)
	multiplication of 'a' and 'b'; replacement of 'a' by the product a*b
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
static FORCE_INLINE number	n_Add (number a, number b, const coeffs r)
	return the sum of 'a' and 'b', i.e., a+b
static FORCE_INLINE number	n_Sub (number a, number b, const coeffs r)
	return the difference of 'a' and 'b', i.e., a-b
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
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...
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
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
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)
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
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
static FORCE_INLINE void	n_CoeffWrite (const coeffs r, BOOLEAN details=TRUE)
	output the coeff description
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)
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))
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.
static FORCE_INLINE char const **	n_ParameterNames (const coeffs r)
	Returns a (const!) pointer to (const char*) names of parameters.
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(...)
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
static FORCE_INLINE BOOLEAN	nCoeff_is_Zp (const coeffs r)
static FORCE_INLINE BOOLEAN	nCoeff_is_Zp_long (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.
static FORCE_INLINE BOOLEAN	nCoeff_has_simple_Alloc (const coeffs r)
	TRUE if n_Delete is empty operation.
static FORCE_INLINE BOOLEAN	nCoeff_is_algExt (const coeffs r)
	TRUE iff r represents an algebraic extension field.
static FORCE_INLINE BOOLEAN	nCoeff_is_Q_algExt (const coeffs r)
	is it an alg. ext. of Q?
static FORCE_INLINE BOOLEAN	nCoeff_is_transExt (const coeffs r)
	TRUE iff r represents a transcendental extension field.
static FORCE_INLINE BOOLEAN	nCoeff_is_Q_transExt (const coeffs r)
	is it an trans. ext. of Q?
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.
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
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
static FORCE_INLINE char *	nCoeffString (const coeffs cf)
	TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
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:
static FORCE_INLINE void	n_WriteFd_S (number a, const coeffs r)
static FORCE_INLINE number	n_ReadFd (const ssiInfo *f, const coeffs r)
	io via ssi:
static FORCE_INLINE number	n_ReadFd_S (char **s, const coeffs r)
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 99 of file coeffs.h.

Data Fields
int	GFChar
int	GFDegree
const char *	GFPar_name

LongComplexInfo

struct LongComplexInfo

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

(

)

Value:

(number)omAlloc0Bin(rnumber_bin)

Definition at line 95 of file coeffs.h.

ALLOC_RNUMBER

#define ALLOC_RNUMBER

(

)

Value:

(number)omAllocBin(rnumber_bin)

Definition at line 94 of file coeffs.h.

FREE_RNUMBER

#define FREE_RNUMBER

(

x

)

Value:

omFreeBin((void *)x, rnumber_bin)

Definition at line 93 of file coeffs.h.

n_Test

#define n_Test	(		a,
			r )

Value:

n_DBTest(a, __FILE__, __LINE__, r)

BOOLEAN n_Test(number a, const coeffs r).

Definition at line 715 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 85 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 89 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 80 of file coeffs.h.

numberfunc

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

Definition at line 77 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 114 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 coefficients
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 function field over Q
n_CF	?
n_Nemo_AnticNumberField
n_Nemo_QQField
n_Nemo_ZZRing
n_Nemo_FqPolyRepField
n_Nemo_fqPolyRepField
n_Nemo_Field
n_Nemo_Ring

Definition at line 26 of file coeffs.h.

{
  n_unknown=0,
  n_Zp=1, /**< \F{p < 2^31} */
  n_Q=2,  /**< rational (GMP) numbers */
  n_R=3,  /**< single prescision (6,6) real numbers */
  n_GF=4, /**< \GF{p^n < 2^16} */
  n_long_R=5, /**< real floating point (GMP) numbers */
  n_polyExt=6, /**< used to represent polys as coefficients */
  n_algExt=7,  /**< used for all algebraic extensions, i.e.,
                the top-most extension in an extension tower
                is algebraic */
  n_transExt=8,  /**< used for all transcendental extensions, i.e.,
                  the top-most extension in an extension tower
                  is transcendental */
  n_long_C=9, /**< complex floating point (GMP) numbers */
  n_nTupel=10, /**< n-tupel of cf: ZZ/p1,... ZZ/pn, R, long_R */
  n_Z=11, /**< only used if HAVE_RINGS is defined  */
  n_Zn=12, /**< only used if HAVE_RINGS is defined */
  n_Znm=13, /**< only used if HAVE_RINGS is defined */
  n_Z2m=14, /**< only used if HAVE_RINGS is defined */
  n_FlintQrat=15, /**< rational function field over Q */
  n_CF=16, /**< ? */
  n_Nemo_AnticNumberField=17, /*17 */
  n_Nemo_QQField=18,          /*18 */
  n_Nemo_ZZRing=19,           /*19*/
  n_Nemo_FqPolyRepField=20,   /*20 */
  n_Nemo_fqPolyRepField=21,   /*21 */
  n_Nemo_Field=22,            /*22 */
  n_Nemo_Ring=23              /*23 */
};

Function Documentation

getCoeffType()

FORCE_INLINE n_coeffType getCoeffType ( const coeffs r )

static

Returns the type of coeffs domain.

Definition at line 431 of file coeffs.h.

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

mpz2number()

FORCE_INLINE number mpz2number ( mpz_t m, coeffs c )

static

Definition at line 994 of file coeffs.h.

{ return n_InitMPZ(m, c); }

n_Add()

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.

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

n_Ann()

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

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

n_ChineseRemainderSym()

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

static

Definition at line 756 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]

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

static

Definition at line 946 of file coeffs.h.

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

n_ClearContent() [2/2]

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

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

n_ClearDenominators() [1/2]

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

static

Definition at line 949 of file coeffs.h.

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

n_ClearDenominators() [2/2]

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

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

n_CoeffRingQuot1()

FORCE_INLINE coeffs n_CoeffRingQuot1 ( number c, const coeffs r )

static

Definition at line 524 of file coeffs.h.

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

n_CoeffWrite()

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

static

output the coeff description

Definition at line 722 of file coeffs.h.

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

n_convFactoryNSingN()

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

static

Definition at line 984 of file coeffs.h.

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

n_convSingNFactoryN()

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

static

Definition at line 987 of file coeffs.h.

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

n_Copy()

FORCE_INLINE number n_Copy ( number n, const coeffs r )

static

return a copy of 'n'

Definition at line 457 of file coeffs.h.

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

n_DBTest()

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

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

n_Delete()

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

static

delete 'p'

Definition at line 461 of file coeffs.h.

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

n_Div()

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

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

n_DivBy()

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

{ assume(r != NULL);
  if( nCoeff_is_Ring(r) )
  {
    assume(r->cfDivBy!=NULL); return r->cfDivBy(a,b,r);
  }
  return !n_IsZero(b, r);
}

n_DivComp()

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

static

Definition at line 527 of file coeffs.h.

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

n_Equal()

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

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

n_EucNorm()

FORCE_INLINE number n_EucNorm ( number a, const coeffs r )

static

Definition at line 678 of file coeffs.h.

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

n_ExactDiv()

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

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

n_ExtGcd()

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

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

n_Farey()

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

static

Definition at line 759 of file coeffs.h.

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

n_Gcd()

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

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

n_GetChar()

FORCE_INLINE int n_GetChar ( const coeffs r )

static

Return the characteristic of the coeff. domain.

Definition at line 450 of file coeffs.h.

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

n_GetDenom()

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

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

n_GetNumerator()

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

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

n_GetUnit()

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

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

n_Greater()

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

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

n_GreaterZero()

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

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

n_ImPart()

FORCE_INLINE number n_ImPart ( number i, const coeffs cf )

static

Definition at line 785 of file coeffs.h.

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

n_Init()

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

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

n_InitMPZ()

FORCE_INLINE number n_InitMPZ ( mpz_t n, const coeffs r )

static

conversion of a GMP integer to number

Definition at line 545 of file coeffs.h.

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

n_InpAdd()

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

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

n_InpMult()

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

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

n_InpNeg()

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

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

n_Int()

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

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

n_IntMod()

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

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

n_Invers()

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

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

n_IsMOne()

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

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

n_IsOne()

FORCE_INLINE BOOLEAN n_IsOne ( number n, const coeffs r )

static

TRUE iff 'n' represents the one element.

Definition at line 474 of file coeffs.h.

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

n_IsUnit()

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

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

n_IsZero()

FORCE_INLINE BOOLEAN n_IsZero ( number n, const coeffs r )

static

TRUE iff 'n' represents the zero element.

Definition at line 470 of file coeffs.h.

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

n_Lcm()

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

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

n_MPZ()

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

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

n_Mult()

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

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

n_Normalize()

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

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

n_NormalizeHelper()

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

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

n_NumberOfParameters()

FORCE_INLINE int n_NumberOfParameters ( const coeffs r )

static

Returns the number of parameters.

Definition at line 766 of file coeffs.h.

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

n_Param()

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 775 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()

FORCE_INLINE char const ** n_ParameterNames ( const coeffs r )

static

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

Definition at line 770 of file coeffs.h.

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

n_ParDeg()

FORCE_INLINE int n_ParDeg ( number n, const coeffs r )

static

Definition at line 762 of file coeffs.h.

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

n_Power()

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 635 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 662 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()

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

static

Definition at line 684 of file coeffs.h.

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

n_Random()

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

static

Definition at line 968 of file coeffs.h.

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

n_Read()

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

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

n_ReadFd()

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

static

io via ssi:

Definition at line 978 of file coeffs.h.

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

n_ReadFd_S()

FORCE_INLINE number n_ReadFd_S ( char ** s, const coeffs r )

static

Definition at line 980 of file coeffs.h.

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

n_RePart()

FORCE_INLINE number n_RePart ( number i, const coeffs cf )

static

Definition at line 782 of file coeffs.h.

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

n_SetMap()

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 703 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()

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

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

n_Sub()

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

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

n_SubringGcd()

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

static

Definition at line 669 of file coeffs.h.

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

n_Write()

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

static

Definition at line 594 of file coeffs.h.

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

n_WriteFd()

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

static

io via ssi:

Definition at line 972 of file coeffs.h.

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

n_WriteFd_S()

FORCE_INLINE void n_WriteFd_S ( number a, const coeffs r )

static

Definition at line 974 of file coeffs.h.

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

n_WriteLong()

FORCE_INLINE void n_WriteLong ( number n, const coeffs r )

static

write to the output buffer of the currently used reporter

Definition at line 586 of file coeffs.h.

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

n_WriteShort()

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

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

n_XExtGcd()

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

static

Definition at line 676 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()

FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc ( const coeffs r )

static

TRUE if n_Delete is empty operation.

Definition at line 904 of file coeffs.h.

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

nCoeff_has_simple_inverse()

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

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

nCoeff_has_Units()

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

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

nCoeff_is_algExt()

FORCE_INLINE BOOLEAN nCoeff_is_algExt ( const coeffs r )

static

TRUE iff r represents an algebraic extension field.

Definition at line 908 of file coeffs.h.

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

nCoeff_is_CF()

FORCE_INLINE BOOLEAN nCoeff_is_CF ( const coeffs r )

static

Definition at line 895 of file coeffs.h.

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

nCoeff_is_Domain()

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()

FORCE_INLINE BOOLEAN nCoeff_is_Extension ( const coeffs r )

static

Definition at line 844 of file coeffs.h.

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

nCoeff_is_GF() [1/2]

FORCE_INLINE BOOLEAN nCoeff_is_GF ( const coeffs r )

static

Definition at line 837 of file coeffs.h.

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

nCoeff_is_GF() [2/2]

FORCE_INLINE BOOLEAN nCoeff_is_GF ( const coeffs r, int q )

static

Definition at line 840 of file coeffs.h.

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

nCoeff_is_long_C()

FORCE_INLINE BOOLEAN nCoeff_is_long_C ( const coeffs r )

static

Definition at line 892 of file coeffs.h.

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

nCoeff_is_long_R()

FORCE_INLINE BOOLEAN nCoeff_is_long_R ( const coeffs r )

static

Definition at line 889 of file coeffs.h.

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

nCoeff_is_numeric()

FORCE_INLINE BOOLEAN nCoeff_is_numeric ( const coeffs r )

static

Definition at line 830 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()

FORCE_INLINE BOOLEAN nCoeff_is_Q ( const coeffs r )

static

Definition at line 804 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()

FORCE_INLINE BOOLEAN nCoeff_is_Q_a ( const coeffs r )

static

Definition at line 883 of file coeffs.h.

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

nCoeff_is_Q_algExt()

FORCE_INLINE BOOLEAN nCoeff_is_Q_algExt ( const coeffs r )

static

is it an alg. ext. of Q?

Definition at line 912 of file coeffs.h.

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

nCoeff_is_Q_or_BI()

FORCE_INLINE BOOLEAN nCoeff_is_Q_or_BI ( const coeffs r )

static

Definition at line 827 of file coeffs.h.

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

nCoeff_is_Q_transExt()

FORCE_INLINE BOOLEAN nCoeff_is_Q_transExt ( const coeffs r )

static

is it an trans. ext. of Q?

Definition at line 920 of file coeffs.h.

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

nCoeff_is_R()

FORCE_INLINE BOOLEAN nCoeff_is_R ( const coeffs r )

static

Definition at line 834 of file coeffs.h.

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

nCoeff_is_Ring()

FORCE_INLINE BOOLEAN nCoeff_is_Ring ( const coeffs r )

static

Definition at line 732 of file coeffs.h.

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

nCoeff_is_Ring_2toM()

FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM ( const coeffs r )

static

Definition at line 726 of file coeffs.h.

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

nCoeff_is_Ring_PtoM()

FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM ( const coeffs r )

static

Definition at line 729 of file coeffs.h.

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

nCoeff_is_transExt()

FORCE_INLINE BOOLEAN nCoeff_is_transExt ( const coeffs r )

static

TRUE iff r represents a transcendental extension field.

Definition at line 916 of file coeffs.h.

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

nCoeff_is_Z()

FORCE_INLINE BOOLEAN nCoeff_is_Z ( const coeffs r )

static

Definition at line 814 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()

FORCE_INLINE BOOLEAN nCoeff_is_Zn ( const coeffs r )

static

Definition at line 824 of file coeffs.h.

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

nCoeff_is_Zp() [1/2]

FORCE_INLINE BOOLEAN nCoeff_is_Zp ( const coeffs r )

static

Definition at line 794 of file coeffs.h.

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

nCoeff_is_Zp() [2/2]

FORCE_INLINE BOOLEAN nCoeff_is_Zp ( const coeffs r, int p )

static

Definition at line 801 of file coeffs.h.

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

nCoeff_is_Zp_a() [1/2]

FORCE_INLINE BOOLEAN nCoeff_is_Zp_a ( const coeffs r )

static

Definition at line 857 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]

FORCE_INLINE BOOLEAN nCoeff_is_Zp_a ( const coeffs r, int p )

static

Definition at line 870 of file coeffs.h.

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

nCoeff_is_Zp_long()

FORCE_INLINE BOOLEAN nCoeff_is_Zp_long ( const coeffs r )

static

Definition at line 797 of file coeffs.h.

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

nCoeffName()

FORCE_INLINE char * nCoeffName ( const coeffs cf )

static

Definition at line 965 of file coeffs.h.

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

nCoeffString()

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

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

nCopyCoeff()

FORCE_INLINE coeffs nCopyCoeff ( const coeffs r )

static

"copy" coeffs, i.e. increment ref

Definition at line 439 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 293 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 412 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 always 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->cfReadFd_S = ndReadFd_S; /* not implemented */
    n->cfWriteFd = ndWriteFd; /* not implemented */
 
    n->cfParameter = ndParameter;
 
    n->cfClearContent = ndClearContent;
    n->cfClearDenominators = ndClearDenominators;
 
    n->cfEucNorm = ndEucNorm;
    n->cfDivComp = ndDivComp;
    n->cfDivBy = ndDivBy;
    n->cfExtGcd = ndExtGcd;
    n->cfXExtGcd = ndXExtGcd;
    //n->cfGetUnit = ndGetUnit_Ring;// set afterwards
 
    // 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;
    }
    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;
    }
 
    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 563 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()

FORCE_INLINE void nSetChar ( const coeffs r )

static

initialisations after each ring change

Definition at line 446 of file coeffs.h.

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

number2mpz()

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

static

Definition at line 993 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 91 of file coeffs.h.