15 #include "factory/factory.h" 36 #ifdef HAVE_POLYEXTENSIONS 43 struct SNumberStatistic number_stats;
58 char *
s=(
char *)
omAlloc(11);snprintf(
s,11,
"Coeffs(%d)",r->type);
64 snprintf(
s,11,
"Coeffs(%d)",r->type);
69 number n=r->cfMult(a,
b,r);
75 number n=r->cfAdd(a,
b,r);
84 *
res = r->cfInit(1, r);
88 *
res = r->cfCopy(a, r);
92 *
res = r->cfMult(a, a, r);
96 number
b = r->cfInvers(a, r);
103 r->cfInpMult(*
res, *
res, r);
106 r->cfInpMult(*
res, a, r);
112 number one=r->cfInit(1,r);
113 number
res=r->cfDiv(one,a,r);
131 Werror(
"ChineseRemainder not implemented for %s (c=%d)",r->cfCoeffString(r),
getCoeffType(r));
132 return r->cfInit(0,r);
137 return (-r->cfIsZero(n,r));
142 Werror(
"ndParameter: n_Parameter is not implemented/relevant for (coeff_type = %d)",
getCoeffType(r));
150 if (ret || (c==0) || (r->is_field))
152 number ch =
n_Init( c, r );
153 number
g =
n_Gcd( ch, a, r );
162 number
ndGcd(number, number,
const coeffs r) {
return r->cfInit(1,r); }
163 static number
ndIntMod(number, number,
const coeffs r) {
return r->cfInit(0,r); }
176 numberCollectionEnumerator.
Reset();
178 if( !numberCollectionEnumerator.
MoveNext() )
184 number &curr = numberCollectionEnumerator.
Current();
200 while( numberCollectionEnumerator.
MoveNext() )
202 number &n = numberCollectionEnumerator.
Current();
228 while( numberCollectionEnumerator.
MoveNext() )
230 number &n = numberCollectionEnumerator.
Current();
255 assume(aRing->rep==r->rep);
259 return r->cfCopy(a, r);
270 static number
ndExtGcd (number, number, number *, number *,
const coeffs r) {
return r->cfInit(1,r); }
276 WerrorS(
"no conversion to factory");
282 WerrorS(
"no conversion from factory");
291 mpz_init_set_si(
result, r->cfInt(n, r) );
296 return r->cfInit( mpz_get_si(
m), r);
322 #ifdef HAVE_POLYEXTENSIONS 422 Werror(
"Sorry: the coeff type [%d] was not registered: it is missing in nInitCharTable", (
int)t);
528 assume (r->cfKillChar!=
NULL); r->cfKillChar(r);
534 WarnS(
"cf_root list destroyed");
577 nFindCoeffByName_p
next;
583 nFindCoeffByName_p
h=(nFindCoeffByName_p)
omAlloc0(
sizeof(*
h));
597 && (strcmp(cf_name,n->
cfCoeffName(n))==0))
return n;
635 if (((*
s) >=
'0') && ((*
s) <=
'9'))
644 while (((*
s) >=
'0') && ((*
s) <=
'9'));
645 if ((
m!=0) && (ii>=
m)) ii=ii%
m;
655 const char * start=
s;
657 while (*
s >=
'0' && *
s <=
'9')
s++;
660 mpz_set_str(
i,start,10);
666 mpz_set_str(
i,start,10);
number nd_Copy(number a, const coeffs r)
static BOOLEAN ndIsUnit(number a, const coeffs r)
void n_Print(number &a, const coeffs r)
print a number (BEWARE of string buffers!) mostly for debugging
BOOLEAN(* cfDivBy)(number a, number b, const coeffs r)
BOOLEAN nrInitChar(coeffs n, void *p)
Initialize 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 i...
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,...
const CanonicalForm int s
number(* cfCopy)(number a, const coeffs r)
return a copy of a
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
number(* cfExtGcd)(number a, number b, number *s, number *t, const coeffs r)
int(* cfDivComp)(number a, number b, const coeffs r)
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
static void ndPower(number a, int i, number *res, const coeffs r)
static number ndParameter(const int, const coeffs r)
number ndGcd(number, number, const coeffs r)
static void ndKillChar(coeffs)
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
static number ndQuotRem(number a, number b, number *r, const coeffs R)
static BOOLEAN ndDBTest(number, const char *, const int, const coeffs)
BOOLEAN(* cfDBTest)(number a, const char *f, const int l, const coeffs r)
Test: is "a" a correct number?
void(* cfMPZ)(mpz_t result, number &n, const coeffs r)
Converts a non-negative number n into a GMP number, 0 if impossible.
void(* cfSetChar)(const coeffs r)
BOOLEAN naInitChar(coeffs cf, void *infoStruct)
Initialize the coeffs object.
static BOOLEAN ndDivBy(number, number, const coeffs)
number(* cfQuotRem)(number a, number b, number *rem, const coeffs r)
static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
multiplication of 'a' and 'b'; replacement of 'a' by the product a*b
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
char const ** pParameterNames
array containing the names of Parameters (default NULL)
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
static number ndInvers(number a, const coeffs r)
static number ndCopy(number a, const coeffs)
static n_coeffType nLastCoeffs
static number ndChineseRemainder(number *, number *, int, BOOLEAN, CFArray &, const coeffs r)
void(* cfDelete)(number *a, const coeffs r)
static void ndNormalize(number &, const coeffs)
BOOLEAN(*)(*)(*)(*) cfIsOne(number a, const coeffs r)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
#define omFreeSize(addr, size)
number(* cfSubringGcd)(number a, number b, const coeffs r)
char * nEati(char *s, int *i, int m)
divide by the first (leading) number and return it, i.e. make monic
BOOLEAN n_IsZeroDivisor(number a, const coeffs r)
Test whether a is a zero divisor in r i.e. not coprime with char. of r very inefficient implementatio...
static number ndConvFactoryNSingN(const CanonicalForm, const coeffs)
[in, out] a bigint number >= 0
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
number(* cfInvers)(number a, const coeffs r)
return 1/a
BOOLEAN(* cfGreater)(number a, number b, const coeffs r)
void(* cfNormalize)(number &a, const coeffs r)
static char * ndCoeffString(const coeffs r)
number(* cfRePart)(number a, const coeffs r)
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
nFindCoeffByName_p nFindCoeffByName_Root
static void ndDelete(number *d, const coeffs)
static int ndDivComp(number, number, const coeffs)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
void(* cfCoeffWrite)(const coeffs r, BOOLEAN details)
output of coeff description via Print
void WerrorS(const char *s)
BOOLEAN nr2mInitChar(coeffs r, void *p)
static char * ndCoeffName(const coeffs r)
BOOLEAN(* cfIsUnit)(number a, const coeffs r)
number(* cfGetUnit)(number a, const coeffs r)
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
number(* cfFarey)(number p, number n, const coeffs)
rational reconstruction: "best" rational a/b with a/b = p mod n
BOOLEAN npInitChar(coeffs r, void *p)
BOOLEAN nlInitChar(coeffs r, void *p)
number(* cfInitMPZ)(mpz_t i, const coeffs r)
init with a GMP integer
char *(* cfCoeffString)(const coeffs r)
string output of coeff description
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
BOOLEAN n2pInitChar(coeffs cf, void *infoStruct)
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
BOOLEAN(* nCoeffIsEqual)(const coeffs r, n_coeffType n, void *parameter)
static number ndReturn0(number, const coeffs r)
static void ndInpMult(number &a, number b, const coeffs r)
virtual void Reset()=0
Sets the enumerator to its initial position: -1, which is before the first element in the collection.
#define omReallocSize(addr, o_size, size)
void nRegisterCfByName(cfInitCfByNameProc p, n_coeffType n)
number(* cfInit)(long i, const coeffs r)
init with an integer
number(* cfNormalizeHelper)(number a, number b, const coeffs r)
BOOLEAN(* cfInitCharProc)(coeffs, void *)
initialize an object of type coeff, return FALSE in case of success
static number ndInitMPZ(mpz_t m, const coeffs r)
BOOLEAN ngcInitChar(coeffs n, void *parameter)
Initialize r (n_long_C)
static int ndParDeg(number n, const coeffs r)
Coefficient rings, fields and other domains suitable for Singular polynomials.
BOOLEAN(*)(*)(*)(*)(*)(*) cfGreaterZero(number a, const coeffs r)
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
long(* cfInt)(number &n, const coeffs r)
convertion to long, 0 if impossible
void(* cfInpMult)(number &a, number b, const coeffs r)
Inplace: a *= b.
n_coeffType nRegister(n_coeffType n, cfInitCharProc p)
void nKillChar(coeffs r)
undo all initialisations
static void ndClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
BOOLEAN nrnInitChar(coeffs r, void *p)
BOOLEAN nnInitChar(coeffs n, void *p)
Initialize r.
static number ndGetDenom(number &, const coeffs r)
number(* cfImPart)(number a, const coeffs r)
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...
The main handler for Singular numbers which are suitable for Singular polynomials.
BOOLEAN nrzInitChar(coeffs r, void *)
Templated enumerator interface for simple iteration over a generic collection of T's.
static int ndSize(number a, const coeffs r)
void StringSetS(const char *st)
static FORCE_INLINE BOOLEAN nCoeff_has_Units(const coeffs r)
returns TRUE, if r is not a field and r has non-trivial units
void(* cfPower)(number a, int i, number *result, const coeffs r)
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete/n_New are empty operations.
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
virtual reference Current()=0
Gets the current element in the collection (read and write).
nCoeffsEnumeratorFunc cfClearContent
function pointer behind n_ClearContent
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
static BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void *)
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
const char *(* cfRead)(const char *s, number *a, const coeffs r)
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
BOOLEAN nfInitChar(coeffs r, void *parameter)
cfInitCharProc nInitCharTableDefault[]
static number ndExtGcd(number, number, number *, number *, const coeffs r)
static cfInitCharProc * nInitCharTable
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
void(* cfWriteLong)(number a, const coeffs r)
print a given number (long format)
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
BOOLEAN ngfInitChar(coeffs n, void *parameter)
Initialize r.
virtual bool MoveNext()=0
Advances the enumerator to the next element of the collection. returns true if the enumerator was suc...
number(* cfGcd)(number a, number b, const coeffs r)
static void ndSetChar(const coeffs)
static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext(const coeffs r)
is it an alg. ext. of Q?
number(* cfLcm)(number a, number b, const coeffs r)
static void ndInpAdd(number &a, number b, const coeffs r)
number(* convFactoryNSingN)(const CanonicalForm n, const coeffs r)
conversion to CanonicalForm(factory) to number
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
static number ndGetNumerator(number &a, const coeffs r)
static number ndAnn(number, const coeffs)
static number ndIntMod(number, number, const coeffs r)
CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
static number ndFarey(number, number, const coeffs r)
static void ndClearDenominators(ICoeffsEnumerator &, number &d, const coeffs r)
nMapFunc(* cfSetMap)(const coeffs src, const coeffs dst)
char *(* cfCoeffName)(const coeffs r)
default name of cf, should substitue cfCoeffWrite, cfCoeffString
coeffs nFindCoeffByName(char *cf_name)
find an existing coeff by its "CoeffName"
int(* cfSize)(number n, const coeffs r)
how complicated, (0) => 0, or positive
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
number(* cfAnn)(number a, const coeffs r)
number(* cfParameter)(const int i, const coeffs r)
create i^th parameter or NULL if not possible
BOOLEAN(*)(*)(*)(*)(*) cfIsMOne(number a, const coeffs r)
CanonicalForm(* convSingNFactoryN)(number n, BOOLEAN setChar, const coeffs r)
void(* cfKillChar)(coeffs r)
char * nEatLong(char *s, mpz_ptr i)
extracts a long integer from s, returns the rest
static void ndMPZ(mpz_t result, number &n, const coeffs r)
Converts a non-negative bigint number into a GMP number.
coeffs(* cfInitCfByNameProc)(char *s, n_coeffType n)
initialize an object of type coeffs by its name, return NULL otherwise
void Werror(const char *fmt,...)
void(* cfInpAdd)(number &a, number b, const coeffs r)
Inplace: a += b.
number(* cfGetNumerator)(number &n, const coeffs r)
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
int iNumberOfParameters
Number of Parameters in the coeffs (default 0)
number(* cfGetDenom)(number &n, const coeffs r)
BOOLEAN(*)(*)(*) cfIsZero(number a, const coeffs r)
BOOLEAN(*)(*) cfEqual(number a, number b, const coeffs r)
tests
BOOLEAN ntInitChar(coeffs cf, void *infoStruct)
Initialize the coeffs object.
nCoeffsEnumeratorFunc cfClearDenominators
function pointer behind n_ClearDenominators
int(* cfParDeg)(number x, const coeffs r)
degree for coeffcients: -1 for 0, 0 for "constants", ...