Data Structures | Macros | Functions
longrat.h File Reference
#include "misc/auxiliary.h"
#include "coeffs/si_gmp.h"
#include "coeffs/coeffs.h"

Go to the source code of this file.

Data Structures

struct  number
 'SR_INT' is the type of those integers small enough to fit into 29 bits. More...
 

Macros

#define SR_HDL(A)   ((long)(A))
 
#define SR_INT   1L
 
#define INT_TO_SR(INT)   ((number) (((long)INT << 2) + SR_INT))
 
#define SR_TO_INT(SR)   (((long)SR) >> 2)
 
#define MP_SMALL   1
 

Functions

number nlGetDenom (number &n, const coeffs r)
 
number nlGetNumerator (number &n, const coeffs r)
 
BOOLEAN nlInitChar (coeffs, void *)
 
static FORCE_INLINE int nlQlogSize (number n, const coeffs r)
 only used by slimgb (tgb.cc) More...
 
static FORCE_INLINE BOOLEAN nlIsInteger (number q, const coeffs r)
 
number nlModP (number q, const coeffs Q, const coeffs Zp)
 
void nlNormalize (number &x, const coeffs r)
 
void nlInpGcd (number &a, number b, const coeffs r)
 
void nlDelete (number *a, 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 More...
 
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 More...
 
void nlGMP (number &i, mpz_t n, const coeffs r)
 
number nlMapGMP (number from, const coeffs src, const coeffs dst)
 
number nlChineseRemainderSym (number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs CF)
 

Data Structure Documentation

◆ snumber

struct snumber

'SR_INT' is the type of those integers small enough to fit into 29 bits.

Therefor the value range of this small integers is: $-2^{28}...2^{28}-1$.

Small integers are represented by an immediate integer handle, containing the value instead of pointing to it, which has the following form:

+-------+-------+-------+-------+- - - -+-------+-------+-------+
| guard | sign  | bit   | bit   |       | bit   | tag   | tag   |
| bit   | bit   | 27    | 26    |       | 0     | 0     | 1     |
+-------+-------+-------+-------+- - - -+-------+-------+-------+

Immediate integers handles carry the tag 'SR_INT', i.e. the last bit is 1. This distuingishes immediate integers from other handles which point to structures aligned on 4 byte boundaries and therefor have last bit zero. (The second bit is reserved as tag to allow extensions of this scheme.) Using immediates as pointers and dereferencing them gives address errors.

To aid overflow check the most significant two bits must always be equal, that is to say that the sign bit of immediate integers has a guard bit.

The macros 'INT_TO_SR' and 'SR_TO_INT' should be used to convert between a small integer value and its representation as immediate integer handle.

Large integers and rationals are represented by z and n where n may be undefined (if s==3) NULL represents only deleted values

Definition at line 49 of file longrat.h.

Data Fields
int debug
mpz_t n
BOOLEAN s parameter s in number: 0 (or FALSE): not normalised rational 1 (or TRUE): normalised rational 3 : integer with n==NULL
mpz_t z

Macro Definition Documentation

◆ INT_TO_SR

#define INT_TO_SR (   INT)    ((number) (((long)INT << 2) + SR_INT))

Definition at line 69 of file longrat.h.

◆ MP_SMALL

#define MP_SMALL   1

Definition at line 72 of file longrat.h.

◆ SR_HDL

#define SR_HDL (   A)    ((long)(A))

Definition at line 66 of file longrat.h.

◆ SR_INT

#define SR_INT   1L

Definition at line 68 of file longrat.h.

◆ SR_TO_INT

#define SR_TO_INT (   SR)    (((long)SR) >> 2)

Definition at line 70 of file longrat.h.

Function Documentation

◆ nlChineseRemainderSym()

number nlChineseRemainderSym ( number *  x,
number *  q,
int  rl,
BOOLEAN  sym,
CFArray inv_cache,
const coeffs  CF 
)

Definition at line 2936 of file longrat.cc.

2938 {
2939  setCharacteristic( 0 ); // only in char 0
2940  Off(SW_RATIONAL);
2941  CFArray X(rl), Q(rl);
2942  int i;
2943  for(i=rl-1;i>=0;i--)
2944  {
2945  X[i]=CF->convSingNFactoryN(x[i],FALSE,CF); // may be larger MAX_INT
2946  Q[i]=CF->convSingNFactoryN(q[i],FALSE,CF); // may be larger MAX_INT
2947  }
2948  CanonicalForm xnew,qnew;
2949  if (n_SwitchChinRem)
2950  chineseRemainder(X,Q,xnew,qnew);
2951  else
2952  chineseRemainderCached(X,Q,xnew,qnew,inv_cache);
2953  number n=CF->convFactoryNSingN(xnew,CF);
2954  if (sym)
2955  {
2956  number p=CF->convFactoryNSingN(qnew,CF);
2957  number p2;
2958  if (getCoeffType(CF) == n_Q) p2=nlIntDiv(p,nlInit(2, CF),CF);
2959  else p2=CF->cfDiv(p,CF->cfInit(2, CF),CF);
2960  if (CF->cfGreater(n,p2,CF))
2961  {
2962  number n2=CF->cfSub(n,p,CF);
2963  CF->cfDelete(&n,CF);
2964  n=n2;
2965  }
2966  CF->cfDelete(&p2,CF);
2967  CF->cfDelete(&p,CF);
2968  }
2969  CF->cfNormalize(n,CF);
2970  return n;
2971 }
void Off(int sw)
switches
#define FALSE
Definition: auxiliary.h:94
rational (GMP) numbers
Definition: coeffs.h:31
int n_SwitchChinRem
Definition: longrat.cc:2935
number nlIntDiv(number a, number b, const coeffs r)
Definition: longrat.cc:796
factory&#39;s main class
Definition: canonicalform.h:77
#define Q
Definition: sirandom.c:25
void setCharacteristic(int c)
Definition: cf_char.cc:23
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
int i
Definition: cfEzgcd.cc:125
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
void chineseRemainderCached(CFArray &a, CFArray &n, CanonicalForm &xnew, CanonicalForm &prod, CFArray &inv)
Definition: cf_chinese.cc:265
void 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...
Definition: cf_chinese.cc:52
Variable x
Definition: cfModGcd.cc:4023
LINLINE number nlInit(long i, const coeffs r)
Definition: longrat.cc:2435
int p
Definition: cfModGcd.cc:4019

◆ nlDelete()

void nlDelete ( number *  a,
const coeffs  r 
)

Definition at line 2495 of file longrat.cc.

2496 {
2497  if (*a!=NULL)
2498  {
2499  nlTest(*a, r);
2500  if ((SR_HDL(*a) & SR_INT)==0)
2501  {
2502  _nlDelete_NoImm(a);
2503  }
2504  *a=NULL;
2505  }
2506 }
void _nlDelete_NoImm(number *a)
Definition: longrat.cc:1627
#define NULL
Definition: omList.c:10
#define SR_INT
Definition: longrat.h:68
#define SR_HDL(A)
Definition: tgb.cc:35
#define nlTest(a, r)
Definition: longrat.cc:93

◆ nlGetDenom()

number nlGetDenom ( number &  n,
const coeffs  r 
)

Definition at line 1499 of file longrat.cc.

1500 {
1501  if (!(SR_HDL(n) & SR_INT))
1502  {
1503  if (n->s==0)
1504  {
1505  nlNormalize(n,r);
1506  }
1507  if (!(SR_HDL(n) & SR_INT))
1508  {
1509  if (n->s!=3)
1510  {
1511  number u=ALLOC_RNUMBER();
1512  u->s=3;
1513 #if defined(LDEBUG)
1514  u->debug=123456;
1515 #endif
1516  mpz_init_set(u->z,n->n);
1517  u=nlShort3_noinline(u);
1518  return u;
1519  }
1520  }
1521  }
1522  return INT_TO_SR(1);
1523 }
#define INT_TO_SR(INT)
Definition: longrat.h:69
number nlShort3_noinline(number x)
Definition: longrat.cc:165
void nlNormalize(number &x, const coeffs r)
Definition: longrat.cc:1345
#define SR_INT
Definition: longrat.h:68
#define ALLOC_RNUMBER()
Definition: coeffs.h:88
#define SR_HDL(A)
Definition: tgb.cc:35

◆ nlGetNumerator()

number nlGetNumerator ( number &  n,
const coeffs  r 
)

Definition at line 1528 of file longrat.cc.

1529 {
1530  if (!(SR_HDL(n) & SR_INT))
1531  {
1532  if (n->s==0)
1533  {
1534  nlNormalize(n,r);
1535  }
1536  if (!(SR_HDL(n) & SR_INT))
1537  {
1538  number u=ALLOC_RNUMBER();
1539 #if defined(LDEBUG)
1540  u->debug=123456;
1541 #endif
1542  u->s=3;
1543  mpz_init_set(u->z,n->z);
1544  if (n->s!=3)
1545  {
1546  u=nlShort3_noinline(u);
1547  }
1548  return u;
1549  }
1550  }
1551  return n; // imm. int
1552 }
number nlShort3_noinline(number x)
Definition: longrat.cc:165
void nlNormalize(number &x, const coeffs r)
Definition: longrat.cc:1345
#define SR_INT
Definition: longrat.h:68
#define ALLOC_RNUMBER()
Definition: coeffs.h:88
#define SR_HDL(A)
Definition: tgb.cc:35

◆ nlGMP()

void nlGMP ( number &  i,
mpz_t  n,
const coeffs  r 
)

Definition at line 1478 of file longrat.cc.

1479 {
1480  // Hier brauche ich einfach die GMP Zahl
1481  nlTest(i, r);
1482  nlNormalize(i, r);
1483  if (SR_HDL(i) & SR_INT)
1484  {
1485  mpz_set_si(n, SR_TO_INT(i));
1486  return;
1487  }
1488  if (i->s!=3)
1489  {
1490  WarnS("Omitted denominator during coefficient mapping !");
1491  }
1492  mpz_set(n, i->z);
1493 }
#define WarnS
Definition: emacs.cc:78
int i
Definition: cfEzgcd.cc:125
#define SR_TO_INT(SR)
Definition: longrat.h:70
void nlNormalize(number &x, const coeffs r)
Definition: longrat.cc:1345
#define SR_INT
Definition: longrat.h:68
#define SR_HDL(A)
Definition: tgb.cc:35
#define nlTest(a, r)
Definition: longrat.cc:93

◆ nlInit2()

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

Definition at line 2373 of file longrat.cc.

2374 {
2375  number z=ALLOC_RNUMBER();
2376 #if defined(LDEBUG)
2377  z->debug=123456;
2378 #endif
2379  mpz_init_set_si(z->z,(long)i);
2380  mpz_init_set_si(z->n,(long)j);
2381  z->s = 0;
2382  nlNormalize(z,r);
2383  return z;
2384 }
int j
Definition: facHensel.cc:105
int i
Definition: cfEzgcd.cc:125
void nlNormalize(number &x, const coeffs r)
Definition: longrat.cc:1345
#define ALLOC_RNUMBER()
Definition: coeffs.h:88

◆ nlInit2gmp()

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

Definition at line 2386 of file longrat.cc.

2387 {
2388  number z=ALLOC_RNUMBER();
2389 #if defined(LDEBUG)
2390  z->debug=123456;
2391 #endif
2392  mpz_init_set(z->z,i);
2393  mpz_init_set(z->n,j);
2394  z->s = 0;
2395  nlNormalize(z,r);
2396  return z;
2397 }
int j
Definition: facHensel.cc:105
int i
Definition: cfEzgcd.cc:125
void nlNormalize(number &x, const coeffs r)
Definition: longrat.cc:1345
#define ALLOC_RNUMBER()
Definition: coeffs.h:88

◆ nlInitChar()

BOOLEAN nlInitChar ( coeffs  ,
void *   
)

Definition at line 3322 of file longrat.cc.

3323 {
3324  r->is_domain=TRUE;
3325  r->rep=n_rep_gap_rat;
3326 
3327  r->nCoeffIsEqual=nlCoeffIsEqual;
3328  //r->cfKillChar = ndKillChar; /* dummy */
3329  r->cfCoeffString=nlCoeffString;
3330  r->cfCoeffName=nlCoeffName;
3331 
3332  r->cfInitMPZ = nlInitMPZ;
3333  r->cfMPZ = nlMPZ;
3334 
3335  r->cfMult = nlMult;
3336  r->cfSub = nlSub;
3337  r->cfAdd = nlAdd;
3338  r->cfExactDiv= nlExactDiv;
3339  if (p==NULL) /* Q */
3340  {
3341  r->is_field=TRUE;
3342  r->cfDiv = nlDiv;
3343  //r->cfGcd = ndGcd_dummy;
3344  r->cfSubringGcd = nlGcd;
3345  }
3346  else /* Z: coeffs_BIGINT */
3347  {
3348  r->is_field=FALSE;
3349  r->cfDiv = nlIntDiv;
3350  r->cfIntMod= nlIntMod;
3351  r->cfGcd = nlGcd;
3352  r->cfDivBy=nlDivBy;
3353  r->cfDivComp = nlDivComp;
3354  r->cfIsUnit = nlIsUnit;
3355  r->cfGetUnit = nlGetUnit;
3356  r->cfQuot1 = nlQuot1;
3357  r->cfLcm = nlLcm;
3358  r->cfXExtGcd=nlXExtGcd;
3359  r->cfQuotRem=nlQuotRem;
3360  }
3361  r->cfInit = nlInit;
3362  r->cfSize = nlSize;
3363  r->cfInt = nlInt;
3364 
3365  r->cfChineseRemainder=nlChineseRemainderSym;
3366  r->cfFarey=nlFarey;
3367  r->cfInpNeg = nlNeg;
3368  r->cfInvers= nlInvers;
3369  r->cfCopy = nlCopy;
3370  r->cfRePart = nlCopy;
3371  //r->cfImPart = ndReturn0;
3372  r->cfWriteLong = nlWrite;
3373  r->cfRead = nlRead;
3374  r->cfNormalize=nlNormalize;
3375  r->cfGreater = nlGreater;
3376  r->cfEqual = nlEqual;
3377  r->cfIsZero = nlIsZero;
3378  r->cfIsOne = nlIsOne;
3379  r->cfIsMOne = nlIsMOne;
3380  r->cfGreaterZero = nlGreaterZero;
3381  r->cfPower = nlPower;
3382  r->cfGetDenom = nlGetDenom;
3383  r->cfGetNumerator = nlGetNumerator;
3384  r->cfExtGcd = nlExtGcd; // only for ring stuff and Z
3385  r->cfNormalizeHelper = nlNormalizeHelper;
3386  r->cfDelete= nlDelete;
3387  r->cfSetMap = nlSetMap;
3388  //r->cfName = ndName;
3389  r->cfInpMult=nlInpMult;
3390  r->cfInpAdd=nlInpAdd;
3391  r->cfCoeffWrite=nlCoeffWrite;
3392 
3393  r->cfClearContent = nlClearContent;
3394  r->cfClearDenominators = nlClearDenominators;
3395 
3396 #ifdef LDEBUG
3397  // debug stuff
3398  r->cfDBTest=nlDBTest;
3399 #endif
3400  r->convSingNFactoryN=nlConvSingNFactoryN;
3401  r->convFactoryNSingN=nlConvFactoryNSingN;
3402 
3403  r->cfRandom=nlRandom;
3404 
3405  // io via ssi
3406  r->cfWriteFd=nlWriteFd;
3407  r->cfReadFd=nlReadFd;
3408 
3409  //r->type = n_Q;
3410  r->ch = 0;
3411  r->has_simple_Alloc=FALSE;
3412  r->has_simple_Inverse=FALSE;
3413 
3414  // variables for this type of coeffs:
3415  // (none)
3416  return FALSE;
3417 }
LINLINE number nlSub(number la, number li, const coeffs r)
Definition: longrat.cc:2596
static void nlClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
Definition: longrat.cc:3071
BOOLEAN nlCoeffIsEqual(const coeffs r, n_coeffType n, void *p)
Definition: longrat.cc:3286
char * nlCoeffName(const coeffs r)
Definition: longrat.cc:3165
static number nlConvFactoryNSingN(const CanonicalForm f, const coeffs r)
Definition: longrat.cc:370
BOOLEAN nlGreaterZero(number za, const coeffs r)
Definition: longrat.cc:1166
#define FALSE
Definition: auxiliary.h:94
static void nlMPZ(mpz_t m, number &n, const coeffs r)
Definition: longrat.cc:2648
number nlNormalizeHelper(number a, number b, const coeffs r)
Definition: longrat.cc:1389
LINLINE void nlInpAdd(number &a, number b, const coeffs r)
Definition: longrat.cc:2548
number nlGetDenom(number &n, const coeffs r)
Definition: longrat.cc:1499
void nlWrite(number a, const coeffs r)
Definition: longrat0.cc:113
int nlSize(number a, const coeffs)
Definition: longrat.cc:570
LINLINE number nlAdd(number la, number li, const coeffs r)
Definition: longrat.cc:2530
BOOLEAN nlIsMOne(number a, const coeffs r)
Definition: longrat.cc:1191
void nlCoeffWrite(const coeffs r, BOOLEAN details)
Definition: longrat.cc:2927
number nlIntDiv(number a, number b, const coeffs r)
Definition: longrat.cc:796
number nlGetUnit(number n, const coeffs cf)
Definition: longrat.cc:963
number nlGcd(number a, number b, const coeffs r)
Definition: longrat.cc:1203
#define TRUE
Definition: auxiliary.h:98
coeffs nlQuot1(number c, const coeffs r)
Definition: longrat.cc:969
const char * nlRead(const char *s, number *a, const coeffs r)
Definition: longrat0.cc:54
number nlIntMod(number a, number b, const coeffs r)
Definition: longrat.cc:877
BOOLEAN nlGreater(number a, number b, const coeffs r)
Definition: longrat.cc:1176
static number nlInitMPZ(mpz_t m, const coeffs)
Definition: longrat.cc:2657
LINLINE BOOLEAN nlIsOne(number a, const coeffs r)
Definition: longrat.cc:2453
static number nlLcm(number a, number b, const coeffs r)
Definition: longrat.cc:3298
LINLINE number nlNeg(number za, const coeffs r)
Definition: longrat.cc:2511
number nlXExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition: longrat.cc:2669
number nlDiv(number a, number b, const coeffs r)
Definition: longrat.cc:1003
LINLINE number nlMult(number a, number b, const coeffs r)
Definition: longrat.cc:2566
number nlInvers(number a, const coeffs r)
Definition: longrat.cc:649
int nlDivComp(number a, number b, const coeffs r)
Definition: longrat.cc:952
LINLINE void nlInpMult(number &a, number b, const coeffs r)
Definition: longrat.cc:2614
static void nlWriteFd(number n, FILE *f, const coeffs)
Definition: longrat.cc:3178
LINLINE BOOLEAN nlEqual(number a, number b, const coeffs r)
Definition: longrat.cc:2426
void nlPower(number x, int exp, number *lu, const coeffs r)
Definition: longrat.cc:1113
number nlQuotRem(number a, number b, number *r, const coeffs R)
Definition: longrat.cc:2721
static number nlReadFd(s_buff f, const coeffs)
Definition: longrat.cc:3224
number nlExtGcd(number a, number b, number *s, number *t, const coeffs)
Definition: longrat.cc:2878
LINLINE BOOLEAN nlIsZero(number za, const coeffs r)
Definition: longrat.cc:2462
static void nlClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
Definition: longrat.cc:2980
static CanonicalForm nlConvSingNFactoryN(number n, const BOOLEAN setChar, const coeffs)
Definition: longrat.cc:332
(number), see longrat.h
Definition: coeffs.h:112
void nlNormalize(number &x, const coeffs r)
Definition: longrat.cc:1345
number nlChineseRemainderSym(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs CF)
Definition: longrat.cc:2936
#define NULL
Definition: omList.c:10
static number nlRandom(siRandProc p, number v2, number, const coeffs cf)
Definition: longrat.cc:3308
LINLINE void nlDelete(number *a, const coeffs r)
Definition: longrat.cc:2495
BOOLEAN nlDivBy(number a, number b, const coeffs)
Definition: longrat.cc:938
BOOLEAN nlIsUnit(number a, const coeffs)
Definition: longrat.cc:994
long nlInt(number &n, const coeffs r)
Definition: longrat.cc:599
nMapFunc nlSetMap(const coeffs src, const coeffs dst)
Definition: longrat.cc:2322
number nlExactDiv(number a, number b, const coeffs r)
Definition: longrat.cc:729
BOOLEAN nlDBTest(number a, const char *f, const int l)
LINLINE number nlInit(long i, const coeffs r)
Definition: longrat.cc:2435
static char * nlCoeffString(const coeffs r)
Definition: longrat.cc:3171
int p
Definition: cfModGcd.cc:4019
number nlGetNumerator(number &n, const coeffs r)
Definition: longrat.cc:1528
LINLINE number nlCopy(number a, const coeffs r)
Definition: longrat.cc:2482
number nlFarey(number nN, number nP, const coeffs CF)
Definition: longrat.cc:2807

◆ nlInpGcd()

void nlInpGcd ( number &  a,
number  b,
const coeffs  r 
)

Definition at line 2774 of file longrat.cc.

2775 {
2776  if ((SR_HDL(b)|SR_HDL(a))&SR_INT)
2777  {
2778  number n=nlGcd(a,b,r);
2779  nlDelete(&a,r);
2780  a=n;
2781  }
2782  else
2783  {
2784  mpz_gcd(a->z,a->z,b->z);
2785  a=nlShort3_noinline(a);
2786  }
2787 }
number nlGcd(number a, number b, const coeffs r)
Definition: longrat.cc:1203
CanonicalForm b
Definition: cfModGcd.cc:4044
number nlShort3_noinline(number x)
Definition: longrat.cc:165
LINLINE void nlDelete(number *a, const coeffs r)
Definition: longrat.cc:2495
#define SR_INT
Definition: longrat.h:68
#define SR_HDL(A)
Definition: tgb.cc:35

◆ nlIsInteger()

static FORCE_INLINE BOOLEAN nlIsInteger ( number  q,
const coeffs  r 
)
static

Definition at line 95 of file longrat.h.

96 {
97  assume( nCoeff_is_Q (r) );
98  n_Test(q, r);
99 
100  if (SR_HDL(q) & SR_INT)
101  return TRUE; // immediate int
102 
103  return ( q->s == 3 );
104 }
#define SR_HDL(A)
Definition: longrat.h:66
#define TRUE
Definition: auxiliary.h:98
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:837
#define assume(x)
Definition: mod2.h:390
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:739
#define SR_INT
Definition: longrat.h:68

◆ nlMapGMP()

number nlMapGMP ( number  from,
const coeffs  src,
const coeffs  dst 
)

Definition at line 201 of file longrat.cc.

202 {
203  number z=ALLOC_RNUMBER();
204 #if defined(LDEBUG)
205  z->debug=123456;
206 #endif
207  mpz_init_set(z->z,(mpz_ptr) from);
208  z->s = 3;
209  z=nlShort3(z);
210  return z;
211 }
static number nlShort3(number x)
Definition: longrat.cc:115
#define ALLOC_RNUMBER()
Definition: coeffs.h:88

◆ nlModP()

number nlModP ( number  q,
const coeffs  Q,
const coeffs  Zp 
)

Definition at line 1436 of file longrat.cc.

1437 {
1438  const int p = n_GetChar(Zp);
1439  assume( p > 0 );
1440 
1441  const long P = p;
1442  assume( P > 0 );
1443 
1444  // embedded long within q => only long numerator has to be converted
1445  // to int (modulo char.)
1446  if (SR_HDL(q) & SR_INT)
1447  {
1448  long i = SR_TO_INT(q);
1449  return n_Init( i, Zp );
1450  }
1451 
1452  const unsigned long PP = p;
1453 
1454  // numerator modulo char. should fit into int
1455  number z = n_Init( static_cast<long>(mpz_fdiv_ui(q->z, PP)), Zp );
1456 
1457  // denominator != 1?
1458  if (q->s!=3)
1459  {
1460  // denominator modulo char. should fit into int
1461  number n = n_Init( static_cast<long>(mpz_fdiv_ui(q->n, PP)), Zp );
1462 
1463  number res = n_Div( z, n, Zp );
1464 
1465  n_Delete(&z, Zp);
1466  n_Delete(&n, Zp);
1467 
1468  return res;
1469  }
1470 
1471  return z;
1472 }
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:539
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:445
CanonicalForm res
Definition: facAbsFact.cc:64
#define assume(x)
Definition: mod2.h:390
int i
Definition: cfEzgcd.cc:125
#define SR_TO_INT(SR)
Definition: longrat.h:70
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:616
#define SR_INT
Definition: longrat.h:68
#define SR_HDL(A)
Definition: tgb.cc:35
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
int p
Definition: cfModGcd.cc:4019

◆ nlNormalize()

void nlNormalize ( number &  x,
const coeffs  r 
)

Definition at line 1345 of file longrat.cc.

1346 {
1347  if ((SR_HDL(x) & SR_INT) ||(x==NULL))
1348  return;
1349  if (x->s==3)
1350  {
1352  nlTest(x,r);
1353  return;
1354  }
1355  else if (x->s==0)
1356  {
1357  if (mpz_cmp_si(x->n,1L)==0)
1358  {
1359  mpz_clear(x->n);
1360  x->s=3;
1361  x=nlShort3(x);
1362  }
1363  else
1364  {
1365  mpz_t gcd;
1366  mpz_init(gcd);
1367  mpz_gcd(gcd,x->z,x->n);
1368  x->s=1;
1369  if (mpz_cmp_si(gcd,1L)!=0)
1370  {
1371  mpz_divexact(x->z,x->z,gcd);
1372  mpz_divexact(x->n,x->n,gcd);
1373  if (mpz_cmp_si(x->n,1L)==0)
1374  {
1375  mpz_clear(x->n);
1376  x->s=3;
1378  }
1379  }
1380  mpz_clear(gcd);
1381  }
1382  }
1383  nlTest(x, r);
1384 }
number nlShort3_noinline(number x)
Definition: longrat.cc:165
#define NULL
Definition: omList.c:10
static number nlShort3(number x)
Definition: longrat.cc:115
int gcd(int a, int b)
Definition: walkSupport.cc:836
#define SR_INT
Definition: longrat.h:68
Variable x
Definition: cfModGcd.cc:4023
#define SR_HDL(A)
Definition: tgb.cc:35
#define nlTest(a, r)
Definition: longrat.cc:93

◆ nlQlogSize()

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

only used by slimgb (tgb.cc)

Definition at line 77 of file longrat.h.

78 {
79  assume( nCoeff_is_Q (r) );
80 
81  if(SR_HDL(n)&SR_INT)
82  {
83  if (SR_HDL(n)==SR_INT) return 0;
84  long i = SR_TO_INT (n);
85  unsigned long v;
86  v = ABS(i);
87  return SI_LOG2(v) + 1;
88  }
89  //assume denominator is 0
90  number nn=(number) n;
91  return mpz_sizeinbase (nn->z, 2);
92 }
#define SR_HDL(A)
Definition: longrat.h:66
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:837
#define assume(x)
Definition: mod2.h:390
int i
Definition: cfEzgcd.cc:125
static int ABS(int v)
Definition: auxiliary.h:110
#define SR_TO_INT(SR)
Definition: longrat.h:70
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define SR_INT
Definition: longrat.h:68
static int SI_LOG2(int v)
Definition: auxiliary.h:119