My Project
Data Structures | Macros | Functions
longrat.h File Reference
#include "misc/auxiliary.h"
#include "coeffs/si_gmp.h"
#include "coeffs/coeffs.h"
#include "factory/si_log2.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)
 
void nlMPZ (mpz_t m, number &n, 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...
 
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 48 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 68 of file longrat.h.

◆ MP_SMALL

#define MP_SMALL   1

Definition at line 71 of file longrat.h.

◆ SR_HDL

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

Definition at line 65 of file longrat.h.

◆ SR_INT

#define SR_INT   1L

Definition at line 67 of file longrat.h.

◆ SR_TO_INT

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

Definition at line 69 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 3095 of file longrat.cc.

3097 {
3098  setCharacteristic( 0 ); // only in char 0
3099  Off(SW_RATIONAL);
3100  CFArray X(rl), Q(rl);
3101  int i;
3102  for(i=rl-1;i>=0;i--)
3103  {
3104  X[i]=CF->convSingNFactoryN(x[i],FALSE,CF); // may be larger MAX_INT
3105  Q[i]=CF->convSingNFactoryN(q[i],FALSE,CF); // may be larger MAX_INT
3106  }
3107  CanonicalForm xnew,qnew;
3108  if (n_SwitchChinRem)
3109  chineseRemainder(X,Q,xnew,qnew);
3110  else
3111  chineseRemainderCached(X,Q,xnew,qnew,inv_cache);
3112  number n=CF->convFactoryNSingN(xnew,CF);
3113  if (sym)
3114  {
3115  number p=CF->convFactoryNSingN(qnew,CF);
3116  number p2;
3117  if (getCoeffType(CF) == n_Q) p2=nlIntDiv(p,nlInit(2, CF),CF);
3118  else p2=CF->cfDiv(p,CF->cfInit(2, CF),CF);
3119  if (CF->cfGreater(n,p2,CF))
3120  {
3121  number n2=CF->cfSub(n,p,CF);
3122  CF->cfDelete(&n,CF);
3123  n=n2;
3124  }
3125  CF->cfDelete(&p2,CF);
3126  CF->cfDelete(&p,CF);
3127  }
3128  CF->cfNormalize(n,CF);
3129  return n;
3130 }
#define FALSE
Definition: auxiliary.h:96
void Off(int sw)
switches
void FACTORY_PUBLIC setCharacteristic(int c)
Definition: cf_char.cc:28
int i
Definition: cfEzgcd.cc:132
Variable x
Definition: cfModGcd.cc:4082
int p
Definition: cfModGcd.cc:4078
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,...
Definition: cf_chinese.cc:57
void FACTORY_PUBLIC chineseRemainderCached(const CanonicalForm &x1, const CanonicalForm &q1, const CanonicalForm &x2, const CanonicalForm &q2, CanonicalForm &xnew, CanonicalForm &qnew, CFArray &inv)
Definition: cf_chinese.cc:308
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:31
factory's main class
Definition: canonicalform.h:86
@ n_Q
rational (GMP) numbers
Definition: coeffs.h:30
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
STATIC_VAR jList * Q
Definition: janet.cc:30
VAR int n_SwitchChinRem
Definition: longrat.cc:3094
number nlIntDiv(number a, number b, const coeffs r)
Definition: longrat.cc:938
LINLINE number nlInit(long i, const coeffs r)
Definition: longrat.cc:2606

◆ nlDelete()

void nlDelete ( number *  a,
const coeffs  r 
)

Definition at line 2666 of file longrat.cc.

2667 {
2668  if (*a!=NULL)
2669  {
2670  nlTest(*a, r);
2671  if ((SR_HDL(*a) & SR_INT)==0)
2672  {
2673  _nlDelete_NoImm(a);
2674  }
2675  *a=NULL;
2676  }
2677 }
#define nlTest(a, r)
Definition: longrat.cc:87
void _nlDelete_NoImm(number *a)
Definition: longrat.cc:1768
#define SR_INT
Definition: longrat.h:67
#define NULL
Definition: omList.c:12
#define SR_HDL(A)
Definition: tgb.cc:35

◆ nlGetDenom()

number nlGetDenom ( number &  n,
const coeffs  r 
)

Definition at line 1640 of file longrat.cc.

1641 {
1642  if (!(SR_HDL(n) & SR_INT))
1643  {
1644  if (n->s==0)
1645  {
1646  nlNormalize(n,r);
1647  }
1648  if (!(SR_HDL(n) & SR_INT))
1649  {
1650  if (n->s!=3)
1651  {
1652  number u=ALLOC_RNUMBER();
1653  u->s=3;
1654 #if defined(LDEBUG)
1655  u->debug=123456;
1656 #endif
1657  mpz_init_set(u->z,n->n);
1658  u=nlShort3_noinline(u);
1659  return u;
1660  }
1661  }
1662  }
1663  return INT_TO_SR(1);
1664 }
#define ALLOC_RNUMBER()
Definition: coeffs.h:87
number nlShort3_noinline(number x)
Definition: longrat.cc:159
void nlNormalize(number &x, const coeffs r)
Definition: longrat.cc:1486
#define INT_TO_SR(INT)
Definition: longrat.h:68

◆ nlGetNumerator()

number nlGetNumerator ( number &  n,
const coeffs  r 
)

Definition at line 1669 of file longrat.cc.

1670 {
1671  if (!(SR_HDL(n) & SR_INT))
1672  {
1673  if (n->s==0)
1674  {
1675  nlNormalize(n,r);
1676  }
1677  if (!(SR_HDL(n) & SR_INT))
1678  {
1679  number u=ALLOC_RNUMBER();
1680 #if defined(LDEBUG)
1681  u->debug=123456;
1682 #endif
1683  u->s=3;
1684  mpz_init_set(u->z,n->z);
1685  if (n->s!=3)
1686  {
1687  u=nlShort3_noinline(u);
1688  }
1689  return u;
1690  }
1691  }
1692  return n; // imm. int
1693 }

◆ 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 2544 of file longrat.cc.

2545 {
2546  number z=ALLOC_RNUMBER();
2547 #if defined(LDEBUG)
2548  z->debug=123456;
2549 #endif
2550  mpz_init_set_si(z->z,(long)i);
2551  mpz_init_set_si(z->n,(long)j);
2552  z->s = 0;
2553  nlNormalize(z,r);
2554  return z;
2555 }
int j
Definition: facHensel.cc:110

◆ 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 2557 of file longrat.cc.

2558 {
2559  number z=ALLOC_RNUMBER();
2560 #if defined(LDEBUG)
2561  z->debug=123456;
2562 #endif
2563  mpz_init_set(z->z,i);
2564  mpz_init_set(z->n,j);
2565  z->s = 0;
2566  nlNormalize(z,r);
2567  return z;
2568 }

◆ nlInitChar()

BOOLEAN nlInitChar ( coeffs  r,
void *  p 
)

Definition at line 3475 of file longrat.cc.

3476 {
3477  r->is_domain=TRUE;
3478  r->rep=n_rep_gap_rat;
3479 
3480  r->nCoeffIsEqual=nlCoeffIsEqual;
3481  //r->cfKillChar = ndKillChar; /* dummy */
3482  //r->cfCoeffString=nlCoeffString;
3483  r->cfCoeffName=nlCoeffName;
3484 
3485  r->cfInitMPZ = nlInitMPZ;
3486  r->cfMPZ = nlMPZ;
3487 
3488  r->cfMult = nlMult;
3489  r->cfSub = nlSub;
3490  r->cfAdd = nlAdd;
3491  r->cfExactDiv= nlExactDiv;
3492  if (p==NULL) /* Q */
3493  {
3494  r->is_field=TRUE;
3495  r->cfDiv = nlDiv;
3496  //r->cfGcd = ndGcd_dummy;
3497  r->cfSubringGcd = nlGcd;
3498  }
3499  else /* Z: coeffs_BIGINT */
3500  {
3501  r->is_field=FALSE;
3502  r->cfDiv = nlIntDiv;
3503  r->cfIntMod= nlIntMod;
3504  r->cfGcd = nlGcd;
3505  r->cfDivBy=nlDivBy;
3506  r->cfDivComp = nlDivComp;
3507  r->cfIsUnit = nlIsUnit;
3508  r->cfGetUnit = nlGetUnit;
3509  r->cfQuot1 = nlQuot1;
3510  r->cfLcm = nlLcm;
3511  r->cfXExtGcd=nlXExtGcd;
3512  r->cfQuotRem=nlQuotRem;
3513  }
3514  r->cfInit = nlInit;
3515  r->cfSize = nlSize;
3516  r->cfInt = nlInt;
3517 
3518  r->cfChineseRemainder=nlChineseRemainderSym;
3519  r->cfFarey=nlFarey;
3520  r->cfInpNeg = nlNeg;
3521  r->cfInvers= nlInvers;
3522  r->cfCopy = nlCopy;
3523  r->cfRePart = nlCopy;
3524  //r->cfImPart = ndReturn0;
3525  r->cfWriteLong = nlWrite;
3526  r->cfRead = nlRead;
3527  r->cfNormalize=nlNormalize;
3528  r->cfGreater = nlGreater;
3529  r->cfEqual = nlEqual;
3530  r->cfIsZero = nlIsZero;
3531  r->cfIsOne = nlIsOne;
3532  r->cfIsMOne = nlIsMOne;
3533  r->cfGreaterZero = nlGreaterZero;
3534  r->cfPower = nlPower;
3535  r->cfGetDenom = nlGetDenom;
3536  r->cfGetNumerator = nlGetNumerator;
3537  r->cfExtGcd = nlExtGcd; // only for ring stuff and Z
3538  r->cfNormalizeHelper = nlNormalizeHelper;
3539  r->cfDelete= nlDelete;
3540  r->cfSetMap = nlSetMap;
3541  //r->cfName = ndName;
3542  r->cfInpMult=nlInpMult;
3543  r->cfInpAdd=nlInpAdd;
3544  //r->cfCoeffWrite=nlCoeffWrite;
3545 
3546  r->cfClearContent = nlClearContent;
3547  r->cfClearDenominators = nlClearDenominators;
3548 
3549 #ifdef LDEBUG
3550  // debug stuff
3551  r->cfDBTest=nlDBTest;
3552 #endif
3553  r->convSingNFactoryN=nlConvSingNFactoryN;
3554  r->convFactoryNSingN=nlConvFactoryNSingN;
3555 
3556  r->cfRandom=nlRandom;
3557 
3558  // io via ssi
3559  r->cfWriteFd=nlWriteFd;
3560  r->cfReadFd=nlReadFd;
3561 
3562  //r->type = n_Q;
3563  r->ch = 0;
3564  r->has_simple_Alloc=FALSE;
3565  r->has_simple_Inverse=FALSE;
3566 
3567  // variables for this type of coeffs:
3568  // (none)
3569  return FALSE;
3570 }
#define TRUE
Definition: auxiliary.h:100
@ n_rep_gap_rat
(number), see longrat.h
Definition: coeffs.h:111
void nlWriteFd(number n, const ssiInfo *d, const coeffs)
Definition: longrat.cc:3330
LINLINE void nlInpMult(number &a, number b, const coeffs r)
Definition: longrat.cc:2785
LINLINE BOOLEAN nlEqual(number a, number b, const coeffs r)
Definition: longrat.cc:2597
LINLINE number nlAdd(number la, number li, const coeffs r)
Definition: longrat.cc:2701
long nlInt(number &n, const coeffs r)
Definition: longrat.cc:743
static number nlLcm(number a, number b, const coeffs r)
Definition: longrat.cc:3451
const char * nlRead(const char *s, number *a, const coeffs r)
Definition: longrat0.cc:31
LINLINE number nlSub(number la, number li, const coeffs r)
Definition: longrat.cc:2767
number nlIntMod(number a, number b, const coeffs r)
Definition: longrat.cc:1019
LINLINE number nlCopy(number a, const coeffs r)
Definition: longrat.cc:2653
LINLINE number nlNeg(number za, const coeffs r)
Definition: longrat.cc:2682
number nlXExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition: longrat.cc:2828
void nlPower(number x, int exp, number *lu, const coeffs r)
Definition: longrat.cc:1255
number nlQuotRem(number a, number b, number *r, const coeffs R)
Definition: longrat.cc:2880
number nlFarey(number nN, number nP, const coeffs CF)
Definition: longrat.cc:2968
LINLINE BOOLEAN nlIsOne(number a, const coeffs r)
Definition: longrat.cc:2624
number nlNormalizeHelper(number a, number b, const coeffs r)
Definition: longrat.cc:1530
LINLINE void nlDelete(number *a, const coeffs r)
Definition: longrat.cc:2666
BOOLEAN nlGreaterZero(number za, const coeffs r)
Definition: longrat.cc:1308
LINLINE void nlInpAdd(number &a, number b, const coeffs r)
Definition: longrat.cc:2719
number nlExactDiv(number a, number b, const coeffs r)
Definition: longrat.cc:873
void nlMPZ(mpz_t m, number &n, const coeffs r)
Definition: longrat.cc:2819
number nlInvers(number a, const coeffs r)
Definition: longrat.cc:793
BOOLEAN nlIsUnit(number a, const coeffs)
Definition: longrat.cc:1136
static number nlConvFactoryNSingN(const CanonicalForm f, const coeffs r)
Definition: longrat.cc:368
number nlChineseRemainderSym(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs CF)
Definition: longrat.cc:3095
int nlDivComp(number a, number b, const coeffs r)
Definition: longrat.cc:1094
number nlExtGcd(number a, number b, number *s, number *t, const coeffs)
Definition: longrat.cc:3039
LINLINE number nlMult(number a, number b, const coeffs r)
Definition: longrat.cc:2737
static number nlInitMPZ(mpz_t m, const coeffs)
Definition: longrat.cc:164
static void nlClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
Definition: longrat.cc:3230
LINLINE BOOLEAN nlIsZero(number za, const coeffs r)
Definition: longrat.cc:2633
number nlGetDenom(number &n, const coeffs r)
Definition: longrat.cc:1640
number nlGcd(number a, number b, const coeffs r)
Definition: longrat.cc:1345
number nlReadFd(const ssiInfo *d, const coeffs)
Definition: longrat.cc:3376
int nlSize(number a, const coeffs)
Definition: longrat.cc:714
nMapFunc nlSetMap(const coeffs src, const coeffs dst)
Definition: longrat.cc:2480
char * nlCoeffName(const coeffs r)
Definition: longrat.cc:3324
BOOLEAN nlDBTest(number a, const char *f, const int l)
number nlDiv(number a, number b, const coeffs r)
Definition: longrat.cc:1145
BOOLEAN nlIsMOne(number a, const coeffs r)
Definition: longrat.cc:1333
static void nlClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
Definition: longrat.cc:3139
number nlGetNumerator(number &n, const coeffs r)
Definition: longrat.cc:1669
BOOLEAN nlCoeffIsEqual(const coeffs r, n_coeffType n, void *p)
Definition: longrat.cc:3439
static CanonicalForm nlConvSingNFactoryN(number n, const BOOLEAN setChar, const coeffs)
Definition: longrat.cc:330
number nlGetUnit(number n, const coeffs cf)
Definition: longrat.cc:1105
coeffs nlQuot1(number c, const coeffs r)
Definition: longrat.cc:1111
BOOLEAN nlGreater(number a, number b, const coeffs r)
Definition: longrat.cc:1318
BOOLEAN nlDivBy(number a, number b, const coeffs)
Definition: longrat.cc:1080
void nlWrite(number a, const coeffs r)
Definition: longrat0.cc:90
static number nlRandom(siRandProc p, number v2, number, const coeffs cf)
Definition: longrat.cc:3461

◆ nlInpGcd()

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

Definition at line 2933 of file longrat.cc.

2934 {
2935  if ((SR_HDL(b)|SR_HDL(a))&SR_INT)
2936  {
2937  number n=nlGcd(a,b,r);
2938  nlDelete(&a,r);
2939  a=n;
2940  }
2941  else
2942  {
2943  mpz_gcd(a->z,a->z,b->z);
2944  a=nlShort3_noinline(a);
2945  }
2946 }
CanonicalForm b
Definition: cfModGcd.cc:4103

◆ nlIsInteger()

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

Definition at line 94 of file longrat.h.

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

◆ nlModP()

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

Definition at line 1577 of file longrat.cc.

1578 {
1579  const int p = n_GetChar(Zp);
1580  assume( p > 0 );
1581 
1582  const long P = p;
1583  assume( P > 0 );
1584 
1585  // embedded long within q => only long numerator has to be converted
1586  // to int (modulo char.)
1587  if (SR_HDL(q) & SR_INT)
1588  {
1589  long i = SR_TO_INT(q);
1590  return n_Init( i, Zp );
1591  }
1592 
1593  const unsigned long PP = p;
1594 
1595  // numerator modulo char. should fit into int
1596  number z = n_Init( static_cast<long>(mpz_fdiv_ui(q->z, PP)), Zp );
1597 
1598  // denominator != 1?
1599  if (q->s!=3)
1600  {
1601  // denominator modulo char. should fit into int
1602  number n = n_Init( static_cast<long>(mpz_fdiv_ui(q->n, PP)), Zp );
1603 
1604  number res = n_Div( z, n, Zp );
1605 
1606  n_Delete(&z, Zp);
1607  n_Delete(&n, Zp);
1608 
1609  return res;
1610  }
1611 
1612  return z;
1613 }
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...
Definition: coeffs.h:612
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:441
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:452
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:535
CanonicalForm res
Definition: facAbsFact.cc:60
#define SR_TO_INT(SR)
Definition: longrat.h:69

◆ nlMPZ()

void nlMPZ ( mpz_t  m,
number &  n,
const coeffs  r 
)

Definition at line 2819 of file longrat.cc.

2820 {
2821  nlTest(n, r);
2822  nlNormalize(n, r);
2823  if (SR_HDL(n) & SR_INT) mpz_init_set_si(m, SR_TO_INT(n)); /* n fits in an int */
2824  else mpz_init_set(m, (mpz_ptr)n->z);
2825 }
int m
Definition: cfEzgcd.cc:128

◆ nlNormalize()

void nlNormalize ( number &  x,
const coeffs  r 
)

Definition at line 1486 of file longrat.cc.

1487 {
1488  if ((SR_HDL(x) & SR_INT) ||(x==NULL))
1489  return;
1490  if (x->s==3)
1491  {
1493  nlTest(x,r);
1494  return;
1495  }
1496  else if (x->s==0)
1497  {
1498  if (mpz_cmp_si(x->n,1L)==0)
1499  {
1500  mpz_clear(x->n);
1501  x->s=3;
1502  x=nlShort3(x);
1503  }
1504  else
1505  {
1506  mpz_t gcd;
1507  mpz_init(gcd);
1508  mpz_gcd(gcd,x->z,x->n);
1509  x->s=1;
1510  if (mpz_cmp_si(gcd,1L)!=0)
1511  {
1512  mpz_divexact(x->z,x->z,gcd);
1513  mpz_divexact(x->n,x->n,gcd);
1514  if (mpz_cmp_si(x->n,1L)==0)
1515  {
1516  mpz_clear(x->n);
1517  x->s=3;
1519  }
1520  }
1521  mpz_clear(gcd);
1522  }
1523  }
1524  nlTest(x, r);
1525 }
static number nlShort3(number x)
Definition: longrat.cc:109
int gcd(int a, int b)
Definition: walkSupport.cc:836

◆ nlQlogSize()

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

only used by slimgb (tgb.cc)

Definition at line 76 of file longrat.h.

77 {
78  assume( nCoeff_is_Q (r) );
79 
80  if(SR_HDL(n)&SR_INT)
81  {
82  if (SR_HDL(n)==SR_INT) return 0;
83  long i = SR_TO_INT (n);
84  unsigned long v;
85  v = ABS(i);
86  return SI_LOG2_LONG(v) + 1;
87  }
88  //assume denominator is 0
89  number nn=(number) n;
90  return mpz_sizeinbase (nn->z, 2);
91 }
static int ABS(int v)
Definition: auxiliary.h:112
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
static int SI_LOG2_LONG(long v)
Definition: si_log2.h:22