10#include "factory/factory.h"
28#if defined(DO_LINLINE) && defined(P_NUMBERS_H) && !defined(LDEBUG)
29#define LINLINE static FORCE_INLINE
72const char *
nlRead (
const char *
s, number *a,
const coeffs r);
87#define nlTest(a, r) nlDBTest(a,__FILE__,__LINE__, r)
90#define nlTest(a, r) do {} while (0)
97#define MAX_NUM_SIZE 60
98#define POW_2_28 (1L<<60)
99#define POW_2_28_32 (1L<<28)
102#define MAX_NUM_SIZE 28
103#define POW_2_28 (1L<<28)
104#define POW_2_28_32 (1L<<28)
120 LONG ui=mpz_get_si(
x->z);
121 if ((((ui<<3)>>3)==ui)
122 && (mpz_cmp_si(
x->z,(
long)ui)==0))
135#ifndef BYTES_PER_MP_LIMB
136#define BYTES_PER_MP_LIMB sizeof(mp_limb_t)
146#define mpz_isNeg(A) ((A)->_mp_size<0)
147#define mpz_limb_size(A) ((A)->_mp_size)
148#define mpz_limb_d(A) ((A)->_mp_d)
171 mpz_init_set(z->z,
m);
176#if (__GNU_MP_VERSION*10+__GNU_MP_VERSION_MINOR < 31)
229 mpz_init_set_ui(z->z,(
unsigned long) from);
242 Print(
"!!longrat: NULL in %s:%d\n",
f,
l);
246 if ((((
long)a)&3L)==3L)
248 Print(
" !!longrat:ptr(3) in %s:%d\n",
f,
l);
251 if ((((
long)a)&3L)==1L)
253 if (((((
LONG)(
long)a)<<1)>>1)!=((
LONG)(
long)a))
255 Print(
" !!longrat:arith:%lx in %s:%d\n",(
long)a,
f,
l);
265 if (a->debug!=123456)
267 Print(
"!!longrat:debug:%d in %s:%d\n",a->debug,
f,
l);
271 if ((a->s<0)||(a->s>4))
273 Print(
"!!longrat:s=%d in %s:%d\n",a->s,
f,
l);
281 if (a->z[0]._mp_alloc==0)
282 Print(
"!!longrat:z->alloc=0 in %s:%d\n",
f,
l);
286 if ((a->n[0]._mp_d[0]==0)&&(a->n[0]._mp_alloc<=1))
288 Print(
"!!longrat: n==0 in %s:%d\n",
f,
l);
296 if (a->z[0]._mp_alloc==0)
297 Print(
"!!longrat:n->alloc=0 in %s:%d\n",
f,
l);
298 if ((
mpz_size1(a->n) ==1) && (mpz_cmp_si(a->n,1L)==0))
300 Print(
"!!longrat:integer as rational in %s:%d\n",
f,
l);
301 mpz_clear(a->n); a->s=3;
306 Print(
"!!longrat:div. by negative in %s:%d\n",
f,
l);
320 if ((((ui<<3)>>3)==ui)
321 && (mpz_cmp_si(a->z,(
long)ui)==0))
323 Print(
"!!longrat:im int %d in %s:%d\n",ui,
f,
l);
345 long lz=mpz_get_si(n->z);
346 if (mpz_cmp_si(n->z,lz)==0)
term=lz;
349 mpz_init_set( dummy,n->z );
358 mpz_init_set(
num, n->z );
359 mpz_init_set(
den, n->n );
381 if (
f.den().isOne() )
409 mpz_init_set_ui(h1,1);
410 while((FLT_RADIX*
f) < DBL_MAX &&
i<DBL_MANT_DIG)
413 mpz_mul_ui(h1,h1,FLT_RADIX);
418 memcpy(&(re->n),&h1,
sizeof(h1));
420 if(f_sign==-1) re=
nlNeg(re,dst);
443 int size,
i,negative;
447 size = (*f)[0]._mp_size;
465 e=(*f)[0]._mp_exp-
size;
472 void* (*allocfunc) (size_t);
473 mp_get_memory_functions (&allocfunc,
NULL,
NULL);
476 al = dest->_mp_size =
size;
478 dd = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*al);
481 nn = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*bl);
482 memset(nn,0,
sizeof(mp_limb_t)*bl);
486 ndest->_mp_alloc = ndest->_mp_size = bl;
491 al = dest->_mp_size =
size+e;
493 dd = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*al);
494 memset(dd,0,
sizeof(mp_limb_t)*al);
496 for (
i=0;
i<e;
i++) dd[
i] = 0;
501 dest->_mp_alloc = al;
502 if (negative) mpz_neg(dest,dest);
520 if (mpf_fits_slong_p(ff->
t))
522 long l=mpf_get_si(ff->
t);
526 char *
p=strchr(out,
'.');
537 mpz_set_str(
res->z,out+1,10);
542 mpz_set_str(
res->z,out,10);
554 if (dst->is_field==
FALSE)
569 WarnS(
"conversion problem in CC -> ZZ mapping");
578 int size,
i,negative;
582 size = (*f)[0]._mp_size;
600 e=(*f)[0]._mp_exp-
size;
607 void* (*allocfunc) (size_t);
608 mp_get_memory_functions (&allocfunc,
NULL,
NULL);
611 al = dest->_mp_size =
size;
613 dd = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*al);
616 nn = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*bl);
617 memset(nn,0,
sizeof(mp_limb_t)*bl);
621 ndest->_mp_alloc = ndest->_mp_size = bl;
626 al = dest->_mp_size =
size+e;
628 dd = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*al);
629 memset(dd,0,
sizeof(mp_limb_t)*al);
631 for (
i=0;
i<e;
i++) dd[
i] = 0;
636 dest->_mp_alloc = al;
637 if (negative) mpz_neg(dest,dest);
721 int s=a->z[0]._mp_alloc;
730 int d=a->n[0]._mp_alloc;
755 long ul=mpz_get_si(
i->z);
756 if (mpz_cmp_si(
i->z,ul)!=0)
return 0;
762 mpz_tdiv_q(tmp,
i->z,
i->n);
767 if (mpz_cmp_si(tmp,ul)!=0) ul=0;
786 mpz_tdiv_q(tmp->z,
i->z,
i->n);
816 mpz_init_set_ui(n->z,1L);
817 mpz_init_set_si(n->n,(
long)
SR_TO_INT(a));
821 mpz_init_set_si(n->z,-1L);
822 mpz_init_set_si(n->n,(
long)-
SR_TO_INT(a));
832 mpz_init_set(n->n,a->z);
838 mpz_init_set(n->z,a->n);
844 if (mpz_cmp_ui(n->n,1L)==0)
857 mpz_init_set_si(n->z,-1L);
861 mpz_init_set_ui(n->z,1L);
914 mpz_divexact(u->z,a->z,
b->z);
957 if (rr<0) rr+=
ABS(bb);
990 mpz_mod(rr,a->z,
b->z);
993 mpz_sub(u->z,a->z,rr);
995 mpz_divexact(u->z,u->z,
b->z);
1035 if (c<0) c+=
ABS(bb);
1042 mpz_init_set_si(aa, ai);
1049 mpz_mod(u->z, aa,
b->z);
1067 mpz_mod(u->z, a->z,
b->z);
1089 return (mpz_divisible_ui_p(a->z,
SR_TO_INT(
b))!=0);
1092 return mpz_divisible_p(a->z,
b->z) != 0;
1114 long ch = r->cfInt(c, r);
1125 mpz_init_set_ui(dummy, ch);
1128 info.exp = (
unsigned long) 1;
1159 if (
j==1L)
return a;
1174 mpz_init_set_si(u->z,(
long)
i);
1175 mpz_init_set_si(u->n,(
long)
j);
1198 if (mpz_cmp(u->z,
b->z)==0)
1204 mpz_init_set(u->n,
b->z);
1213 mpz_init_set(u->n,a->n);
1233 mpz_init_set(u->n,
b->z);
1234 if (a->s<2) mpz_mul(u->n,u->n,a->n);
1235 if (
b->s<2) mpz_mul(u->z,u->z,
b->n);
1243 if (mpz_cmp_si(u->n,1L)==0)
1277 mpz_pow_ui((*u)->z,
x->z,(
unsigned long)
exp);
1280 if (mpz_cmp_si(
x->n,1L)==0)
1288 mpz_pow_ui((*u)->n,
x->n,(
unsigned long)
exp);
1385 unsigned long t=mpz_gcd_ui(
NULL,
b->z,(
long)aa);
1395 unsigned long t=mpz_gcd_ui(
NULL,a->z,(
long)bb);
1476 if (mpz_cmp(
x->z,
x->n)==0)
1499 if (mpz_cmp_si(
x->n,1L)==0)
1509 mpz_gcd(
gcd,
x->z,
x->n);
1511 if (mpz_cmp_si(
gcd,1L)!=0)
1513 mpz_divexact(
x->z,
x->z,
gcd);
1514 mpz_divexact(
x->n,
x->n,
gcd);
1515 if (mpz_cmp_si(
x->n,1L)==0)
1553 mpz_gcd(
gcd,a->z,
b->n);
1554 if (mpz_cmp_si(
gcd,1L)!=0)
1558 mpz_divexact(bt,
b->n,
gcd);
1562 mpz_mul(
result->z,bt,a->z);
1594 const unsigned long PP =
p;
1597 number z =
n_Init(
static_cast<long>(mpz_fdiv_ui(q->z, PP)), Zp );
1603 number n =
n_Init(
static_cast<long>(mpz_fdiv_ui(q->n, PP)), Zp );
1632 WarnS(
"Omitted denominator during coefficient mapping !");
1658 mpz_init_set(u->z,n->n);
1685 mpz_init_set(u->z,n->z);
1708 if (a->s!=0)
return FALSE;
1709 number n=
b;
b=a; a=n;
1723 bo=(mpz_cmp(bb,
b->z)==0);
1728 if (((a->s==1) && (
b->s==3))
1729 || ((
b->s==1) && (a->s==3)))
1737 mpz_init_set(aa,a->z);
1738 mpz_init_set(bb,
b->z);
1739 if (a->s<2) mpz_mul(bb,bb,a->n);
1740 if (
b->s<2) mpz_mul(aa,aa,
b->n);
1741 bo=(mpz_cmp(aa,bb)==0);
1760 mpz_init_set(
b->n,a->n);
1762 mpz_init_set(
b->z,a->z);
1781 memset(*a,0,
sizeof(**a));
1798#define GCD_NORM_COND(OLD,NEW) (mpz_size1(NEW->z)>mpz_size1(OLD->z))
1804 mpz_gcd(
gcd,
x->z,
x->n);
1806 if (mpz_cmp_si(
gcd,1L)!=0)
1808 mpz_divexact(
x->z,
x->z,
gcd);
1809 mpz_divexact(
x->n,
x->n,
gcd);
1810 if (mpz_cmp_si(
x->n,1L)==0)
1843 mpz_add(u->z,
b->z,
x);
1851 if (mpz_cmp(u->z,
b->n)==0)
1857 mpz_init_set(u->n,
b->n);
1889 mpz_mul(
x,
b->z,a->n);
1890 mpz_mul(u->z,a->z,
b->n);
1891 mpz_add(u->z,u->z,
x);
1901 mpz_mul(u->n,a->n,
b->n);
1902 if (mpz_cmp(u->z,u->n)==0)
1915 mpz_mul(u->z,
b->z,a->n);
1916 mpz_add(u->z,u->z,a->z);
1923 if (mpz_cmp(u->z,a->n)==0)
1929 mpz_init_set(u->n,a->n);
1944 mpz_mul(u->z,a->z,
b->n);
1945 mpz_add(u->z,u->z,
b->z);
1952 if (mpz_cmp(u->z,
b->n)==0)
1958 mpz_init_set(u->n,
b->n);
1965 mpz_add(u->z,a->z,
b->z);
1990 mpz_add(a->z,a->z,
x);
2024 mpz_add(u->z,
b->z,
x);
2027 mpz_init_set(u->n,
b->n);
2063 mpz_mul(
x,
b->z,a->n);
2064 mpz_mul(
y,a->z,
b->n);
2068 mpz_mul(a->n,a->n,
b->n);
2078 mpz_mul(
x,
b->z,a->n);
2079 mpz_add(a->z,a->z,
x);
2098 mpz_mul(
x,a->z,
b->n);
2099 mpz_add(a->z,
b->z,
x);
2101 mpz_init_set(a->n,
b->n);
2109 mpz_add(a->z,a->z,
b->z);
2138 mpz_sub(u->z,
x,
b->z);
2146 if (mpz_cmp(u->z,
b->n)==0)
2152 mpz_init_set(u->n,
b->n);
2185 mpz_sub(u->z,a->z,
x);
2193 if (mpz_cmp(u->z,a->n)==0)
2199 mpz_init_set(u->n,a->n);
2236 mpz_mul(
x,
b->z,a->n);
2237 mpz_mul(
y,a->z,
b->n);
2248 mpz_mul(u->n,a->n,
b->n);
2249 if (mpz_cmp(u->z,u->n)==0)
2264 mpz_mul(
x,
b->z,a->n);
2265 mpz_sub(u->z,a->z,
x);
2273 if (mpz_cmp(u->z,a->n)==0)
2279 mpz_init_set(u->n,a->n);
2296 mpz_mul(
x,a->z,
b->n);
2297 mpz_sub(u->z,
x,
b->z);
2305 if (mpz_cmp(u->z,
b->n)==0)
2311 mpz_init_set(u->n,
b->n);
2318 mpz_sub(u->z,a->z,
b->z);
2362 if (u->s==1) u->s=0;
2365 mpz_mul_ui(u->z,
b->z,(
unsigned long)
SR_TO_INT(a));
2377 mpz_mul_ui(u->z,
b->z,(
unsigned long)-
SR_TO_INT(a));
2383 if (mpz_cmp(u->z,
b->n)==0)
2389 mpz_init_set(u->n,
b->n);
2399 mpz_mul(u->z,a->z,
b->z);
2409 if (mpz_cmp(u->z,
b->n)==0)
2415 mpz_init_set(u->n,
b->n);
2423 if (mpz_cmp(u->z,a->n)==0)
2429 mpz_init_set(u->n,a->n);
2435 mpz_mul(u->n,a->n,
b->n);
2436 if (mpz_cmp(u->z,u->n)==0)
2485 if ((src->is_field==dst->is_field)
2486 || (src->is_field==
FALSE))
2537 mpz_init_set_si(z->z,
i);
2551 mpz_init_set_si(z->z,(
long)
i);
2552 mpz_init_set_si(z->n,(
long)
j);
2564 mpz_init_set(z->z,
i);
2565 mpz_init_set(z->n,
j);
2591#if defined(DO_LINLINE) || !defined(P_NUMBERS_H)
2610 #if MAX_NUM_SIZE == 60
2615 if ( ((((
long)ii)==
i) && ((ii << 3) >> 3) == ii )) n=
INT_TO_SR(ii);
2639 if (mpz_cmp_si(a->z,0L)==0)
2641 printf(
"gmp-0 in nlIsZero\n");
2707 if ( ((r << 1) >> 1) == r )
2708 return (number)(long)r;
2726 if ( ((r << 1) >> 1) == r )
2749 number u=((number) ((r>>1)+
SR_INT));
2773 if ( ((r << 1) >> 1) == r )
2775 return (number)(long)r;
2797 mpz_mul(aa->z,a->z,
b->z);
2802 mpz_init_set(a->n,
b->n);
2810 mpz_mul(a->n,a->n,
b->n);
2825 else mpz_init_set(
m, (mpz_ptr)n->z);
2850 mpz_init_set(aa, a->z);
2858 mpz_init_set(bb,
b->z);
2860 mpz_t erg; mpz_t bs; mpz_t bt;
2865 mpz_gcdext(erg, bs, bt, aa, bb);
2867 mpz_div(aa, aa, erg);
2910 rr = mpz_divmod_ui(qq, rrr, a->z, (
unsigned long)
ABS(
SR_TO_INT(
b)));
2924 mpz_divmod(qq, rr, a->z,
b->z);
2944 mpz_gcd(a->z,a->z,
b->z);
2961 mpz_mod(rr,a->z,
b->z);
2962 mpz_sub(a->z,a->z,rr);
2964 mpz_divexact(a->z,a->z,
b->z);
2971 mpz_t
A,
B,C,
D,
E,
N,P,tmp;
2973 else mpz_init_set(P,nP->z);
2974 const mp_bitcnt_t bits=2*(
mpz_size1(P)+1)*GMP_LIMB_BITS;
2977 else mpz_set(
N,nN->z);
2980 mpz_init2(
A,bits); mpz_set_ui(
A,0L);
2981 mpz_init2(
B,bits); mpz_set_ui(
B,1L);
2982 mpz_init2(C,bits); mpz_set_ui(C,0L);
2984 mpz_init2(
E,bits); mpz_set(
E,P);
2985 mpz_init2(tmp,bits);
2990 mpz_add(tmp,tmp,tmp);
2991 if (mpz_cmp(tmp,P)<0)
3000 if (mpz_cmp_ui(tmp,1)==0)
3007 memcpy(z->z,
N,
sizeof(mpz_t));
3008 memcpy(z->n,
B,
sizeof(mpz_t));
3023 mpz_divmod(tmp,
D,
E,
N);
3044 mpz_init((*s)->z); (*s)->s=3;
3046 mpz_init((*t)->z); (*t)->s=3;
3048 mpz_init(
g->z);
g->s=3;
3056 aa=(mpz_ptr)
omAlloc(
sizeof(mpz_t));
3065 bb=(mpz_ptr)
omAlloc(
sizeof(mpz_t));
3072 mpz_gcdext(
g->z,(*s)->z,(*t)->z,aa,bb);
3103 for(
i=rl-1;
i>=0;
i--)
3105 X[
i]=CF->convSingNFactoryN(
x[
i],
FALSE,CF);
3106 Q[
i]=CF->convSingNFactoryN(q[
i],
FALSE,CF);
3113 number n=CF->convFactoryNSingN(xnew,CF);
3116 number
p=CF->convFactoryNSingN(qnew,CF);
3119 else p2=CF->cfDiv(
p,CF->cfInit(2, CF),CF);
3120 if (CF->cfGreater(n,p2,CF))
3122 number n2=CF->cfSub(n,
p,CF);
3123 CF->cfDelete(&n,CF);
3126 CF->cfDelete(&p2,CF);
3127 CF->cfDelete(&
p,CF);
3129 CF->cfNormalize(n,CF);
3133number nlChineseRemainder(number *
x, number *q,
int rl,
const coeffs C)
3144 numberCollectionEnumerator.
Reset();
3146 if( !numberCollectionEnumerator.
MoveNext() )
3161 int normalcount = 0;
3164 number& n = numberCollectionEnumerator.
Current();
3176 }
while (numberCollectionEnumerator.
MoveNext() );
3183 numberCollectionEnumerator.
Reset();
3185 while (numberCollectionEnumerator.
MoveNext() )
3187 number& n = numberCollectionEnumerator.
Current();
3189 if( (--normalcount) <= 0)
3203 numberCollectionEnumerator.
Reset();
3205 while (numberCollectionEnumerator.
MoveNext() )
3207 number& nn = numberCollectionEnumerator.
Current();
3220 numberCollectionEnumerator.
Reset();
3222 while (numberCollectionEnumerator.
MoveNext() )
3224 number& n = numberCollectionEnumerator.
Current();
3235 numberCollectionEnumerator.
Reset();
3237 if( !numberCollectionEnumerator.
MoveNext() )
3260 number& cand1 = numberCollectionEnumerator.
Current();
3270 mpz_init_set(
cand->z, cand1->n);
3275 mpz_lcm(
cand->z,
cand->z, cand1->n);
3280 while (numberCollectionEnumerator.
MoveNext() );
3295 numberCollectionEnumerator.
Reset();
3296 while (numberCollectionEnumerator.
MoveNext() )
3298 number& n = numberCollectionEnumerator.
Current();
3310 numberCollectionEnumerator.
Reset();
3317 while (numberCollectionEnumerator.
MoveNext() )
3319 number &n = numberCollectionEnumerator.
Current();
3327 if (r->cfDiv==
nlDiv)
return (
char*)
"QQ";
3328 else return (
char*)
"ZZ";
3335 #if SIZEOF_LONG == 4
3342 fprintf(d->
f_write,
"4 %d ",nnn);
3347 mpz_init_set_si(tmp,nn);
3358 fprintf(d->
f_write,
"%d ",n->s+5);
3399 #if SIZEOF_LONG == 8
3428 #if SIZEOF_LONG == 8
3434 default:
Werror(
"error in reading number: invalid subtype %d",sub_type);
3498 r->cfSubringGcd =
nlGcd;
3521 r->cfInpNeg =
nlNeg;
3565 r->has_simple_Alloc=
FALSE;
3566 r->has_simple_Inverse=
FALSE;
3573number nlMod(number a, number
b)
3595 mpz_mod(r->z,al->z,bl->z);
3600 LONG ui=(int)mpz_get_si(&r->z);
3601 if ((((ui<<3)>>3)==ui)
3602 && (mpz_cmp_si(
x->z,(
long)ui)==0))
const CanonicalForm CFMap CFMap & N
const CanonicalForm const CanonicalForm const CanonicalForm const CanonicalForm & cand
void FACTORY_PUBLIC chineseRemainder(const CanonicalForm &x1, const CanonicalForm &q1, const CanonicalForm &x2, const CanonicalForm &q2, CanonicalForm &xnew, CanonicalForm &qnew)
void chineseRemainder ( const CanonicalForm & x1, const CanonicalForm & q1, const CanonicalForm & x2,...
void FACTORY_PUBLIC chineseRemainderCached(const CanonicalForm &x1, const CanonicalForm &q1, const CanonicalForm &x2, const CanonicalForm &q2, CanonicalForm &xnew, CanonicalForm &qnew, CFArray &inv)
static const int SW_RATIONAL
set to 1 for computations over Q
virtual reference Current()=0
Gets the current element in the collection (read and write).
virtual void Reset()=0
Sets the enumerator to its initial position: -1, which is before the first element in the collection.
virtual bool MoveNext()=0
Advances the enumerator to the next element of the collection. returns true if the enumerator was suc...
Templated enumerator interface for simple iteration over a generic collection of T's.
gmp_complex numbers based on
Coefficient rings, fields and other domains suitable for Singular polynomials.
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
@ n_R
single prescision (6,6) real numbers
@ n_Q
rational (GMP) numbers
@ n_Zn
only used if HAVE_RINGS is defined
@ n_long_R
real floating point (GMP) numbers
@ n_long_C
complex floating point (GMP) numbers
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...
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(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
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
@ n_rep_gap_rat
(number), see longrat.h
@ n_rep_gap_gmp
(), see rinteger.h, new impl.
@ n_rep_float
(float), see shortfl.h
@ n_rep_int
(int), see modulop.h
@ n_rep_gmp_float
(gmp_float), see
@ n_rep_gmp
(mpz_ptr), see rmodulon,h
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
const CanonicalForm int s
const CanonicalForm int const CFList const Variable & y
REvaluation E(1, terms.length(), IntRandom(25))
const Variable & v
< [in] a sqrfree bivariate poly
bool isZero(const CFArray &A)
checks if entries of A are zero
CanonicalForm FACTORY_PUBLIC make_cf(const mpz_ptr n)
void FACTORY_PUBLIC gmp_numerator(const CanonicalForm &f, mpz_ptr result)
void FACTORY_PUBLIC gmp_denominator(const CanonicalForm &f, mpz_ptr result)
void WerrorS(const char *s)
static number nlMapP(number from, const coeffs src, const coeffs dst)
void nlWriteFd(number n, const ssiInfo *d, const coeffs)
LINLINE void nlInpMult(number &a, number b, const coeffs r)
LINLINE BOOLEAN nlEqual(number a, number b, const coeffs r)
LINLINE number nlAdd(number la, number li, const coeffs r)
long nlInt(number &n, const coeffs r)
static number nlLcm(number a, number b, const coeffs r)
static number nlMapLongR_BI(number from, const coeffs src, const coeffs dst)
number nlInit2(int i, int j, const coeffs r)
create a rational i/j (implicitly) over Q NOTE: make sure to use correct Q in debug mode
LINLINE number nl_Copy(number a, const coeffs r)
number nlInit2gmp(mpz_t i, mpz_t j, const coeffs r)
create a rational i/j (implicitly) over Q NOTE: make sure to use correct Q in debug mode
void _nlInpAdd_aNoImm_OR_bNoImm(number &a, number b)
LINLINE number nlSub(number la, number li, const coeffs r)
number nlIntMod(number a, number b, const coeffs r)
number _nlCopy_NoImm(number a)
number _nlSub_aNoImm_OR_bNoImm(number a, number b)
LINLINE number nlCopy(number a, const coeffs r)
LINLINE number nlNeg(number za, const coeffs r)
number nlXExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
void nlPower(number x, int exp, number *lu, const coeffs r)
number nlQuotRem(number a, number b, number *r, const coeffs R)
number nlFarey(number nN, number nP, const coeffs CF)
LINLINE BOOLEAN nlIsOne(number a, const coeffs r)
static number nlMapC(number from, const coeffs src, const coeffs dst)
number nlNormalizeHelper(number a, number b, const coeffs r)
LINLINE void nlDelete(number *a, const coeffs r)
number nlMapZ(number from, const coeffs src, const coeffs dst)
BOOLEAN nlGreaterZero(number za, const coeffs r)
number _nlNeg_NoImm(number a)
number nlModP(number q, const coeffs, const coeffs Zp)
LINLINE void nlInpAdd(number &a, number b, const coeffs r)
number nlExactDiv(number a, number b, const coeffs r)
void mpz_mul_si(mpz_ptr r, mpz_srcptr s, long int si)
const char * nlRead(const char *s, number *a, const coeffs r)
void nlMPZ(mpz_t m, number &n, const coeffs r)
number nlInvers(number a, const coeffs r)
BOOLEAN nlIsUnit(number a, const coeffs)
void nlInpIntDiv(number &a, number b, const coeffs r)
static void nlNormalize_Gcd(number &x)
static number nlConvFactoryNSingN(const CanonicalForm f, const coeffs r)
number nlChineseRemainderSym(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs CF)
int nlDivComp(number a, number b, const coeffs r)
void _nlDelete_NoImm(number *a)
char * nlCoeffName(const coeffs r)
BOOLEAN nlInitChar(coeffs r, void *p)
number nlCopyMap(number a, const coeffs, const coeffs)
number nlExtGcd(number a, number b, number *s, number *t, const coeffs)
static number nlMapGMP(number from, const coeffs, const coeffs dst)
LINLINE number nlMult(number a, number b, const coeffs r)
static number nlInitMPZ(mpz_t m, const coeffs)
number nlIntDiv(number a, number b, const coeffs r)
static void nlClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
static number nlMapLongR(number from, const coeffs src, const coeffs dst)
LINLINE BOOLEAN nlIsZero(number za, const coeffs r)
number nlGetDenom(number &n, const coeffs r)
number nlGcd(number a, number b, const coeffs r)
number _nlMult_aImm_bImm_rNoImm(number a, number b)
number nlReadFd(const ssiInfo *d, const coeffs)
int nlSize(number a, const coeffs)
number nlMapMachineInt(number from, const coeffs, const coeffs)
nMapFunc nlSetMap(const coeffs src, const coeffs dst)
number nlBigInt(number &n)
static number nlShort3(number x)
#define GCD_NORM_COND(OLD, NEW)
BOOLEAN nlDBTest(number a, const char *f, const int l)
number nlDiv(number a, number b, const coeffs r)
BOOLEAN nlIsMOne(number a, const coeffs r)
static void nlClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
number _nlMult_aNoImm_OR_bNoImm(number a, number b)
LINLINE number nlInit(long i, const coeffs r)
number nlShort3_noinline(number x)
number nlGetNumerator(number &n, const coeffs r)
number _nlAdd_aNoImm_OR_bNoImm(number a, number b)
BOOLEAN nlCoeffIsEqual(const coeffs r, n_coeffType n, void *p)
static CanonicalForm nlConvSingNFactoryN(number n, const BOOLEAN setChar, const coeffs)
static number nlMapR(number from, const coeffs src, const coeffs dst)
number nlGetUnit(number n, const coeffs cf)
coeffs nlQuot1(number c, const coeffs r)
BOOLEAN _nlEqual_aNoImm_OR_bNoImm(number a, number b)
number nlShort1(number x)
BOOLEAN nlGreater(number a, number b, const coeffs r)
static number nlMapR_BI(number from, const coeffs src, const coeffs dst)
void nlGMP(number &i, mpz_t n, const coeffs r)
void nlNormalize(number &x, const coeffs r)
BOOLEAN nlDivBy(number a, number b, const coeffs)
static int int_extgcd(int a, int b, int *u, int *x, int *v, int *y)
void nlWrite(number a, const coeffs r)
void nlInpGcd(number &a, number b, const coeffs r)
static number nlRandom(siRandProc p, number v2, number, const coeffs cf)
number nlMapQtoZ(number a, const coeffs src, const coeffs dst)
long npInt(number &n, const coeffs r)
char * floatToStr(const gmp_float &r, const unsigned int oprec)
gmp_float exp(const gmp_float &a)
The main handler for Singular numbers which are suitable for Singular polynomials.
char * nEatLong(char *s, mpz_ptr i)
extracts a long integer from s, returns the rest
const char *const nDivBy0
#define omFreeSize(addr, size)
#define omCheckIf(cond, test)
#define omCheckAddrSize(addr, size)
void Werror(const char *fmt,...)
void s_readmpz(s_buff F, mpz_t a)
void s_readmpz_base(s_buff F, mpz_ptr a, int base)
long s_readlong(s_buff F)
SI_FLOAT nrFloat(number n)
Converts a n_R number into a float. Needed by Maps.