My Project
Loading...
Searching...
No Matches
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)
 
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
 
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
 
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 3096 of file longrat.cc.

3098{
3099 setCharacteristic( 0 ); // only in char 0
3101 CFArray X(rl), Q(rl);
3102 int i;
3103 for(i=rl-1;i>=0;i--)
3104 {
3105 X[i]=CF->convSingNFactoryN(x[i],FALSE,CF); // may be larger MAX_INT
3106 Q[i]=CF->convSingNFactoryN(q[i],FALSE,CF); // may be larger MAX_INT
3107 }
3108 CanonicalForm xnew,qnew;
3109 if (n_SwitchChinRem)
3110 chineseRemainder(X,Q,xnew,qnew);
3111 else
3112 chineseRemainderCached(X,Q,xnew,qnew,inv_cache);
3113 number n=CF->convFactoryNSingN(xnew,CF);
3114 if (sym)
3115 {
3116 number p=CF->convFactoryNSingN(qnew,CF);
3117 number p2;
3118 if (getCoeffType(CF) == n_Q) p2=nlIntDiv(p,nlInit(2, CF),CF);
3119 else p2=CF->cfDiv(p,CF->cfInit(2, CF),CF);
3120 if (CF->cfGreater(n,p2,CF))
3121 {
3122 number n2=CF->cfSub(n,p,CF);
3123 CF->cfDelete(&n,CF);
3124 n=n2;
3125 }
3126 CF->cfDelete(&p2,CF);
3127 CF->cfDelete(&p,CF);
3128 }
3129 CF->cfNormalize(n,CF);
3130 return n;
3131}
#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:4081
int p
Definition: cfModGcd.cc:4077
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:421
VAR int n_SwitchChinRem
Definition: longrat.cc:3095
number nlIntDiv(number a, number b, const coeffs r)
Definition: longrat.cc:939
LINLINE number nlInit(long i, const coeffs r)
Definition: longrat.cc:2607
#define Q
Definition: sirandom.c:26

◆ nlDelete()

void nlDelete ( number *  a,
const coeffs  r 
)

Definition at line 2667 of file longrat.cc.

2668{
2669 if (*a!=NULL)
2670 {
2671 nlTest(*a, r);
2672 if ((SR_HDL(*a) & SR_INT)==0)
2673 {
2674 _nlDelete_NoImm(a);
2675 }
2676 *a=NULL;
2677 }
2678}
#define nlTest(a, r)
Definition: longrat.cc:87
void _nlDelete_NoImm(number *a)
Definition: longrat.cc:1769
#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 1641 of file longrat.cc.

1642{
1643 if (!(SR_HDL(n) & SR_INT))
1644 {
1645 if (n->s==0)
1646 {
1647 nlNormalize(n,r);
1648 }
1649 if (!(SR_HDL(n) & SR_INT))
1650 {
1651 if (n->s!=3)
1652 {
1653 number u=ALLOC_RNUMBER();
1654 u->s=3;
1655#if defined(LDEBUG)
1656 u->debug=123456;
1657#endif
1658 mpz_init_set(u->z,n->n);
1659 u=nlShort3_noinline(u);
1660 return u;
1661 }
1662 }
1663 }
1664 return INT_TO_SR(1);
1665}
#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:1487
#define INT_TO_SR(INT)
Definition: longrat.h:68

◆ nlGetNumerator()

number nlGetNumerator ( number &  n,
const coeffs  r 
)

Definition at line 1670 of file longrat.cc.

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

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

2546{
2547 number z=ALLOC_RNUMBER();
2548#if defined(LDEBUG)
2549 z->debug=123456;
2550#endif
2551 mpz_init_set_si(z->z,(long)i);
2552 mpz_init_set_si(z->n,(long)j);
2553 z->s = 0;
2554 nlNormalize(z,r);
2555 return z;
2556}
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 2558 of file longrat.cc.

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

◆ nlInitChar()

BOOLEAN nlInitChar ( coeffs  r,
void *  p 
)

Definition at line 3476 of file longrat.cc.

3477{
3478 r->is_domain=TRUE;
3479 r->rep=n_rep_gap_rat;
3480
3481 r->nCoeffIsEqual=nlCoeffIsEqual;
3482 //r->cfKillChar = ndKillChar; /* dummy */
3483 //r->cfCoeffString=nlCoeffString;
3484 r->cfCoeffName=nlCoeffName;
3485
3486 r->cfInitMPZ = nlInitMPZ;
3487 r->cfMPZ = nlMPZ;
3488
3489 r->cfMult = nlMult;
3490 r->cfSub = nlSub;
3491 r->cfAdd = nlAdd;
3492 r->cfExactDiv= nlExactDiv;
3493 if (p==NULL) /* Q */
3494 {
3495 r->is_field=TRUE;
3496 r->cfDiv = nlDiv;
3497 //r->cfGcd = ndGcd_dummy;
3498 r->cfSubringGcd = nlGcd;
3499 }
3500 else /* Z: coeffs_BIGINT */
3501 {
3502 r->is_field=FALSE;
3503 r->cfDiv = nlIntDiv;
3504 r->cfIntMod= nlIntMod;
3505 r->cfGcd = nlGcd;
3506 r->cfDivBy=nlDivBy;
3507 r->cfDivComp = nlDivComp;
3508 r->cfIsUnit = nlIsUnit;
3509 r->cfGetUnit = nlGetUnit;
3510 r->cfQuot1 = nlQuot1;
3511 r->cfLcm = nlLcm;
3512 r->cfXExtGcd=nlXExtGcd;
3513 r->cfQuotRem=nlQuotRem;
3514 }
3515 r->cfInit = nlInit;
3516 r->cfSize = nlSize;
3517 r->cfInt = nlInt;
3518
3519 r->cfChineseRemainder=nlChineseRemainderSym;
3520 r->cfFarey=nlFarey;
3521 r->cfInpNeg = nlNeg;
3522 r->cfInvers= nlInvers;
3523 r->cfCopy = nlCopy;
3524 r->cfRePart = nlCopy;
3525 //r->cfImPart = ndReturn0;
3526 r->cfWriteLong = nlWrite;
3527 r->cfRead = nlRead;
3528 r->cfNormalize=nlNormalize;
3529 r->cfGreater = nlGreater;
3530 r->cfEqual = nlEqual;
3531 r->cfIsZero = nlIsZero;
3532 r->cfIsOne = nlIsOne;
3533 r->cfIsMOne = nlIsMOne;
3534 r->cfGreaterZero = nlGreaterZero;
3535 r->cfPower = nlPower;
3536 r->cfGetDenom = nlGetDenom;
3537 r->cfGetNumerator = nlGetNumerator;
3538 r->cfExtGcd = nlExtGcd; // only for ring stuff and Z
3539 r->cfNormalizeHelper = nlNormalizeHelper;
3540 r->cfDelete= nlDelete;
3541 r->cfSetMap = nlSetMap;
3542 //r->cfName = ndName;
3543 r->cfInpMult=nlInpMult;
3544 r->cfInpAdd=nlInpAdd;
3545 //r->cfCoeffWrite=nlCoeffWrite;
3546
3547 r->cfClearContent = nlClearContent;
3548 r->cfClearDenominators = nlClearDenominators;
3549
3550#ifdef LDEBUG
3551 // debug stuff
3552 r->cfDBTest=nlDBTest;
3553#endif
3554 r->convSingNFactoryN=nlConvSingNFactoryN;
3555 r->convFactoryNSingN=nlConvFactoryNSingN;
3556
3557 r->cfRandom=nlRandom;
3558
3559 // io via ssi
3560 r->cfWriteFd=nlWriteFd;
3561 r->cfReadFd=nlReadFd;
3562
3563 //r->type = n_Q;
3564 r->ch = 0;
3565 r->has_simple_Alloc=FALSE;
3566 r->has_simple_Inverse=FALSE;
3567
3568 // variables for this type of coeffs:
3569 // (none)
3570 return FALSE;
3571}
#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:3331
LINLINE void nlInpMult(number &a, number b, const coeffs r)
Definition: longrat.cc:2786
LINLINE BOOLEAN nlEqual(number a, number b, const coeffs r)
Definition: longrat.cc:2598
LINLINE number nlAdd(number la, number li, const coeffs r)
Definition: longrat.cc:2702
long nlInt(number &n, const coeffs r)
Definition: longrat.cc:744
static number nlLcm(number a, number b, const coeffs r)
Definition: longrat.cc:3452
LINLINE number nlSub(number la, number li, const coeffs r)
Definition: longrat.cc:2768
number nlIntMod(number a, number b, const coeffs r)
Definition: longrat.cc:1020
LINLINE number nlCopy(number a, const coeffs r)
Definition: longrat.cc:2654
LINLINE number nlNeg(number za, const coeffs r)
Definition: longrat.cc:2683
number nlXExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition: longrat.cc:2829
void nlPower(number x, int exp, number *lu, const coeffs r)
Definition: longrat.cc:1256
number nlQuotRem(number a, number b, number *r, const coeffs R)
Definition: longrat.cc:2881
number nlFarey(number nN, number nP, const coeffs CF)
Definition: longrat.cc:2969
LINLINE BOOLEAN nlIsOne(number a, const coeffs r)
Definition: longrat.cc:2625
number nlNormalizeHelper(number a, number b, const coeffs r)
Definition: longrat.cc:1531
LINLINE void nlDelete(number *a, const coeffs r)
Definition: longrat.cc:2667
BOOLEAN nlGreaterZero(number za, const coeffs r)
Definition: longrat.cc:1309
LINLINE void nlInpAdd(number &a, number b, const coeffs r)
Definition: longrat.cc:2720
number nlExactDiv(number a, number b, const coeffs r)
Definition: longrat.cc:874
const char * nlRead(const char *s, number *a, const coeffs r)
Definition: longrat0.cc:31
void nlMPZ(mpz_t m, number &n, const coeffs r)
Definition: longrat.cc:2820
number nlInvers(number a, const coeffs r)
Definition: longrat.cc:794
BOOLEAN nlIsUnit(number a, const coeffs)
Definition: longrat.cc:1137
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:3096
int nlDivComp(number a, number b, const coeffs r)
Definition: longrat.cc:1095
char * nlCoeffName(const coeffs r)
Definition: longrat.cc:3325
number nlExtGcd(number a, number b, number *s, number *t, const coeffs)
Definition: longrat.cc:3040
LINLINE number nlMult(number a, number b, const coeffs r)
Definition: longrat.cc:2738
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:3231
LINLINE BOOLEAN nlIsZero(number za, const coeffs r)
Definition: longrat.cc:2634
number nlGetDenom(number &n, const coeffs r)
Definition: longrat.cc:1641
number nlGcd(number a, number b, const coeffs r)
Definition: longrat.cc:1346
number nlReadFd(const ssiInfo *d, const coeffs)
Definition: longrat.cc:3377
int nlSize(number a, const coeffs)
Definition: longrat.cc:715
nMapFunc nlSetMap(const coeffs src, const coeffs dst)
Definition: longrat.cc:2481
BOOLEAN nlDBTest(number a, const char *f, const int l)
number nlDiv(number a, number b, const coeffs r)
Definition: longrat.cc:1146
BOOLEAN nlIsMOne(number a, const coeffs r)
Definition: longrat.cc:1334
static void nlClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
Definition: longrat.cc:3140
number nlGetNumerator(number &n, const coeffs r)
Definition: longrat.cc:1670
BOOLEAN nlCoeffIsEqual(const coeffs r, n_coeffType n, void *p)
Definition: longrat.cc:3440
static CanonicalForm nlConvSingNFactoryN(number n, const BOOLEAN setChar, const coeffs)
Definition: longrat.cc:330
number nlGetUnit(number n, const coeffs cf)
Definition: longrat.cc:1106
coeffs nlQuot1(number c, const coeffs r)
Definition: longrat.cc:1112
BOOLEAN nlGreater(number a, number b, const coeffs r)
Definition: longrat.cc:1319
BOOLEAN nlDivBy(number a, number b, const coeffs)
Definition: longrat.cc:1081
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:3462

◆ nlInpGcd()

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

Definition at line 2934 of file longrat.cc.

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

◆ 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:712
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:806
#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 1578 of file longrat.cc.

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

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

◆ nlNormalize()

void nlNormalize ( number &  x,
const coeffs  r 
)

Definition at line 1487 of file longrat.cc.

1488{
1489 if ((SR_HDL(x) & SR_INT) ||(x==NULL))
1490 return;
1491 if (x->s==3)
1492 {
1494 nlTest(x,r);
1495 return;
1496 }
1497 else if (x->s==0)
1498 {
1499 if (mpz_cmp_si(x->n,1L)==0)
1500 {
1501 mpz_clear(x->n);
1502 x->s=3;
1503 x=nlShort3(x);
1504 }
1505 else
1506 {
1507 mpz_t gcd;
1508 mpz_init(gcd);
1509 mpz_gcd(gcd,x->z,x->n);
1510 x->s=1;
1511 if (mpz_cmp_si(gcd,1L)!=0)
1512 {
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)
1516 {
1517 mpz_clear(x->n);
1518 x->s=3;
1520 }
1521 }
1522 mpz_clear(gcd);
1523 }
1524 }
1525 nlTest(x, r);
1526}
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