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)
228 mpz_init_set_ui(z->z,(
unsigned long) from);
239 Print(
"!!longrat: NULL in %s:%d\n",
f,
l);
243 if ((((
long)a)&3L)==3L)
245 Print(
" !!longrat:ptr(3) in %s:%d\n",
f,
l);
248 if ((((
long)a)&3L)==1L)
250 if (((((
LONG)(
long)a)<<1)>>1)!=((
LONG)(
long)a))
252 Print(
" !!longrat:arith:%lx in %s:%d\n",(
long)a,
f,
l);
262 if (a->debug!=123456)
264 Print(
"!!longrat:debug:%d in %s:%d\n",a->debug,
f,
l);
268 if ((a->s<0)||(a->s>4))
270 Print(
"!!longrat:s=%d in %s:%d\n",a->s,
f,
l);
278 if (a->z[0]._mp_alloc==0)
279 Print(
"!!longrat:z->alloc=0 in %s:%d\n",
f,
l);
283 if ((a->n[0]._mp_d[0]==0)&&(a->n[0]._mp_alloc<=1))
285 Print(
"!!longrat: n==0 in %s:%d\n",
f,
l);
293 if (a->z[0]._mp_alloc==0)
294 Print(
"!!longrat:n->alloc=0 in %s:%d\n",
f,
l);
295 if ((
mpz_size1(a->n) ==1) && (mpz_cmp_si(a->n,1L)==0))
297 Print(
"!!longrat:integer as rational in %s:%d\n",
f,
l);
298 mpz_clear(a->n); a->s=3;
303 Print(
"!!longrat:div. by negative in %s:%d\n",
f,
l);
317 if ((((ui<<3)>>3)==ui)
318 && (mpz_cmp_si(a->z,(
long)ui)==0))
320 Print(
"!!longrat:im int %d in %s:%d\n",ui,
f,
l);
342 long lz=mpz_get_si(n->z);
343 if (mpz_cmp_si(n->z,lz)==0)
term=lz;
346 mpz_init_set( dummy,n->z );
355 mpz_init_set(
num, n->z );
356 mpz_init_set(
den, n->n );
378 if (
f.den().isOne() )
406 mpz_init_set_ui(h1,1);
407 while((FLT_RADIX*
f) < DBL_MAX &&
i<DBL_MANT_DIG)
410 mpz_mul_ui(h1,h1,FLT_RADIX);
415 memcpy(&(re->n),&h1,
sizeof(h1));
417 if(f_sign==-1) re=
nlNeg(re,dst);
440 int size,
i,negative;
444 size = (*f)[0]._mp_size;
462 e=(*f)[0]._mp_exp-
size;
469 void* (*allocfunc) (size_t);
470 mp_get_memory_functions (&allocfunc,
NULL,
NULL);
473 al = dest->_mp_size =
size;
475 dd = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*al);
478 nn = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*bl);
479 memset(nn,0,
sizeof(mp_limb_t)*bl);
483 ndest->_mp_alloc = ndest->_mp_size = bl;
488 al = dest->_mp_size =
size+e;
490 dd = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*al);
491 memset(dd,0,
sizeof(mp_limb_t)*al);
493 for (
i=0;
i<e;
i++) dd[
i] = 0;
498 dest->_mp_alloc = al;
499 if (negative) mpz_neg(dest,dest);
517 if (mpf_fits_slong_p(ff->
t))
519 long l=mpf_get_si(ff->
t);
523 char *
p=strchr(out,
'.');
534 mpz_set_str(
res->z,out+1,10);
539 mpz_set_str(
res->z,out,10);
551 if (dst->is_field==
FALSE)
566 WarnS(
"conversion problem in CC -> ZZ mapping");
575 int size,
i,negative;
579 size = (*f)[0]._mp_size;
597 e=(*f)[0]._mp_exp-
size;
604 void* (*allocfunc) (size_t);
605 mp_get_memory_functions (&allocfunc,
NULL,
NULL);
608 al = dest->_mp_size =
size;
610 dd = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*al);
613 nn = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*bl);
614 memset(nn,0,
sizeof(mp_limb_t)*bl);
618 ndest->_mp_alloc = ndest->_mp_size = bl;
623 al = dest->_mp_size =
size+e;
625 dd = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*al);
626 memset(dd,0,
sizeof(mp_limb_t)*al);
628 for (
i=0;
i<e;
i++) dd[
i] = 0;
633 dest->_mp_alloc = al;
634 if (negative) mpz_neg(dest,dest);
718 int s=a->z[0]._mp_alloc;
727 int d=a->n[0]._mp_alloc;
752 long ul=mpz_get_si(
i->z);
753 if (mpz_cmp_si(
i->z,ul)!=0)
return 0;
759 mpz_tdiv_q(tmp,
i->z,
i->n);
764 if (mpz_cmp_si(tmp,ul)!=0) ul=0;
783 mpz_tdiv_q(tmp->z,
i->z,
i->n);
813 mpz_init_set_ui(n->z,1L);
814 mpz_init_set_si(n->n,(
long)
SR_TO_INT(a));
818 mpz_init_set_si(n->z,-1L);
819 mpz_init_set_si(n->n,(
long)-
SR_TO_INT(a));
829 mpz_init_set(n->n,a->z);
835 mpz_init_set(n->z,a->n);
841 if (mpz_cmp_ui(n->n,1L)==0)
854 mpz_init_set_si(n->z,-1L);
858 mpz_init_set_ui(n->z,1L);
911 mpz_divexact(u->z,a->z,
b->z);
954 if (rr<0) rr+=
ABS(bb);
987 mpz_mod(rr,a->z,
b->z);
990 mpz_sub(u->z,a->z,rr);
992 mpz_divexact(u->z,u->z,
b->z);
1032 if (c<0) c+=
ABS(bb);
1039 mpz_init_set_si(aa, ai);
1046 mpz_mod(u->z, aa,
b->z);
1064 mpz_mod(u->z, a->z,
b->z);
1086 return (mpz_divisible_ui_p(a->z,
SR_TO_INT(
b))!=0);
1089 return mpz_divisible_p(a->z,
b->z) != 0;
1111 long ch = r->cfInt(c, r);
1121 mpz_init_set_ui(dummy, ch);
1124 info.exp = (
unsigned long) 1;
1154 if (
j==1L)
return a;
1169 mpz_init_set_si(u->z,(
long)
i);
1170 mpz_init_set_si(u->n,(
long)
j);
1193 if (mpz_cmp(u->z,
b->z)==0)
1199 mpz_init_set(u->n,
b->z);
1208 mpz_init_set(u->n,a->n);
1228 mpz_init_set(u->n,
b->z);
1229 if (a->s<2) mpz_mul(u->n,u->n,a->n);
1230 if (
b->s<2) mpz_mul(u->z,u->z,
b->n);
1238 if (mpz_cmp_si(u->n,1L)==0)
1272 mpz_pow_ui((*u)->z,
x->z,(
unsigned long)
exp);
1275 if (mpz_cmp_si(
x->n,1L)==0)
1283 mpz_pow_ui((*u)->n,
x->n,(
unsigned long)
exp);
1380 unsigned long t=mpz_gcd_ui(
NULL,
b->z,(
long)aa);
1390 unsigned long t=mpz_gcd_ui(
NULL,a->z,(
long)bb);
1471 if (mpz_cmp(
x->z,
x->n)==0)
1494 if (mpz_cmp_si(
x->n,1L)==0)
1504 mpz_gcd(
gcd,
x->z,
x->n);
1506 if (mpz_cmp_si(
gcd,1L)!=0)
1508 mpz_divexact(
x->z,
x->z,
gcd);
1509 mpz_divexact(
x->n,
x->n,
gcd);
1510 if (mpz_cmp_si(
x->n,1L)==0)
1548 mpz_gcd(
gcd,a->z,
b->n);
1549 if (mpz_cmp_si(
gcd,1L)!=0)
1553 mpz_divexact(bt,
b->n,
gcd);
1557 mpz_mul(
result->z,bt,a->z);
1589 const unsigned long PP =
p;
1592 number z =
n_Init(
static_cast<long>(mpz_fdiv_ui(q->z, PP)), Zp );
1598 number n =
n_Init(
static_cast<long>(mpz_fdiv_ui(q->n, PP)), Zp );
1626 WarnS(
"Omitted denominator during coefficient mapping !");
1651 mpz_init_set(u->z,n->n);
1678 mpz_init_set(u->z,n->z);
1701 if (a->s!=0)
return FALSE;
1702 number n=
b;
b=a; a=n;
1716 bo=(mpz_cmp(bb,
b->z)==0);
1721 if (((a->s==1) && (
b->s==3))
1722 || ((
b->s==1) && (a->s==3)))
1730 mpz_init_set(aa,a->z);
1731 mpz_init_set(bb,
b->z);
1732 if (a->s<2) mpz_mul(bb,bb,a->n);
1733 if (
b->s<2) mpz_mul(aa,aa,
b->n);
1734 bo=(mpz_cmp(aa,bb)==0);
1753 mpz_init_set(
b->n,a->n);
1755 mpz_init_set(
b->z,a->z);
1774 memset(*a,0,
sizeof(**a));
1791#define GCD_NORM_COND(OLD,NEW) (mpz_size1(NEW->z)>mpz_size1(OLD->z))
1797 mpz_gcd(
gcd,
x->z,
x->n);
1799 if (mpz_cmp_si(
gcd,1L)!=0)
1801 mpz_divexact(
x->z,
x->z,
gcd);
1802 mpz_divexact(
x->n,
x->n,
gcd);
1803 if (mpz_cmp_si(
x->n,1L)==0)
1836 mpz_add(u->z,
b->z,
x);
1844 if (mpz_cmp(u->z,
b->n)==0)
1850 mpz_init_set(u->n,
b->n);
1882 mpz_mul(
x,
b->z,a->n);
1883 mpz_mul(u->z,a->z,
b->n);
1884 mpz_add(u->z,u->z,
x);
1894 mpz_mul(u->n,a->n,
b->n);
1895 if (mpz_cmp(u->z,u->n)==0)
1908 mpz_mul(u->z,
b->z,a->n);
1909 mpz_add(u->z,u->z,a->z);
1916 if (mpz_cmp(u->z,a->n)==0)
1922 mpz_init_set(u->n,a->n);
1937 mpz_mul(u->z,a->z,
b->n);
1938 mpz_add(u->z,u->z,
b->z);
1945 if (mpz_cmp(u->z,
b->n)==0)
1951 mpz_init_set(u->n,
b->n);
1958 mpz_add(u->z,a->z,
b->z);
1983 mpz_add(a->z,a->z,
x);
2017 mpz_add(u->z,
b->z,
x);
2020 mpz_init_set(u->n,
b->n);
2056 mpz_mul(
x,
b->z,a->n);
2057 mpz_mul(
y,a->z,
b->n);
2061 mpz_mul(a->n,a->n,
b->n);
2071 mpz_mul(
x,
b->z,a->n);
2072 mpz_add(a->z,a->z,
x);
2091 mpz_mul(
x,a->z,
b->n);
2092 mpz_add(a->z,
b->z,
x);
2094 mpz_init_set(a->n,
b->n);
2102 mpz_add(a->z,a->z,
b->z);
2131 mpz_sub(u->z,
x,
b->z);
2139 if (mpz_cmp(u->z,
b->n)==0)
2145 mpz_init_set(u->n,
b->n);
2178 mpz_sub(u->z,a->z,
x);
2186 if (mpz_cmp(u->z,a->n)==0)
2192 mpz_init_set(u->n,a->n);
2229 mpz_mul(
x,
b->z,a->n);
2230 mpz_mul(
y,a->z,
b->n);
2241 mpz_mul(u->n,a->n,
b->n);
2242 if (mpz_cmp(u->z,u->n)==0)
2257 mpz_mul(
x,
b->z,a->n);
2258 mpz_sub(u->z,a->z,
x);
2266 if (mpz_cmp(u->z,a->n)==0)
2272 mpz_init_set(u->n,a->n);
2289 mpz_mul(
x,a->z,
b->n);
2290 mpz_sub(u->z,
x,
b->z);
2298 if (mpz_cmp(u->z,
b->n)==0)
2304 mpz_init_set(u->n,
b->n);
2311 mpz_sub(u->z,a->z,
b->z);
2355 if (u->s==1) u->s=0;
2358 mpz_mul_ui(u->z,
b->z,(
unsigned long)
SR_TO_INT(a));
2370 mpz_mul_ui(u->z,
b->z,(
unsigned long)-
SR_TO_INT(a));
2376 if (mpz_cmp(u->z,
b->n)==0)
2382 mpz_init_set(u->n,
b->n);
2392 mpz_mul(u->z,a->z,
b->z);
2402 if (mpz_cmp(u->z,
b->n)==0)
2408 mpz_init_set(u->n,
b->n);
2416 if (mpz_cmp(u->z,a->n)==0)
2422 mpz_init_set(u->n,a->n);
2428 mpz_mul(u->n,a->n,
b->n);
2429 if (mpz_cmp(u->z,u->n)==0)
2478 if ((src->is_field==dst->is_field)
2479 || (src->is_field==
FALSE))
2528 mpz_init_set_si(z->z,
i);
2542 mpz_init_set_si(z->z,(
long)
i);
2543 mpz_init_set_si(z->n,(
long)
j);
2555 mpz_init_set(z->z,
i);
2556 mpz_init_set(z->n,
j);
2582#if defined(DO_LINLINE) || !defined(P_NUMBERS_H)
2601 #if MAX_NUM_SIZE == 60
2606 if ( ((((
long)ii)==
i) && ((ii << 3) >> 3) == ii )) n=
INT_TO_SR(ii);
2630 if (mpz_cmp_si(a->z,0L)==0)
2632 printf(
"gmp-0 in nlIsZero\n");
2698 if ( ((r << 1) >> 1) == r )
2699 return (number)(long)r;
2717 if ( ((r << 1) >> 1) == r )
2740 number u=((number) ((r>>1)+
SR_INT));
2764 if ( ((r << 1) >> 1) == r )
2766 return (number)(long)r;
2788 mpz_mul(aa->z,a->z,
b->z);
2793 mpz_init_set(a->n,
b->n);
2801 mpz_mul(a->n,a->n,
b->n);
2816 else mpz_init_set(
m, (mpz_ptr)n->z);
2841 mpz_init_set(aa, a->z);
2849 mpz_init_set(bb,
b->z);
2851 mpz_t erg; mpz_t bs; mpz_t bt;
2856 mpz_gcdext(erg, bs, bt, aa, bb);
2858 mpz_div(aa, aa, erg);
2901 rr = mpz_divmod_ui(qq, rrr, a->z, (
unsigned long)
ABS(
SR_TO_INT(
b)));
2915 mpz_divmod(qq, rr, a->z,
b->z);
2935 mpz_gcd(a->z,a->z,
b->z);
2952 mpz_mod(rr,a->z,
b->z);
2953 mpz_sub(a->z,a->z,rr);
2955 mpz_divexact(a->z,a->z,
b->z);
2962 mpz_t
A,
B,C,
D,
E,
N,P,tmp;
2964 else mpz_init_set(P,nP->z);
2965 const mp_bitcnt_t bits=2*(
mpz_size1(P)+1)*GMP_LIMB_BITS;
2968 else mpz_set(
N,nN->z);
2971 mpz_init2(
A,bits); mpz_set_ui(
A,0L);
2972 mpz_init2(
B,bits); mpz_set_ui(
B,1L);
2973 mpz_init2(C,bits); mpz_set_ui(C,0L);
2975 mpz_init2(
E,bits); mpz_set(
E,P);
2976 mpz_init2(tmp,bits);
2981 mpz_add(tmp,tmp,tmp);
2982 if (mpz_cmp(tmp,P)<0)
2991 if (mpz_cmp_ui(tmp,1)==0)
2998 memcpy(z->z,
N,
sizeof(mpz_t));
2999 memcpy(z->n,
B,
sizeof(mpz_t));
3014 mpz_divmod(tmp,
D,
E,
N);
3035 mpz_init((*s)->z); (*s)->s=3;
3037 mpz_init((*t)->z); (*t)->s=3;
3039 mpz_init(
g->z);
g->s=3;
3047 aa=(mpz_ptr)
omAlloc(
sizeof(mpz_t));
3056 bb=(mpz_ptr)
omAlloc(
sizeof(mpz_t));
3063 mpz_gcdext(
g->z,(*s)->z,(*t)->z,aa,bb);
3094 for(
i=rl-1;
i>=0;
i--)
3096 X[
i]=CF->convSingNFactoryN(
x[
i],
FALSE,CF);
3097 Q[
i]=CF->convSingNFactoryN(q[
i],
FALSE,CF);
3104 number n=CF->convFactoryNSingN(xnew,CF);
3107 number
p=CF->convFactoryNSingN(qnew,CF);
3110 else p2=CF->cfDiv(
p,CF->cfInit(2, CF),CF);
3111 if (CF->cfGreater(n,p2,CF))
3113 number n2=CF->cfSub(n,
p,CF);
3114 CF->cfDelete(&n,CF);
3117 CF->cfDelete(&p2,CF);
3118 CF->cfDelete(&
p,CF);
3120 CF->cfNormalize(n,CF);
3124number nlChineseRemainder(number *
x, number *q,
int rl,
const coeffs C)
3135 numberCollectionEnumerator.
Reset();
3137 if( !numberCollectionEnumerator.
MoveNext() )
3152 int normalcount = 0;
3155 number& n = numberCollectionEnumerator.
Current();
3167 }
while (numberCollectionEnumerator.
MoveNext() );
3174 numberCollectionEnumerator.
Reset();
3176 while (numberCollectionEnumerator.
MoveNext() )
3178 number& n = numberCollectionEnumerator.
Current();
3180 if( (--normalcount) <= 0)
3194 numberCollectionEnumerator.
Reset();
3196 while (numberCollectionEnumerator.
MoveNext() )
3198 number& nn = numberCollectionEnumerator.
Current();
3211 numberCollectionEnumerator.
Reset();
3213 while (numberCollectionEnumerator.
MoveNext() )
3215 number& n = numberCollectionEnumerator.
Current();
3226 numberCollectionEnumerator.
Reset();
3228 if( !numberCollectionEnumerator.
MoveNext() )
3251 number& cand1 = numberCollectionEnumerator.
Current();
3261 mpz_init_set(
cand->z, cand1->n);
3266 mpz_lcm(
cand->z,
cand->z, cand1->n);
3271 while (numberCollectionEnumerator.
MoveNext() );
3286 numberCollectionEnumerator.
Reset();
3287 while (numberCollectionEnumerator.
MoveNext() )
3289 number& n = numberCollectionEnumerator.
Current();
3301 numberCollectionEnumerator.
Reset();
3308 while (numberCollectionEnumerator.
MoveNext() )
3310 number &n = numberCollectionEnumerator.
Current();
3318 if (r->cfDiv==
nlDiv)
return (
char*)
"QQ";
3319 else return (
char*)
"ZZ";
3326 #if SIZEOF_LONG == 4
3333 fprintf(d->
f_write,
"4 %d ",nnn);
3338 mpz_init_set_si(tmp,nn);
3349 fprintf(d->
f_write,
"%d ",n->s+5);
3390 #if SIZEOF_LONG == 8
3415 #if SIZEOF_LONG == 8
3421 default:
Werror(
"error in reading number: invalid subtype %d",sub_type);
3485 r->cfSubringGcd =
nlGcd;
3508 r->cfInpNeg =
nlNeg;
3552 r->has_simple_Alloc=
FALSE;
3553 r->has_simple_Inverse=
FALSE;
3560number nlMod(number a, number
b)
3582 mpz_mod(r->z,al->z,bl->z);
3587 LONG ui=(int)mpz_get_si(&r->z);
3588 if ((((ui<<3)>>3)==ui)
3589 && (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...
gmp_complex numbers based on
Coefficient rings, fields and other domains suitable for Singular polynomials.
IEnumerator< number > ICoeffsEnumerator
Abstract interface for an enumerator of number coefficients for an object, e.g. a polynomial.
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
‘factory.h’ is the user interface to Factory.
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)
number nlMapZ(number from, const coeffs, const coeffs dst)
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)
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.