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);
437 size = (*f)[0]._mp_size;
455 e=(*f)[0]._mp_exp-
size;
462 void* (*allocfunc) (size_t);
463 mp_get_memory_functions (&allocfunc,
NULL,
NULL);
466 al = dest->_mp_size =
size;
468 dd = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*al);
471 nn = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*bl);
472 memset(nn,0,
sizeof(mp_limb_t)*bl);
476 ndest->_mp_alloc = ndest->_mp_size = bl;
481 al = dest->_mp_size =
size+e;
483 dd = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*al);
484 memset(dd,0,
sizeof(mp_limb_t)*al);
486 for (
i=0;
i<e;
i++) dd[
i] = 0;
491 dest->_mp_alloc = al;
512 if (dst->is_field==
FALSE)
527 WarnS(
"conversion problem in CC -> ZZ mapping");
539 size = (*f)[0]._mp_size;
557 e=(*f)[0]._mp_exp-
size;
564 void* (*allocfunc) (size_t);
565 mp_get_memory_functions (&allocfunc,
NULL,
NULL);
568 al = dest->_mp_size =
size;
570 dd = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*al);
573 nn = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*bl);
574 memset(nn,0,
sizeof(mp_limb_t)*bl);
578 ndest->_mp_alloc = ndest->_mp_size = bl;
583 al = dest->_mp_size =
size+e;
585 dd = (mp_ptr)allocfunc(
sizeof(mp_limb_t)*al);
586 memset(dd,0,
sizeof(mp_limb_t)*al);
588 for (
i=0;
i<e;
i++) dd[
i] = 0;
593 dest->_mp_alloc = al;
678 int s=a->z[0]._mp_alloc;
687 int d=a->n[0]._mp_alloc;
712 long ul=mpz_get_si(
i->z);
713 if (mpz_cmp_si(
i->z,ul)!=0)
return 0;
719 mpz_tdiv_q(tmp,
i->z,
i->n);
724 if (mpz_cmp_si(tmp,ul)!=0) ul=0;
743 mpz_tdiv_q(tmp->z,
i->z,
i->n);
773 mpz_init_set_ui(n->z,1L);
774 mpz_init_set_si(n->n,(
long)
SR_TO_INT(a));
778 mpz_init_set_si(n->z,-1L);
779 mpz_init_set_si(n->n,(
long)-
SR_TO_INT(a));
789 mpz_init_set(n->n,a->z);
795 mpz_init_set(n->z,a->n);
801 if (mpz_cmp_ui(n->n,1L)==0)
814 mpz_init_set_si(n->z,-1L);
818 mpz_init_set_ui(n->z,1L);
873 mpz_divexact(u->z,a->z,
b->z);
918 if (rr<0) rr+=
ABS(bb);
948 mpz_init_set(u->z,a->z);
953 else mpz_sub(u->z,u->z,rr->z);
954 mpz_divexact(u->z,u->z,
b->z);
1001 mpz_init_set_si(aa, ai);
1008 mpz_mod(u->z, aa,
b->z);
1026 mpz_mod(u->z, a->z,
b->z);
1048 return (mpz_divisible_ui_p(a->z,
SR_TO_INT(
b))!=0);
1051 return mpz_divisible_p(a->z,
b->z) != 0;
1073 long ch = r->cfInt(c, r);
1084 mpz_init_set_ui(dummy, ch);
1087 info.exp = (
unsigned long) 1;
1118 if (
j==1L)
return a;
1133 mpz_init_set_si(u->z,(
long)
i);
1134 mpz_init_set_si(u->n,(
long)
j);
1157 if (mpz_cmp(u->z,
b->z)==0)
1163 mpz_init_set(u->n,
b->z);
1172 mpz_init_set(u->n,a->n);
1192 mpz_init_set(u->n,
b->z);
1193 if (a->s<2) mpz_mul(u->n,u->n,a->n);
1194 if (
b->s<2) mpz_mul(u->z,u->z,
b->n);
1202 if (mpz_cmp_si(u->n,1L)==0)
1236 mpz_pow_ui((*u)->z,
x->z,(
unsigned long)
exp);
1239 if (mpz_cmp_si(
x->n,1L)==0)
1247 mpz_pow_ui((*u)->n,
x->n,(
unsigned long)
exp);
1323 if((
i==0L)||(
j==0L))
1346 unsigned long t=mpz_gcd_ui(
NULL,
b->z,(
long)aa);
1356 unsigned long t=mpz_gcd_ui(
NULL,a->z,(
long)bb);
1436 if (mpz_cmp(
x->z,
x->n)==0)
1459 if (mpz_cmp_si(
x->n,1L)==0)
1469 mpz_gcd(
gcd,
x->z,
x->n);
1471 if (mpz_cmp_si(
gcd,1L)!=0)
1473 mpz_divexact(
x->z,
x->z,
gcd);
1474 mpz_divexact(
x->n,
x->n,
gcd);
1475 if (mpz_cmp_si(
x->n,1L)==0)
1513 mpz_gcd(
gcd,a->z,
b->n);
1514 if (mpz_cmp_si(
gcd,1L)!=0)
1518 mpz_divexact(bt,
b->n,
gcd);
1522 mpz_mul(
result->z,bt,a->z);
1554 const unsigned long PP =
p;
1557 number z =
n_Init(
static_cast<long>(mpz_fdiv_ui(q->z, PP)), Zp );
1563 number n =
n_Init(
static_cast<long>(mpz_fdiv_ui(q->n, PP)), Zp );
1592 WarnS(
"Omitted denominator during coefficient mapping !");
1618 mpz_init_set(u->z,n->n);
1645 mpz_init_set(u->z,n->z);
1668 if (a->s!=0)
return FALSE;
1669 number n=
b;
b=a; a=n;
1683 bo=(mpz_cmp(bb,
b->z)==0);
1688 if (((a->s==1) && (
b->s==3))
1689 || ((
b->s==1) && (a->s==3)))
1697 mpz_init_set(aa,a->z);
1698 mpz_init_set(bb,
b->z);
1699 if (a->s<2) mpz_mul(bb,bb,a->n);
1700 if (
b->s<2) mpz_mul(aa,aa,
b->n);
1701 bo=(mpz_cmp(aa,bb)==0);
1720 mpz_init_set(
b->n,a->n);
1722 mpz_init_set(
b->z,a->z);
1744 memset(*a,0,
sizeof(**a));
1763#define GCD_NORM_COND(OLD,NEW) (mpz_size1(NEW->z)>mpz_size1(OLD->z))
1769 mpz_gcd(
gcd,
x->z,
x->n);
1771 if (mpz_cmp_si(
gcd,1L)!=0)
1773 mpz_divexact(
x->z,
x->z,
gcd);
1774 mpz_divexact(
x->n,
x->n,
gcd);
1775 if (mpz_cmp_si(
x->n,1L)==0)
1808 mpz_add(u->z,
b->z,
x);
1816 if (mpz_cmp(u->z,
b->n)==0)
1822 mpz_init_set(u->n,
b->n);
1854 mpz_mul(
x,
b->z,a->n);
1855 mpz_mul(u->z,a->z,
b->n);
1856 mpz_add(u->z,u->z,
x);
1866 mpz_mul(u->n,a->n,
b->n);
1867 if (mpz_cmp(u->z,u->n)==0)
1880 mpz_mul(u->z,
b->z,a->n);
1881 mpz_add(u->z,u->z,a->z);
1888 if (mpz_cmp(u->z,a->n)==0)
1894 mpz_init_set(u->n,a->n);
1909 mpz_mul(u->z,a->z,
b->n);
1910 mpz_add(u->z,u->z,
b->z);
1917 if (mpz_cmp(u->z,
b->n)==0)
1923 mpz_init_set(u->n,
b->n);
1930 mpz_add(u->z,a->z,
b->z);
1955 mpz_add(a->z,a->z,
x);
1989 mpz_add(u->z,
b->z,
x);
1992 mpz_init_set(u->n,
b->n);
2028 mpz_mul(
x,
b->z,a->n);
2029 mpz_mul(
y,a->z,
b->n);
2033 mpz_mul(a->n,a->n,
b->n);
2043 mpz_mul(
x,
b->z,a->n);
2044 mpz_add(a->z,a->z,
x);
2063 mpz_mul(
x,a->z,
b->n);
2064 mpz_add(a->z,
b->z,
x);
2066 mpz_init_set(a->n,
b->n);
2074 mpz_add(a->z,a->z,
b->z);
2103 mpz_sub(u->z,
x,
b->z);
2111 if (mpz_cmp(u->z,
b->n)==0)
2117 mpz_init_set(u->n,
b->n);
2150 mpz_sub(u->z,a->z,
x);
2158 if (mpz_cmp(u->z,a->n)==0)
2164 mpz_init_set(u->n,a->n);
2201 mpz_mul(
x,
b->z,a->n);
2202 mpz_mul(
y,a->z,
b->n);
2213 mpz_mul(u->n,a->n,
b->n);
2214 if (mpz_cmp(u->z,u->n)==0)
2229 mpz_mul(
x,
b->z,a->n);
2230 mpz_sub(u->z,a->z,
x);
2238 if (mpz_cmp(u->z,a->n)==0)
2244 mpz_init_set(u->n,a->n);
2261 mpz_mul(
x,a->z,
b->n);
2262 mpz_sub(u->z,
x,
b->z);
2270 if (mpz_cmp(u->z,
b->n)==0)
2276 mpz_init_set(u->n,
b->n);
2283 mpz_sub(u->z,a->z,
b->z);
2327 if (u->s==1) u->s=0;
2330 mpz_mul_ui(u->z,
b->z,(
unsigned long)
SR_TO_INT(a));
2342 mpz_mul_ui(u->z,
b->z,(
unsigned long)-
SR_TO_INT(a));
2348 if (mpz_cmp(u->z,
b->n)==0)
2354 mpz_init_set(u->n,
b->n);
2364 mpz_mul(u->z,a->z,
b->z);
2374 if (mpz_cmp(u->z,
b->n)==0)
2380 mpz_init_set(u->n,
b->n);
2388 if (mpz_cmp(u->z,a->n)==0)
2394 mpz_init_set(u->n,a->n);
2400 mpz_mul(u->n,a->n,
b->n);
2401 if (mpz_cmp(u->z,u->n)==0)
2450 if ((src->is_field==dst->is_field)
2451 || (src->is_field==
FALSE))
2496 mpz_init_set_si(z->z,
i);
2510 mpz_init_set_si(z->z,(
long)
i);
2511 mpz_init_set_si(z->n,(
long)
j);
2523 mpz_init_set(z->z,
i);
2524 mpz_init_set(z->n,
j);
2550#if defined(DO_LINLINE) || !defined(P_NUMBERS_H)
2569 #if MAX_NUM_SIZE == 60
2574 if ( ((((
long)ii)==
i) && ((ii << 3) >> 3) == ii )) n=
INT_TO_SR(ii);
2598 if (mpz_cmp_si(a->z,0L)==0)
2600 printf(
"gmp-0 in nlIsZero\n");
2666 if ( ((r << 1) >> 1) == r )
2667 return (number)(long)r;
2685 if ( ((r << 1) >> 1) == r )
2708 number u=((number) ((r>>1)+
SR_INT));
2732 if ( ((r << 1) >> 1) == r )
2734 return (number)(long)r;
2756 mpz_mul(aa->z,a->z,
b->z);
2761 mpz_init_set(a->n,
b->n);
2769 mpz_mul(a->n,a->n,
b->n);
2784 else mpz_init_set(
m, (mpz_ptr)n->z);
2809 mpz_init_set(aa, a->z);
2817 mpz_init_set(bb,
b->z);
2819 mpz_t erg; mpz_t bs; mpz_t bt;
2824 mpz_gcdext(erg, bs, bt, aa, bb);
2826 mpz_div(aa, aa, erg);
2869 rr = mpz_divmod_ui(qq, rrr, a->z, (
unsigned long)
ABS(
SR_TO_INT(
b)));
2883 mpz_divmod(qq, rr, a->z,
b->z);
2903 mpz_gcd(a->z,a->z,
b->z);
2920 else mpz_sub(a->z,a->z,rr->z);
2921 mpz_divexact(a->z,a->z,
b->z);
2928 mpz_t
A,
B,C,
D,
E,
N,P,tmp;
2930 else mpz_init_set(P,nP->z);
2931 const mp_bitcnt_t bits=2*(
mpz_size1(P)+1)*GMP_LIMB_BITS;
2934 else mpz_set(
N,nN->z);
2937 mpz_init2(
A,bits); mpz_set_ui(
A,0L);
2938 mpz_init2(
B,bits); mpz_set_ui(
B,1L);
2939 mpz_init2(C,bits); mpz_set_ui(C,0L);
2941 mpz_init2(
E,bits); mpz_set(
E,P);
2942 mpz_init2(tmp,bits);
2947 mpz_add(tmp,tmp,tmp);
2948 if (mpz_cmp(tmp,P)<0)
2957 if (mpz_cmp_ui(tmp,1)==0)
2964 memcpy(z->z,
N,
sizeof(mpz_t));
2965 memcpy(z->n,
B,
sizeof(mpz_t));
2980 mpz_divmod(tmp,
D,
E,
N);
3001 mpz_init((*s)->z); (*s)->s=3;
3003 mpz_init((*t)->z); (*t)->s=3;
3005 mpz_init(
g->z);
g->s=3;
3013 aa=(mpz_ptr)
omAlloc(
sizeof(mpz_t));
3022 bb=(mpz_ptr)
omAlloc(
sizeof(mpz_t));
3029 mpz_gcdext(
g->z,(*s)->z,(*t)->z,aa,bb);
3060 for(
i=rl-1;
i>=0;
i--)
3062 X[
i]=CF->convSingNFactoryN(
x[
i],
FALSE,CF);
3063 Q[
i]=CF->convSingNFactoryN(q[
i],
FALSE,CF);
3070 number n=CF->convFactoryNSingN(xnew,CF);
3073 number
p=CF->convFactoryNSingN(qnew,CF);
3076 else p2=CF->cfDiv(
p,CF->cfInit(2, CF),CF);
3077 if (CF->cfGreater(n,p2,CF))
3079 number n2=CF->cfSub(n,
p,CF);
3080 CF->cfDelete(&n,CF);
3083 CF->cfDelete(&p2,CF);
3084 CF->cfDelete(&
p,CF);
3086 CF->cfNormalize(n,CF);
3090number nlChineseRemainder(number *
x, number *q,
int rl,
const coeffs C)
3101 numberCollectionEnumerator.
Reset();
3103 if( !numberCollectionEnumerator.
MoveNext() )
3118 int normalcount = 0;
3121 number& n = numberCollectionEnumerator.
Current();
3133 }
while (numberCollectionEnumerator.
MoveNext() );
3140 numberCollectionEnumerator.
Reset();
3142 while (numberCollectionEnumerator.
MoveNext() )
3144 number& n = numberCollectionEnumerator.
Current();
3146 if( (--normalcount) <= 0)
3160 numberCollectionEnumerator.
Reset();
3162 while (numberCollectionEnumerator.
MoveNext() )
3164 number& nn = numberCollectionEnumerator.
Current();
3177 numberCollectionEnumerator.
Reset();
3179 while (numberCollectionEnumerator.
MoveNext() )
3181 number& n = numberCollectionEnumerator.
Current();
3192 numberCollectionEnumerator.
Reset();
3194 if( !numberCollectionEnumerator.
MoveNext() )
3217 number& cand1 = numberCollectionEnumerator.
Current();
3227 mpz_init_set(
cand->z, cand1->n);
3232 mpz_lcm(
cand->z,
cand->z, cand1->n);
3237 while (numberCollectionEnumerator.
MoveNext() );
3252 numberCollectionEnumerator.
Reset();
3253 while (numberCollectionEnumerator.
MoveNext() )
3255 number& n = numberCollectionEnumerator.
Current();
3267 numberCollectionEnumerator.
Reset();
3274 while (numberCollectionEnumerator.
MoveNext() )
3276 number &n = numberCollectionEnumerator.
Current();
3284 if (r->cfDiv==
nlDiv)
return (
char*)
"QQ";
3285 else return (
char*)
"ZZ";
3292 #if SIZEOF_LONG == 4
3299 fprintf(d->
f_write,
"4 %d ",nnn);
3304 mpz_init_set_si(tmp,nn);
3315 fprintf(d->
f_write,
"%d ",n->s+5);
3356 #if SIZEOF_LONG == 8
3385 #if SIZEOF_LONG == 8
3391 default:
Werror(
"error in reading number: invalid subtype %d",sub_type);
3455 r->cfSubringGcd =
nlGcd;
3478 r->cfInpNeg =
nlNeg;
3522 r->has_simple_Alloc=
FALSE;
3523 r->has_simple_Inverse=
FALSE;
3530number nlMod(number a, number
b)
3552 mpz_mod(r->z,al->z,bl->z);
3557 LONG ui=(int)mpz_get_si(&r->z);
3558 if ((((ui<<3)>>3)==ui)
3559 && (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
const ExtensionInfo & info
< [in] sqrfree 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)
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)
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.