Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
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"
#include "coeffs/numstats.h"

Go to the source code of this file.

Data Structures

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

Macros

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

Typedefs

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

Enumerations

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

Functions

static FORCE_INLINE n_coeffType getCoeffType (const coeffs r)
 Returns the type of coeffs domain. More...
 
coeffs nInitChar (n_coeffType t, void *parameter)
 one-time initialisations for new coeffs in case of an error return NULL More...
 
static FORCE_INLINE coeffs nCopyCoeff (const coeffs r)
 "copy" coeffs, i.e. increment ref More...
 
void nKillChar (coeffs r)
 undo all initialisations More...
 
static FORCE_INLINE void nSetChar (const coeffs r)
 initialisations after each ring change More...
 
void nNew (number *a)
 
static FORCE_INLINE int n_GetChar (const coeffs r)
 Return the characteristic of the coeff. domain. More...
 
static FORCE_INLINE number n_Copy (number n, const coeffs r)
 return a copy of 'n' More...
 
static FORCE_INLINE void n_Delete (number *p, const coeffs r)
 delete 'p' More...
 
static FORCE_INLINE BOOLEAN n_Equal (number a, number b, const coeffs r)
 TRUE iff 'a' and 'b' represent the same number; they may have different representations. More...
 
static FORCE_INLINE BOOLEAN n_IsZero (number n, const coeffs r)
 TRUE iff 'n' represents the zero element. More...
 
static FORCE_INLINE BOOLEAN n_IsOne (number n, const coeffs r)
 TRUE iff 'n' represents the one element. More...
 
static FORCE_INLINE BOOLEAN n_IsMOne (number n, const coeffs r)
 TRUE iff 'n' represents the additive inverse of the one element, i.e. -1. More...
 
static FORCE_INLINE BOOLEAN n_GreaterZero (number n, const coeffs r)
 ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0 More...
 
static FORCE_INLINE BOOLEAN n_Greater (number a, number b, const coeffs r)
 ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the long's representing More...
 
static FORCE_INLINE 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...
 
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/n_New are empty operations. More...
 
static FORCE_INLINE BOOLEAN nCoeff_is_algExt (const coeffs r)
 TRUE iff r represents an algebraic extension field. More...
 
static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext (const coeffs r)
 is it an alg. ext. of Q? More...
 
static FORCE_INLINE BOOLEAN nCoeff_is_transExt (const coeffs r)
 TRUE iff r represents a transcendental extension field. More...
 
static FORCE_INLINE void n_ClearContent (ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
 Computes the content and (inplace) divides it out on a collection of numbers number c is the content (i.e. the GCD of all the coeffs, which we divide out inplace) NOTE: it assumes all coefficient numbers to be integer!!! NOTE/TODO: see also the description by Hans TODO: rename into n_ClearIntegerContent. More...
 
static FORCE_INLINE void n_ClearDenominators (ICoeffsEnumerator &numberCollectionEnumerator, number &d, const coeffs r)
 (inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient denominators (i.e. the number with which all the number coeffs. were multiplied) NOTE/TODO: see also the description by Hans More...
 
static FORCE_INLINE void n_ClearContent (ICoeffsEnumerator &numberCollectionEnumerator, const coeffs r)
 
static FORCE_INLINE void n_ClearDenominators (ICoeffsEnumerator &numberCollectionEnumerator, const coeffs r)
 
void n_Print (number &a, const coeffs r)
 print a number (BEWARE of string buffers!) mostly for debugging More...
 
static FORCE_INLINE char * nCoeffString (const coeffs cf)
 TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar. More...
 
static FORCE_INLINE char * nCoeffName (const coeffs cf)
 
static FORCE_INLINE number n_Random (siRandProc p, number p1, number p2, const coeffs cf)
 
static FORCE_INLINE void n_WriteFd (number a, 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...
 
number n_convFactoryNSingN (const CanonicalForm n, const coeffs r)
 
CanonicalForm n_convSingNFactoryN (number n, BOOLEAN setChar, const coeffs r)
 
static FORCE_INLINE void number2mpz (number n, coeffs c, mpz_t m)
 
static FORCE_INLINE number mpz2number (mpz_t m, coeffs c)
 

Variables

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_New

#define n_New (   n,
 
)    nNew(n)

Definition at line 440 of file coeffs.h.

◆ n_Test

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

BOOLEAN n_Test(number a, const coeffs r)

Definition at line 738 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.

108 {
109  n_rep_unknown=0,
110  n_rep_int, /**< (int), see modulop.h */
111  n_rep_gap_rat, /**< (number), see longrat.h */
112  n_rep_gap_gmp, /**< (), see rinteger.h, new impl. */
113  n_rep_poly, /**< (poly), see algext.h */
114  n_rep_rat_fct, /**< (fraction), see transext.h */
115  n_rep_gmp, /**< (mpz_ptr), see rmodulon,h */
116  n_rep_float, /**< (float), see shortfl.h */
117  n_rep_gmp_float, /**< (gmp_float), see */
118  n_rep_gmp_complex,/**< (gmp_complex), see gnumpc.h */
119  n_rep_gf /**< (int), see ffields.h */
120 };
(), see rinteger.h, new impl.
Definition: coeffs.h:112
(fraction), see transext.h
Definition: coeffs.h:114
(poly), see algext.h
Definition: coeffs.h:113
(gmp_complex), see gnumpc.h
Definition: coeffs.h:118
(mpz_ptr), see rmodulon,h
Definition: coeffs.h:115
(number), see longrat.h
Definition: coeffs.h:111
(gmp_float), see
Definition: coeffs.h:117
(int), see modulop.h
Definition: coeffs.h:110
(int), see ffields.h
Definition: coeffs.h:119
(float), see shortfl.h
Definition: coeffs.h:116

◆ n_coeffType

Enumerator
n_unknown 
n_Zp 

{p < 2^31}

n_Q 

rational (GMP) numbers

n_R 

single prescision (6,6) real numbers

n_GF 

{p^n < 2^16}

n_long_R 

real floating point (GMP) numbers

n_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_CF 

?

Definition at line 27 of file coeffs.h.

28 {
29  n_unknown=0,
30  n_Zp, /**< \F{p < 2^31} */
31  n_Q, /**< rational (GMP) numbers */
32  n_R, /**< single prescision (6,6) real numbers */
33  n_GF, /**< \GF{p^n < 2^16} */
34  n_long_R, /**< real floating point (GMP) numbers */
35  n_polyExt, /**< used to represent polys as coeffcients */
36  n_algExt, /**< used for all algebraic extensions, i.e.,
37  the top-most extension in an extension tower
38  is algebraic */
39  n_transExt, /**< used for all transcendental extensions, i.e.,
40  the top-most extension in an extension tower
41  is transcendental */
42  n_long_C, /**< complex floating point (GMP) numbers */
43  n_nTupel, /**< n-tupel of cf: ZZ/p1,... ZZ/pn, R, long_R */
44  n_Z, /**< only used if HAVE_RINGS is defined */
45  n_Zn, /**< only used if HAVE_RINGS is defined */
46  n_Znm, /**< only used if HAVE_RINGS is defined */
47  n_Z2m, /**< only used if HAVE_RINGS is defined */
48  n_CF /**< ? */
49 };
only used if HAVE_RINGS is defined
Definition: coeffs.h:45
?
Definition: coeffs.h:48
only used if HAVE_RINGS is defined
Definition: coeffs.h:47
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:39
rational (GMP) numbers
Definition: coeffs.h:31
{p < 2^31}
Definition: coeffs.h:30
real floating point (GMP) numbers
Definition: coeffs.h:34
single prescision (6,6) real numbers
Definition: coeffs.h:32
only used if HAVE_RINGS is defined
Definition: coeffs.h:46
complex floating point (GMP) numbers
Definition: coeffs.h:42
only used if HAVE_RINGS is defined
Definition: coeffs.h:44
n-tupel of cf: ZZ/p1,...
Definition: coeffs.h:43
{p^n < 2^16}
Definition: coeffs.h:33
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic ...
Definition: coeffs.h:36
used to represent polys as coeffcients
Definition: coeffs.h:35

Function Documentation

◆ getCoeffType()

static FORCE_INLINE n_coeffType getCoeffType ( const coeffs  r)
static

Returns the type of coeffs domain.

Definition at line 421 of file coeffs.h.

422 { assume(r != NULL); return r->type; }
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ mpz2number()

static FORCE_INLINE number mpz2number ( mpz_t  m,
coeffs  c 
)
static

Definition at line 1010 of file coeffs.h.

1010 { return n_InitMPZ(m, c); }
static FORCE_INLINE number n_InitMPZ(mpz_t n, const coeffs r)
conversion of a GMP integer to number
Definition: coeffs.h:542
int m
Definition: cfEzgcd.cc:121

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

657 { STATISTIC(n_Add); assume(r != NULL); assume(r->cfAdd!=NULL); const number sum = r->cfAdd(a, b, r);
658 
659 #ifdef HAVE_NUMSTATS
660  // avoid double counting
661  if( r->cfIsZero(sum,r) ) STATISTIC(n_CancelOut);
662 #endif
663 
664  return sum;
665 }
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of &#39;a&#39; and &#39;b&#39;, i.e., a+b
Definition: coeffs.h:656
#define NULL
Definition: omList.c:12

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

702 { STATISTIC(n_Ann); assume(r != NULL); return r->cfAnn (a,r); }
#define STATISTIC(f)
Definition: numstats.h:16
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 ...
Definition: coeffs.h:701
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

787 { STATISTIC(n_ChineseRemainderSym); assume(r != NULL); assume(r->cfChineseRemainder != NULL); return r->cfChineseRemainder(a,b,rl,sym,inv_cache,r); }
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
Definition: coeffs.h:786
#define NULL
Definition: omList.c:12

◆ n_ClearContent() [1/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 950 of file coeffs.h.

951 { STATISTIC(n_ClearContent); assume(r != NULL); r->cfClearContent(numberCollectionEnumerator, c, r); }
#define STATISTIC(f)
Definition: numstats.h:16
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 ...
Definition: coeffs.h:950
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ n_ClearContent() [2/2]

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

Definition at line 966 of file coeffs.h.

967 { STATISTIC(n_ClearContent); number c; n_ClearContent(numberCollectionEnumerator, c, r); n_Delete(&c, r); }
#define STATISTIC(f)
Definition: numstats.h:16
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 ...
Definition: coeffs.h:950
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:455

◆ n_ClearDenominators() [1/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 957 of file coeffs.h.

958 { STATISTIC(n_ClearDenominators); assume(r != NULL); r->cfClearDenominators(numberCollectionEnumerator, d, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &d, const coeffs r)
(inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient d...
Definition: coeffs.h:957

◆ n_ClearDenominators() [2/2]

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

Definition at line 969 of file coeffs.h.

970 { STATISTIC(n_ClearDenominators); assume(r != NULL); number d; n_ClearDenominators(numberCollectionEnumerator, d, r); n_Delete(&d, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:455
static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &d, const coeffs r)
(inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient d...
Definition: coeffs.h:957

◆ n_CoeffRingQuot1()

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

Definition at line 518 of file coeffs.h.

519 { STATISTIC(n_CoeffRingQuot1); assume(r != NULL); assume(r->cfQuot1 != NULL); return r->cfQuot1(c, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE coeffs n_CoeffRingQuot1(number c, const coeffs r)
Definition: coeffs.h:518

◆ n_CoeffWrite()

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

output the coeff description

Definition at line 741 of file coeffs.h.

742 { STATISTIC(n_CoeffWrite); assume(r != NULL); assume(r->cfCoeffWrite != NULL); r->cfCoeffWrite(r, details); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
Definition: coeffs.h:741
#define NULL
Definition: omList.c:12

◆ n_convFactoryNSingN()

number n_convFactoryNSingN ( const CanonicalForm  n,
const coeffs  r 
)

Definition at line 621 of file numbers.cc.

623 { STATISTIC(n_convFactoryNSingN); assume(r != NULL); assume(r->convFactoryNSingN != NULL); return r->convFactoryNSingN(n, r); }
#define STATISTIC(f)
Definition: numstats.h:16
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:621
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ n_convSingNFactoryN()

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

Definition at line 626 of file numbers.cc.

628 { STATISTIC(n_convSingNFactoryN); assume(r != NULL); assume(r->convSingNFactoryN != NULL); return r->convSingNFactoryN(n, setChar, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: numbers.cc:626

◆ n_Copy()

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

return a copy of 'n'

Definition at line 451 of file coeffs.h.

452 { STATISTIC(n_Copy); assume(r != NULL); assume(r->cfCopy!=NULL); return r->cfCopy(n, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:451

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

728 { STATISTIC(n_Test); assume(r != NULL); assume(r->cfDBTest != NULL); return r->cfDBTest(n, filename, linenumber, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:738
#define NULL
Definition: omList.c:12

◆ n_Delete()

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

delete 'p'

Definition at line 455 of file coeffs.h.

456 { STATISTIC(n_Delete); assume(r != NULL); assume(r->cfDelete!= NULL); r->cfDelete(p, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:455
int p
Definition: cfModGcd.cc:4019

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

616 { STATISTIC(n_Div); assume(r != NULL); assume(r->cfDiv!=NULL); return r->cfDiv(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:615

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

776 { STATISTIC(n_DivBy); assume(r != NULL);
777 #ifdef HAVE_RINGS
778  if( nCoeff_is_Ring(r) )
779  {
780  assume(r->cfDivBy!=NULL); return r->cfDivBy(a,b,r);
781  }
782 #endif
783  return !n_IsZero(b, r);
784 }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:752
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether &#39;a&#39; is divisible &#39;b&#39;; for r encoding a field: TRUE iff &#39;b&#39; does not represent zero in Z:...
Definition: coeffs.h:775
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:464
#define NULL
Definition: omList.c:12

◆ n_DivComp()

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

Definition at line 522 of file coeffs.h.

523 { STATISTIC(n_DivComp); assume(r != NULL); assume(r->cfDivComp!=NULL); return r->cfDivComp (a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE int n_DivComp(number a, number b, const coeffs r)
Definition: coeffs.h:522
#define NULL
Definition: omList.c:12

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

461 { STATISTIC(n_Equal); assume(r != NULL); assume(r->cfEqual!=NULL); return r->cfEqual(a, b, r); }
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff &#39;a&#39; and &#39;b&#39; represent the same number; they may have different representations.
Definition: coeffs.h:460

◆ n_EucNorm()

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

Definition at line 697 of file coeffs.h.

698 { STATISTIC(n_EucNorm); assume(r != NULL); assume(r->cfEucNorm!=NULL); return r->cfEucNorm (a,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_EucNorm(number a, const coeffs r)
Definition: coeffs.h:697
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

623 { STATISTIC(n_ExactDiv); assume(r != NULL); assume(r->cfExactDiv!=NULL); return r->cfExactDiv(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
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 ...
Definition: coeffs.h:622

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

694 { STATISTIC(n_ExtGcd); assume(r != NULL); assume(r->cfExtGcd!=NULL); return r->cfExtGcd (a,b,s,t,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const CanonicalForm int s
Definition: facAbsFact.cc:55
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
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 unexpec...
Definition: coeffs.h:693
#define NULL
Definition: omList.c:12

◆ n_Farey()

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

Definition at line 789 of file coeffs.h.

790 { STATISTIC(n_Farey); assume(r != NULL); assume(r->cfFarey != NULL); return r->cfFarey(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
Definition: coeffs.h:789
#define NULL
Definition: omList.c:12

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

687 { STATISTIC(n_Gcd); assume(r != NULL); assume(r->cfGcd!=NULL); return r->cfGcd(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of &#39;a&#39; and &#39;b&#39; in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ...
Definition: coeffs.h:686
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ n_GetChar()

static FORCE_INLINE int n_GetChar ( const coeffs  r)
static

Return the characteristic of the coeff. domain.

Definition at line 444 of file coeffs.h.

445 { STATISTIC(n_GetChar); assume(r != NULL); return r->ch; }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

604 { STATISTIC(n_GetDenom); assume(r != NULL); assume(r->cfGetDenom!=NULL); return r->cfGetDenom(n, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
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) ...
Definition: coeffs.h:603

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

609 { STATISTIC(n_GetNumerator); assume(r != NULL); assume(r->cfGetNumerator!=NULL); return r->cfGetNumerator(n, r); }
#define STATISTIC(f)
Definition: numstats.h:16
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) ...
Definition: coeffs.h:608
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

533 { STATISTIC(n_GetUnit); assume(r != NULL); assume(r->cfGetUnit!=NULL); return r->cfGetUnit(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
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 i...
Definition: coeffs.h:532
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

512 { STATISTIC(n_Greater); assume(r != NULL); assume(r->cfGreater!=NULL); return r->cfGreater(a,b,r); }
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff &#39;a&#39; is larger than &#39;b&#39;; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
Definition: coeffs.h:511
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

495 { STATISTIC(n_GreaterZero); assume(r != NULL); assume(r->cfGreaterZero!=NULL); return r->cfGreaterZero(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff &#39;n&#39; 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
Definition: coeffs.h:494

◆ n_ImPart()

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

Definition at line 815 of file coeffs.h.

816 { STATISTIC(n_ImPart); assume(cf != NULL); assume(cf->cfImPart!=NULL); return cf->cfImPart(i,cf); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
int i
Definition: cfEzgcd.cc:125
static FORCE_INLINE number n_ImPart(number i, const coeffs cf)
Definition: coeffs.h:815
#define NULL
Definition: omList.c:12

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

539 { STATISTIC(n_Init); assume(r != NULL); assume(r->cfInit!=NULL); return r->cfInit(i,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:538
#define assume(x)
Definition: mod2.h:390
int i
Definition: cfEzgcd.cc:125
#define NULL
Definition: omList.c:12

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

543 { STATISTIC(n_InitMPZ); assume(r != NULL); assume(r->cfInitMPZ != NULL); return r->cfInitMPZ(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE number n_InitMPZ(mpz_t n, const coeffs r)
conversion of a GMP integer to number
Definition: coeffs.h:542
#define NULL
Definition: omList.c:12

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

647 { STATISTIC(n_InpAdd); assume(r != NULL); assume(r->cfInpAdd!=NULL); r->cfInpAdd(a,b,r);
648 
649 #ifdef HAVE_NUMSTATS
650  // avoid double counting
651  if( r->cfIsZero(a,r) ) STATISTIC(n_CancelOut);
652 #endif
653 }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE void n_InpAdd(number &a, number b, const coeffs r)
addition of &#39;a&#39; and &#39;b&#39;; replacement of &#39;a&#39; by the sum a+b
Definition: coeffs.h:646
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

642 { STATISTIC(n_InpMult); assume(r != NULL); assume(r->cfInpMult!=NULL); r->cfInpMult(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
multiplication of &#39;a&#39; and &#39;b&#39;; replacement of &#39;a&#39; by the product a*b
Definition: coeffs.h:641
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

558 { STATISTIC(n_InpNeg); assume(r != NULL); assume(r->cfInpNeg!=NULL); return r->cfInpNeg(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
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)
Definition: coeffs.h:557
#define NULL
Definition: omList.c:12

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

548 { STATISTIC(n_Int); assume(r != NULL); assume(r->cfInt!=NULL); return r->cfInt(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
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 ...
Definition: coeffs.h:547
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

629 { STATISTIC(n_IntMod); assume(r != NULL); return r->cfIntMod(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
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
Definition: coeffs.h:628
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

565 { STATISTIC(n_Invers); assume(r != NULL); assume(r->cfInvers!=NULL); return r->cfInvers(a,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of &#39;a&#39;; raise an error if &#39;a&#39; is not invertible ...
Definition: coeffs.h:564
#define NULL
Definition: omList.c:12

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

473 { STATISTIC(n_IsMOne); assume(r != NULL); assume(r->cfIsMOne!=NULL); return r->cfIsMOne(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE BOOLEAN n_IsMOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the additive inverse of the one element, i.e. -1.
Definition: coeffs.h:472

◆ n_IsOne()

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

TRUE iff 'n' represents the one element.

Definition at line 468 of file coeffs.h.

469 { STATISTIC(n_IsOne); assume(r != NULL); assume(r->cfIsOne!=NULL); return r->cfIsOne(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:468
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

516 { STATISTIC(n_IsUnit); assume(r != NULL); assume(r->cfIsUnit!=NULL); return r->cfIsUnit(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
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.
Definition: coeffs.h:515
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ n_IsZero()

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

TRUE iff 'n' represents the zero element.

Definition at line 464 of file coeffs.h.

465 { STATISTIC(n_IsZero); assume(r != NULL); assume(r->cfIsZero!=NULL); return r->cfIsZero(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:464
#define NULL
Definition: omList.c:12

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

713 { STATISTIC(n_Lcm); assume(r != NULL); assume(r->cfLcm!=NULL); return r->cfLcm(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE number n_Lcm(number a, number b, const coeffs r)
in Z: return the lcm of &#39;a&#39; and &#39;b&#39; in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ...
Definition: coeffs.h:712
#define NULL
Definition: omList.c:12

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

552 { STATISTIC(n_MPZ); assume(r != NULL); assume(r->cfMPZ!=NULL); r->cfMPZ(result, n, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
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
Definition: coeffs.h:551
return result
Definition: facAbsBiFact.cc:76

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

637 { STATISTIC(n_Mult); assume(r != NULL); assume(r->cfMult!=NULL); return r->cfMult(a, b, r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:636
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

579 { STATISTIC(n_Normalize); assume(r != NULL); assume(r->cfNormalize!=NULL); r->cfNormalize(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:578
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

718 { STATISTIC(n_NormalizeHelper); assume(r != NULL); assume(r->cfNormalizeHelper!=NULL); return r->cfNormalizeHelper(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
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...
Definition: coeffs.h:717
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ n_NumberOfParameters()

static FORCE_INLINE int n_NumberOfParameters ( const coeffs  r)
static

Returns the number of parameters.

Definition at line 796 of file coeffs.h.

797 { STATISTIC(n_NumberOfParameters); assume(r != NULL); return r->iNumberOfParameters; }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:796
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

806 { assume(r != NULL);
807  assume((iParameter >= 1) || (iParameter <= n_NumberOfParameters(r)));
808  assume(r->cfParameter != NULL);
809  STATISTIC(n_Param); return r->cfParameter(iParameter, r);
810 }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:796
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(...)
Definition: coeffs.h:805
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

801 { STATISTIC(n_ParameterNames); assume(r != NULL); return r->pParameterNames; }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:800
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ n_ParDeg()

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

Definition at line 792 of file coeffs.h.

793 { STATISTIC(n_ParDeg); assume(r != NULL); assume(r->cfParDeg != NULL); return r->cfParDeg(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE int n_ParDeg(number n, const coeffs r)
Definition: coeffs.h:792
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

633 { STATISTIC(n_Power); assume(r != NULL); assume(r->cfPower!=NULL); r->cfPower(a,b,res,r); }
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
CanonicalForm res
Definition: facAbsFact.cc:64
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
Definition: coeffs.h:632
#define NULL
Definition: omList.c:12

◆ n_Print()

void n_Print ( number &  a,
const coeffs  r 
)

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

Definition at line 610 of file numbers.cc.

612 {
613  assume(r != NULL);
614  n_Test(a,r);
615 
616  StringSetS("");
617  n_Write(a, r);
618  { char* s = StringEndS(); Print("%s", s); omFree(s); }
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define Print
Definition: emacs.cc:80
char * StringEndS()
Definition: reporter.cc:151
#define omFree(addr)
Definition: omAllocDecl.h:261
#define assume(x)
Definition: mod2.h:390
void StringSetS(const char *st)
Definition: reporter.cc:128
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:591
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:738
#define NULL
Definition: omList.c:12

◆ n_QuotRem()

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

Definition at line 703 of file coeffs.h.

704 { STATISTIC(n_QuotRem); assume(r != NULL); assume(r->cfQuotRem!=NULL); return r->cfQuotRem (a,b,q,r); }
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
Definition: coeffs.h:703
#define NULL
Definition: omList.c:12

◆ n_Random()

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

Definition at line 988 of file coeffs.h.

989 { STATISTIC(n_Random); assume( cf != NULL ); assume( cf->cfRandom != NULL ); return cf->cfRandom(p, p1, p2, cf); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_Random(siRandProc p, number p1, number p2, const coeffs cf)
Definition: coeffs.h:988
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
int p
Definition: cfModGcd.cc:4019

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

599 { STATISTIC(n_Read); assume(r != NULL); assume(r->cfRead!=NULL); return r->cfRead(s, a, r); }
#define STATISTIC(f)
Definition: numstats.h:16
const CanonicalForm int s
Definition: facAbsFact.cc:55
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.
Definition: coeffs.h:598
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ n_ReadFd()

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

io via ssi:

Definition at line 996 of file coeffs.h.

997 { STATISTIC(n_ReadFd); assume(r != NULL); assume(r->cfReadFd != NULL); return r->cfReadFd(f, r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE number n_ReadFd(const ssiInfo *f, const coeffs r)
io via ssi:
Definition: coeffs.h:996
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ n_RePart()

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

Definition at line 812 of file coeffs.h.

813 { STATISTIC(n_RePart); assume(cf != NULL); assume(cf->cfRePart!=NULL); return cf->cfRePart(i,cf); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
int i
Definition: cfEzgcd.cc:125
#define NULL
Definition: omList.c:12
static FORCE_INLINE number n_RePart(number i, const coeffs cf)
Definition: coeffs.h:812

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

722 { STATISTIC(n_SetMap); assume(src != NULL && dst != NULL); assume(dst->cfSetMap!=NULL); return dst->cfSetMap(src,dst); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition: coeffs.h:721
#define NULL
Definition: omList.c:12

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

571 { STATISTIC(n_Size); assume(r != NULL); assume(r->cfSize!=NULL); return r->cfSize(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
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 fo...
Definition: coeffs.h:570

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

670 { STATISTIC(n_Sub); assume(r != NULL); assume(r->cfSub!=NULL); const number d = r->cfSub(a, b, r);
671 
672 #ifdef HAVE_NUMSTATS
673  // avoid double counting
674  if( r->cfIsZero(d,r) ) STATISTIC(n_CancelOut);
675 #endif
676 
677  return d;
678 }
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of &#39;a&#39; and &#39;b&#39;, i.e., a-b
Definition: coeffs.h:669
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ n_SubringGcd()

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

Definition at line 688 of file coeffs.h.

689 { STATISTIC(n_SubringGcd); assume(r != NULL); assume(r->cfSubringGcd!=NULL); return r->cfSubringGcd(a,b,r); }
#define STATISTIC(f)
Definition: numstats.h:16
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:688

◆ n_Write()

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

Definition at line 591 of file coeffs.h.

592 { STATISTIC(n_Write); if (bShortOut) n_WriteShort(n, r); else n_WriteLong(n, r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE void n_WriteLong(number n, const coeffs r)
write to the output buffer of the currently used reporter
Definition: coeffs.h:583
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:591
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
Definition: coeffs.h:588

◆ n_WriteFd()

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

io via ssi:

Definition at line 992 of file coeffs.h.

993 { STATISTIC(n_WriteFd); assume(r != NULL); assume(r->cfWriteFd != NULL); return r->cfWriteFd(a, f, r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE void n_WriteFd(number a, const ssiInfo *f, const coeffs r)
io via ssi:
Definition: coeffs.h:992

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

584 { STATISTIC(n_WriteLong); assume(r != NULL); assume(r->cfWriteLong!=NULL); r->cfWriteLong(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE void n_WriteLong(number n, const coeffs r)
write to the output buffer of the currently used reporter
Definition: coeffs.h:583
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

589 { STATISTIC(n_WriteShort); assume(r != NULL); assume(r->cfWriteShort!=NULL); r->cfWriteShort(n,r); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
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
Definition: coeffs.h:588

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

696 { STATISTIC(n_XExtGcd); assume(r != NULL); assume(r->cfXExtGcd!=NULL); return r->cfXExtGcd (a,b,s,t,u,v,r); }
#define STATISTIC(f)
Definition: numstats.h:16
const CanonicalForm int s
Definition: facAbsFact.cc:55
static FORCE_INLINE number n_XExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition: coeffs.h:695
CanonicalForm b
Definition: cfModGcd.cc:4044
#define assume(x)
Definition: mod2.h:390
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:12

◆ nCoeff_has_simple_Alloc()

static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc ( const coeffs  r)
static

TRUE if n_Delete/n_New are empty operations.

Definition at line 928 of file coeffs.h.

929 { assume(r != NULL); return r->has_simple_Alloc; }
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

925 { assume(r != NULL); return r->has_simple_Inverse; }
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

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

820 { assume(r != NULL); return ((getCoeffType(r)==n_Zn) || (getCoeffType(r)==n_Z2m) || (getCoeffType(r)==n_Znm)); }
only used if HAVE_RINGS is defined
Definition: coeffs.h:45
only used if HAVE_RINGS is defined
Definition: coeffs.h:47
only used if HAVE_RINGS is defined
Definition: coeffs.h:46
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

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

933 { assume(r != NULL); return (getCoeffType(r)==n_algExt); }
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic ...
Definition: coeffs.h:36

◆ nCoeff_is_CF()

static FORCE_INLINE BOOLEAN nCoeff_is_CF ( const coeffs  r)
static

Definition at line 919 of file coeffs.h.

920 { assume(r != NULL); return getCoeffType(r)==n_CF; }
?
Definition: coeffs.h:48
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

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

762 {
763  assume(r != NULL);
764  return (r->is_domain);
765 }
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ nCoeff_is_Extension()

static FORCE_INLINE BOOLEAN nCoeff_is_Extension ( const coeffs  r)
static

Definition at line 868 of file coeffs.h.

869 {
870  assume(r != NULL);
871  return (getCoeffType(r)==n_algExt) || (getCoeffType(r)==n_transExt);
872 }
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:39
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic ...
Definition: coeffs.h:36

◆ nCoeff_is_GF() [1/2]

static FORCE_INLINE BOOLEAN nCoeff_is_GF ( const coeffs  r)
static

Definition at line 861 of file coeffs.h.

862 { assume(r != NULL); return getCoeffType(r)==n_GF; }
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12
{p^n < 2^16}
Definition: coeffs.h:33

◆ nCoeff_is_GF() [2/2]

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

Definition at line 864 of file coeffs.h.

865 { assume(r != NULL); return (getCoeffType(r)==n_GF) && (r->ch == q); }
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12
{p^n < 2^16}
Definition: coeffs.h:33

◆ nCoeff_is_long_C()

static FORCE_INLINE BOOLEAN nCoeff_is_long_C ( const coeffs  r)
static

Definition at line 916 of file coeffs.h.

917 { assume(r != NULL); return getCoeffType(r)==n_long_C; }
#define assume(x)
Definition: mod2.h:390
complex floating point (GMP) numbers
Definition: coeffs.h:42
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

◆ nCoeff_is_long_R()

static FORCE_INLINE BOOLEAN nCoeff_is_long_R ( const coeffs  r)
static

Definition at line 913 of file coeffs.h.

914 { assume(r != NULL); return getCoeffType(r)==n_long_R; }
real floating point (GMP) numbers
Definition: coeffs.h:34
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

◆ nCoeff_is_numeric()

static FORCE_INLINE BOOLEAN nCoeff_is_numeric ( const coeffs  r)
static

Definition at line 854 of file coeffs.h.

855 { assume(r != NULL); return (getCoeffType(r)==n_R) || (getCoeffType(r)==n_long_R) || (getCoeffType(r)==n_long_C); }
real floating point (GMP) numbers
Definition: coeffs.h:34
single prescision (6,6) real numbers
Definition: coeffs.h:32
#define assume(x)
Definition: mod2.h:390
complex floating point (GMP) numbers
Definition: coeffs.h:42
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

◆ nCoeff_is_Q()

static FORCE_INLINE BOOLEAN nCoeff_is_Q ( const coeffs  r)
static

Definition at line 828 of file coeffs.h.

829 {
830  assume(r != NULL);
831  #if SI_INTEGER_VARIANT==1
832  return getCoeffType(r)==n_Q && (r->is_field);
833  #else
834  return getCoeffType(r)==n_Q;
835  #endif
836 }
rational (GMP) numbers
Definition: coeffs.h:31
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

◆ nCoeff_is_Q_a()

static FORCE_INLINE BOOLEAN nCoeff_is_Q_a ( const coeffs  r)
static

Definition at line 907 of file coeffs.h.

908 {
909  assume(r != NULL);
910  return ((n_GetChar(r) == 0) && nCoeff_is_Extension(r));
911 }
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:868

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

937 { assume(r != NULL); return ((n_GetChar(r) == 0) && nCoeff_is_algExt(r)); }
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:932
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ nCoeff_is_Q_or_BI()

static FORCE_INLINE BOOLEAN nCoeff_is_Q_or_BI ( const coeffs  r)
static

Definition at line 851 of file coeffs.h.

852 { assume(r != NULL); return getCoeffType(r)==n_Q; }
rational (GMP) numbers
Definition: coeffs.h:31
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

◆ nCoeff_is_R()

static FORCE_INLINE BOOLEAN nCoeff_is_R ( const coeffs  r)
static

Definition at line 858 of file coeffs.h.

859 { assume(r != NULL); return getCoeffType(r)==n_R; }
single prescision (6,6) real numbers
Definition: coeffs.h:32
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

◆ nCoeff_is_Ring()

static FORCE_INLINE BOOLEAN nCoeff_is_Ring ( const coeffs  r)
static

Definition at line 752 of file coeffs.h.

753 { assume(r != NULL); return (r->is_field==0); }
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ nCoeff_is_Ring_2toM()

static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM ( const coeffs  r)
static

Definition at line 746 of file coeffs.h.

747 { assume(r != NULL); return (getCoeffType(r)==n_Z2m); }
only used if HAVE_RINGS is defined
Definition: coeffs.h:47
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

◆ nCoeff_is_Ring_PtoM()

static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM ( const coeffs  r)
static

Definition at line 749 of file coeffs.h.

750 { assume(r != NULL); return (getCoeffType(r)==n_Znm); }
only used if HAVE_RINGS is defined
Definition: coeffs.h:46
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

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

941 { assume(r != NULL); return (getCoeffType(r)==n_transExt); }
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:39
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

◆ nCoeff_is_Z()

static FORCE_INLINE BOOLEAN nCoeff_is_Z ( const coeffs  r)
static

Definition at line 838 of file coeffs.h.

839 {
840  assume(r != NULL);
841  #if SI_INTEGER_VARIANT==1
842  return ((getCoeffType(r)==n_Q) && (!r->is_field));
843  #else
844  return getCoeffType(r)==n_Z;
845  #endif
846 }
rational (GMP) numbers
Definition: coeffs.h:31
#define assume(x)
Definition: mod2.h:390
only used if HAVE_RINGS is defined
Definition: coeffs.h:44
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

◆ nCoeff_is_Zn()

static FORCE_INLINE BOOLEAN nCoeff_is_Zn ( const coeffs  r)
static

Definition at line 848 of file coeffs.h.

849 { assume(r != NULL); return getCoeffType(r)==n_Zn; }
only used if HAVE_RINGS is defined
Definition: coeffs.h:45
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

◆ nCoeff_is_Zp() [1/2]

static FORCE_INLINE BOOLEAN nCoeff_is_Zp ( const coeffs  r)
static

Definition at line 822 of file coeffs.h.

823 { assume(r != NULL); return getCoeffType(r)==n_Zp; }
{p < 2^31}
Definition: coeffs.h:30
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12

◆ nCoeff_is_Zp() [2/2]

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

Definition at line 825 of file coeffs.h.

826 { assume(r != NULL); return ((getCoeffType(r)==n_Zp) && (r->ch == p)); }
{p < 2^31}
Definition: coeffs.h:30
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
#define NULL
Definition: omList.c:12
int p
Definition: cfModGcd.cc:4019

◆ nCoeff_is_Zp_a() [1/2]

static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a ( const coeffs  r)
static

Definition at line 881 of file coeffs.h.

882 {
883  assume(r != NULL);
884  return ((!nCoeff_is_Ring(r)) && (n_GetChar(r) != 0) && nCoeff_is_Extension(r));
885 }
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:752
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:868

◆ nCoeff_is_Zp_a() [2/2]

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

Definition at line 894 of file coeffs.h.

895 {
896  assume(r != NULL);
897  assume(p != 0);
898  return ((!nCoeff_is_Ring(r)) && (n_GetChar(r) == p) && nCoeff_is_Extension(r));
899 }
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:752
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:868
int p
Definition: cfModGcd.cc:4019

◆ nCoeffName()

static FORCE_INLINE char* nCoeffName ( const coeffs  cf)
static

Definition at line 985 of file coeffs.h.

986 { STATISTIC(nCoeffName); assume( cf != NULL ); return cf->cfCoeffName(cf); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
static FORCE_INLINE char * nCoeffName(const coeffs cf)
Definition: coeffs.h:985
#define NULL
Definition: omList.c:12

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

982 { STATISTIC(nCoeffString); assume( cf != NULL ); return cf->cfCoeffString(cf); }
#define STATISTIC(f)
Definition: numstats.h:16
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar...
Definition: coeffs.h:981

◆ nCopyCoeff()

static FORCE_INLINE coeffs nCopyCoeff ( const coeffs  r)
static

"copy" coeffs, i.e. increment ref

Definition at line 429 of file coeffs.h.

430 { assume(r!=NULL); r->ref++; return r;}
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ nInitChar()

coeffs nInitChar ( n_coeffType  t,
void *  parameter 
)

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

Definition at line 349 of file numbers.cc.

351 {
352  n_Procs_s *n=cf_root;
353 
354  while((n!=NULL) && (n->nCoeffIsEqual!=NULL) && (!n->nCoeffIsEqual(n,t,parameter)))
355  n=n->next;
356 
357  if (n==NULL)
358  {
359  n=(n_Procs_s*)omAlloc0(sizeof(n_Procs_s));
360  n->next=cf_root;
361  n->ref=1;
362  n->type=t;
363 
364  // default entries (different from NULL) for some routines:
366  n->cfSize = ndSize;
369  n->cfImPart=ndReturn0;
370  n->cfDelete= ndDelete;
371  n->cfAnn = ndAnn;
372  n->cfCoeffString = ndCoeffString; // should alway be changed!
373  n->cfCoeffName = ndCoeffName; // should alway be changed!
374  n->cfInpMult=ndInpMult;
375  n->cfInpAdd=ndInpAdd;
376  n->cfCopy = ndCopy;
377  n->cfIntMod=ndIntMod; /* dummy !! */
379  n->cfGcd = ndGcd;
380  n->cfNormalizeHelper = ndGcd; /* tricky, isn't it ?*/
381  n->cfLcm = ndGcd; /* tricky, isn't it ?*/
382  n->cfInitMPZ = ndInitMPZ;
383  n->cfMPZ = ndMPZ;
384  n->cfPower = ndPower;
385  n->cfQuotRem = ndQuotRem;
386  n->cfInvers = ndInvers;
387 
388  n->cfKillChar = ndKillChar; /* dummy */
389  n->cfSetChar = ndSetChar; /* dummy */
390  // temp. removed to catch all the coeffs which miss to implement this!
391 
393  n->cfFarey = ndFarey;
394  n->cfParDeg = ndParDeg;
395 
397 
400 
401  n->cfIsUnit = ndIsUnit;
402 #ifdef HAVE_RINGS
403  n->cfDivComp = ndDivComp;
404  n->cfDivBy = ndDivBy;
405  n->cfExtGcd = ndExtGcd;
406  //n->cfGetUnit = (nMapFunc)NULL;
407 #endif
408 
409 #ifdef LDEBUG
410  n->cfDBTest=ndDBTest;
411 #endif
412 
415 
416  BOOLEAN nOK=TRUE;
417  // init
418  if ((t<=nLastCoeffs) && (nInitCharTable[t]!=NULL))
419  nOK = (nInitCharTable[t])(n,parameter);
420  else
421  Werror("Sorry: the coeff type [%d] was not registered: it is missing in nInitCharTable", (int)t);
422  if (nOK)
423  {
424  omFreeSize(n,sizeof(*n));
425  return NULL;
426  }
427  cf_root=n;
428  // post init settings:
429  if (n->cfRePart==NULL) n->cfRePart=n->cfCopy;
430  if (n->cfExactDiv==NULL) n->cfExactDiv=n->cfDiv;
431  if (n->cfSubringGcd==NULL) n->cfSubringGcd=n->cfGcd;
432 
433 #ifdef HAVE_RINGS
434  if (n->cfGetUnit==NULL) n->cfGetUnit=n->cfCopy;
435 #endif
436 
437  if(n->cfWriteShort==NULL)
438  n->cfWriteShort = n->cfWriteLong;
439 
441  assume(n->cfSetChar!=NULL);
444  assume(n->cfMult!=NULL);
445  assume(n->cfSub!=NULL);
446  assume(n->cfAdd!=NULL);
447  assume(n->cfDiv!=NULL);
448  assume(n->cfIntMod!=NULL);
449  assume(n->cfExactDiv!=NULL);
450  assume(n->cfInit!=NULL);
451  assume(n->cfInitMPZ!=NULL);
452  assume(n->cfSize!=NULL);
453  assume(n->cfInt!=NULL);
454  assume(n->cfMPZ!=NULL);
455  //assume(n->n->cfDivComp!=NULL);
456  //assume(n->cfIsUnit!=NULL);
457  //assume(n->cfGetUnit!=NULL);
458  //assume(n->cfExtGcd!=NULL);
459  assume(n->cfInpNeg!=NULL);
460  assume(n->cfCopy!=NULL);
461 
462  assume(n->cfWriteLong!=NULL);
463  assume(n->cfWriteShort!=NULL);
464 
465  assume(n->iNumberOfParameters>= 0);
466 
467  assume( (n->iNumberOfParameters == 0 && n->pParameterNames == NULL) ||
468  (n->iNumberOfParameters > 0 && n->pParameterNames != NULL) );
469 
470  assume(n->cfParameter!=NULL);
471  assume(n->cfParDeg!=NULL);
472 
473  assume(n->cfRead!=NULL);
474  assume(n->cfNormalize!=NULL);
475  assume(n->cfGreater!=NULL);
476  //assume(n->cfDivBy!=NULL);
477  assume(n->cfEqual!=NULL);
478  assume(n->cfIsZero!=NULL);
479  assume(n->cfIsOne!=NULL);
480  assume(n->cfIsMOne!=NULL);
482  assume(n->cfGetDenom!=NULL);
484  assume(n->cfGcd!=NULL);
486  assume(n->cfDelete!=NULL);
487  assume(n->cfSetMap!=NULL);
488  assume(n->cfInpMult!=NULL);
489 // assume(n->cfInit_bigint!=NULL);
490  assume(n->cfCoeffWrite != NULL);
491 
492  assume(n->cfClearContent != NULL);
494 
495  assume(n->type==t);
496 
497 #ifndef SING_NDEBUG
498  if(n->cfKillChar==NULL) Warn("cfKillChar is NULL for coeff %d",t);
499  if(n->cfWriteLong==NULL) Warn("cfWrite is NULL for coeff %d",t);
500  if(n->cfWriteShort==NULL) Warn("cfWriteShort is NULL for coeff %d",t);
501  if(n->cfCoeffString==ndCoeffString) Warn("cfCoeffString is undefined for coeff %d",t);
502 #endif
503  }
504  else
505  {
506  n->ref++;
507  }
508  return n;
static BOOLEAN ndIsUnit(number a, const coeffs r)
Definition: numbers.cc:117
BOOLEAN(* cfDivBy)(number a, number b, const coeffs r)
Definition: coeffs.h:381
number(* cfCopy)(number a, const coeffs r)
return a copy of a
Definition: coeffs.h:199
number(* cfExtGcd)(number a, number b, number *s, number *t, const coeffs r)
Definition: coeffs.h:248
numberfunc cfIntMod
Definition: coeffs.h:175
int(* cfDivComp)(number a, number b, const coeffs r)
Definition: coeffs.h:377
static void ndPower(number a, int i, number *res, const coeffs r)
Definition: numbers.cc:79
static number ndParameter(const int, const coeffs r)
Definition: numbers.cc:139
number ndGcd(number, number, const coeffs r)
Definition: numbers.cc:161
static void ndKillChar(coeffs)
Definition: numbers.cc:261
static number ndQuotRem(number a, number b, number *r, const coeffs R)
Definition: numbers.cc:305
static BOOLEAN ndDBTest(number, const char *, const int, const coeffs)
Definition: numbers.cc:120
BOOLEAN(* cfDBTest)(number a, const char *f, const int l, const coeffs r)
Test: is "a" a correct number?
Definition: coeffs.h:415
void(* cfMPZ)(mpz_t result, number &n, const coeffs r)
Converts a non-negative number n into a GMP number, 0 if impossible.
Definition: coeffs.h:190
void(* cfSetChar)(const coeffs r)
Definition: coeffs.h:161
static BOOLEAN ndDivBy(number, number, const coeffs)
Definition: numbers.cc:267
VAR n_Procs_s * cf_root
Definition: numbers.cc:48
number(* cfQuotRem)(number a, number b, number *rem, const coeffs r)
Definition: coeffs.h:269
char const ** pParameterNames
array containing the names of Parameters (default NULL)
Definition: coeffs.h:322
coeffs next
Definition: coeffs.h:125
static number ndInvers(number a, const coeffs r)
Definition: numbers.cc:109
static number ndCopy(number a, const coeffs)
Definition: numbers.cc:250
static number ndChineseRemainder(number *, number *, int, BOOLEAN, CFArray &, const coeffs r)
Definition: numbers.cc:128
void(* cfDelete)(number *a, const coeffs r)
Definition: coeffs.h:272
static void ndNormalize(number &, const coeffs)
Definition: numbers.cc:159
BOOLEAN(*)(*)(*)(*) cfIsOne(number a, const coeffs r)
Definition: coeffs.h:229
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
number(* cfSubringGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:247
static number ndConvFactoryNSingN(const CanonicalForm, const coeffs)
[in, out] a bigint number >= 0
Definition: numbers.cc:279
numberfunc cfAdd
Definition: coeffs.h:175
number(* cfInvers)(number a, const coeffs r)
return 1/a
Definition: coeffs.h:197
BOOLEAN(* cfGreater)(number a, number b, const coeffs r)
Definition: coeffs.h:225
void(* cfNormalize)(number &a, const coeffs r)
Definition: coeffs.h:223
static char * ndCoeffString(const coeffs r)
Definition: numbers.cc:55
number(* cfRePart)(number a, const coeffs r)
Definition: coeffs.h:200
#define TRUE
Definition: auxiliary.h:100
static void ndDelete(number *d, const coeffs)
Definition: numbers.cc:53
static int ndDivComp(number, number, const coeffs)
Definition: numbers.cc:268
void(* cfCoeffWrite)(const coeffs r, BOOLEAN details)
output of coeff description via Print
Definition: coeffs.h:148
static char * ndCoeffName(const coeffs r)
Definition: numbers.cc:60
BOOLEAN(* cfIsUnit)(number a, const coeffs r)
Definition: coeffs.h:378
number(* cfGetUnit)(number a, const coeffs r)
Definition: coeffs.h:379
number(* cfFarey)(number p, number n, const coeffs)
rational reconstruction: "best" rational a/b with a/b = p mod n
Definition: coeffs.h:291
number(* cfInitMPZ)(mpz_t i, const coeffs r)
init with a GMP integer
Definition: coeffs.h:181
char *(* cfCoeffString)(const coeffs r)
string output of coeff description
Definition: coeffs.h:151
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
BOOLEAN(* nCoeffIsEqual)(const coeffs r, n_coeffType n, void *parameter)
Definition: coeffs.h:145
static number ndReturn0(number, const coeffs r)
Definition: numbers.cc:160
static void ndInpMult(number &a, number b, const coeffs r)
Definition: numbers.cc:66
number(* cfInit)(long i, const coeffs r)
init with an integer
Definition: coeffs.h:178
number(* cfNormalizeHelper)(number a, number b, const coeffs r)
Definition: coeffs.h:271
static number ndInitMPZ(mpz_t m, const coeffs r)
Definition: numbers.cc:292
static int ndParDeg(number n, const coeffs r)
Definition: numbers.cc:134
BOOLEAN(*)(*)(*)(*)(*)(*) cfGreaterZero(number a, const coeffs r)
Definition: coeffs.h:237
long(* cfInt)(number &n, const coeffs r)
convertion to long, 0 if impossible
Definition: coeffs.h:187
void(* cfInpMult)(number &a, number b, const coeffs r)
Inplace: a *= b.
Definition: coeffs.h:281
numberfunc cfSub
Definition: coeffs.h:175
static void ndClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Definition: numbers.cc:167
static number ndGetDenom(number &, const coeffs r)
Definition: numbers.cc:163
number(* cfImPart)(number a, const coeffs r)
Definition: coeffs.h:201
#define assume(x)
Definition: mod2.h:390
number(* cfInpNeg)(number a, const coeffs r)
changes argument inline: a:= -a return -a! (no copy is returned) the result should be assigned to the...
Definition: coeffs.h:195
static int ndSize(number a, const coeffs r)
Definition: numbers.cc:165
STATIC_VAR cfInitCharProc * nInitCharTable
Definition: numbers.cc:345
int ref
Definition: coeffs.h:126
void(* cfPower)(number a, int i, number *result, const coeffs r)
Definition: coeffs.h:239
nCoeffsEnumeratorFunc cfClearContent
function pointer behind n_ClearContent
Definition: coeffs.h:309
numberfunc cfExactDiv
Definition: coeffs.h:175
static BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void *)
Definition: numbers.cc:298
n_coeffType type
Definition: coeffs.h:128
numberfunc cfDiv
Definition: coeffs.h:175
const char *(* cfRead)(const char *s, number *a, const coeffs r)
Definition: coeffs.h:221
numberfunc cfMult
Definition: coeffs.h:175
STATIC_VAR n_coeffType nLastCoeffs
Definition: numbers.cc:312
static number ndExtGcd(number, number, number *, number *, const coeffs r)
Definition: numbers.cc:269
#define NULL
Definition: omList.c:12
void(* cfWriteLong)(number a, const coeffs r)
print a given number (long format)
Definition: coeffs.h:204
number(* cfGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:246
static void ndSetChar(const coeffs)
Definition: numbers.cc:262
number(* cfLcm)(number a, number b, const coeffs r)
Definition: coeffs.h:270
static void ndInpAdd(number &a, number b, const coeffs r)
Definition: numbers.cc:72
number(* convFactoryNSingN)(const CanonicalForm n, const coeffs r)
conversion to CanonicalForm(factory) to number
Definition: coeffs.h:315
number(* cfChineseRemainder)(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs)
chinese remainder returns X with X mod q[i]=x[i], i=0..rl-1
Definition: coeffs.h:297
static number ndGetNumerator(number &a, const coeffs r)
Definition: numbers.cc:164
static number ndAnn(number, const coeffs)
Definition: numbers.cc:54
static number ndIntMod(number, number, const coeffs r)
Definition: numbers.cc:162
static number ndFarey(number, number, const coeffs r)
Definition: numbers.cc:123
static void ndClearDenominators(ICoeffsEnumerator &, number &d, const coeffs r)
Definition: numbers.cc:241
nMapFunc(* cfSetMap)(const coeffs src, const coeffs dst)
Definition: coeffs.h:275
char *(* cfCoeffName)(const coeffs r)
default name of cf, should substitue cfCoeffWrite, cfCoeffString
Definition: coeffs.h:154
int(* cfSize)(number n, const coeffs r)
how complicated, (0) => 0, or positive
Definition: coeffs.h:184
number(* cfAnn)(number a, const coeffs r)
Definition: coeffs.h:261
number(* cfParameter)(const int i, const coeffs r)
create i^th parameter or NULL if not possible
Definition: coeffs.h:303
BOOLEAN(*)(*)(*)(*)(*) cfIsMOne(number a, const coeffs r)
Definition: coeffs.h:232
CanonicalForm(* convSingNFactoryN)(number n, BOOLEAN setChar, const coeffs r)
Definition: coeffs.h:316
void(* cfKillChar)(coeffs r)
Definition: coeffs.h:159
int BOOLEAN
Definition: auxiliary.h:87
static void ndMPZ(mpz_t result, number &n, const coeffs r)
Converts a non-negative bigint number into a GMP number.
Definition: numbers.cc:287
void Werror(const char *fmt,...)
Definition: reporter.cc:189
void(* cfInpAdd)(number &a, number b, const coeffs r)
Inplace: a += b.
Definition: coeffs.h:284
number(* cfGetNumerator)(number &n, const coeffs r)
Definition: coeffs.h:241
void(* cfWriteShort)(number a, const coeffs r)
print a given number in a shorter way, if possible e.g. in K(a): a2 instead of a^2 ...
Definition: coeffs.h:208
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int iNumberOfParameters
Number of Parameters in the coeffs (default 0)
Definition: coeffs.h:319
number(* cfGetDenom)(number &n, const coeffs r)
Definition: coeffs.h:240
BOOLEAN(*)(*)(*) cfIsZero(number a, const coeffs r)
Definition: coeffs.h:228
BOOLEAN(*)(*) cfEqual(number a, number b, const coeffs r)
tests
Definition: coeffs.h:227
nCoeffsEnumeratorFunc cfClearDenominators
function pointer behind n_ClearDenominators
Definition: coeffs.h:312
#define Warn
Definition: emacs.cc:77
int(* cfParDeg)(number x, const coeffs r)
degree for coeffcients: -1 for 0, 0 for "constants", ...
Definition: coeffs.h:300

◆ nKillChar()

void nKillChar ( coeffs  r)

undo all initialisations

Definition at line 510 of file numbers.cc.

512 {
514  if (r!=NULL)
515  {
516  r->ref--;
517  if (r->ref<=0)
518  {
519  n_Procs_s tmp;
520  n_Procs_s* n=&tmp;
521  tmp.next=cf_root;
522  while((n->next!=NULL) && (n->next!=r)) n=n->next;
523  if (n->next==r)
524  {
525  n->next=n->next->next;
526  if (cf_root==r) cf_root=n->next;
527  assume (r->cfKillChar!=NULL); r->cfKillChar(r); // STATISTIC(nKillChar);
528  omFreeSize((void *)r, sizeof(n_Procs_s));
529  r=NULL;
530  }
531  else
532  {
533  WarnS("cf_root list destroyed");
534  }
535  }
536  }
#define STATISTIC(f)
Definition: numstats.h:16
VAR n_Procs_s * cf_root
Definition: numbers.cc:48
coeffs next
Definition: coeffs.h:125
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define WarnS
Definition: emacs.cc:78
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:510
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ nNew()

void nNew ( number *  a)

Definition at line 50 of file numbers.cc.

50 { *d=NULL; }
#define NULL
Definition: omList.c:12

◆ nSetChar()

static FORCE_INLINE void nSetChar ( const coeffs  r)
static

initialisations after each ring change

Definition at line 436 of file coeffs.h.

437 { STATISTIC(nSetChar); assume(r!=NULL); assume(r->cfSetChar != NULL); r->cfSetChar(r); }
#define STATISTIC(f)
Definition: numstats.h:16
static FORCE_INLINE void nSetChar(const coeffs r)
initialisations after each ring change
Definition: coeffs.h:436
#define assume(x)
Definition: mod2.h:390
#define NULL
Definition: omList.c:12

◆ number2mpz()

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

Definition at line 1009 of file coeffs.h.

1009 { n_MPZ(m, n, c); }
int m
Definition: cfEzgcd.cc:121
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
Definition: coeffs.h:551

Variable Documentation

◆ fftable

const unsigned short fftable[]

Definition at line 30 of file ffields.cc.

◆ rnumber_bin

EXTERN_VAR omBin rnumber_bin

Definition at line 84 of file coeffs.h.