My Project
Loading...
Searching...
No Matches
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)
 
#define SR_INT   1L
 
#define INT_TO_SR(INT)
 
#define SR_TO_INT(SR)
 
#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.

Therefore 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 distinguishes immediate integers from other handles which point to structures aligned on 4 byte boundaries and therefore 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)
Value:
((number) (((long)INT << 2) + SR_INT))
#define SR_INT
Definition longrat.h:67

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)
Value:
((long)(A))
#define A
Definition sirandom.c:24

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)
Value:
(((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 3087 of file longrat.cc.

3089{
3090 setCharacteristic( 0 ); // only in char 0
3092 CFArray X(rl), Q(rl);
3093 int i;
3094 for(i=rl-1;i>=0;i--)
3095 {
3096 X[i]=CF->convSingNFactoryN(x[i],FALSE,CF); // may be larger MAX_INT
3097 Q[i]=CF->convSingNFactoryN(q[i],FALSE,CF); // may be larger MAX_INT
3098 }
3099 CanonicalForm xnew,qnew;
3100 if (n_SwitchChinRem)
3101 chineseRemainder(X,Q,xnew,qnew);
3102 else
3103 chineseRemainderCached(X,Q,xnew,qnew,inv_cache);
3104 number n=CF->convFactoryNSingN(xnew,CF);
3105 if (sym)
3106 {
3107 number p=CF->convFactoryNSingN(qnew,CF);
3108 number p2;
3109 if (getCoeffType(CF) == n_Q) p2=nlIntDiv(p,nlInit(2, CF),CF);
3110 else p2=CF->cfDiv(p,CF->cfInit(2, CF),CF);
3111 if (CF->cfGreater(n,p2,CF))
3112 {
3113 number n2=CF->cfSub(n,p,CF);
3114 CF->cfDelete(&n,CF);
3115 n=n2;
3116 }
3117 CF->cfDelete(&p2,CF);
3118 CF->cfDelete(&p,CF);
3119 }
3120 CF->cfNormalize(n,CF);
3121 return n;
3122}
#define FALSE
Definition auxiliary.h:97
void Off(int sw)
switches
Array< CanonicalForm > CFArray
void FACTORY_PUBLIC setCharacteristic(int c)
Definition cf_char.cc:28
int i
Definition cfEzgcd.cc:132
Variable x
Definition cfModGcd.cc:4090
int p
Definition cfModGcd.cc:4086
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)
static const int SW_RATIONAL
set to 1 for computations over Q
Definition cf_defs.h:31
factory's main class
@ 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:429
VAR int n_SwitchChinRem
Definition longrat.cc:3086
number nlIntDiv(number a, number b, const coeffs r)
Definition longrat.cc:936
LINLINE number nlInit(long i, const coeffs r)
Definition longrat.cc:2598
#define Q
Definition sirandom.c:26

◆ nlDelete()

void nlDelete ( number * a,
const coeffs r )

Definition at line 2658 of file longrat.cc.

2659{
2660 if (*a!=NULL)
2661 {
2662 nlTest(*a, r);
2663 if ((SR_HDL(*a) & SR_INT)==0)
2664 {
2665 _nlDelete_NoImm(a);
2666 }
2667 *a=NULL;
2668 }
2669}
#define nlTest(a, r)
Definition longrat.cc:87
void _nlDelete_NoImm(number *a)
Definition longrat.cc:1762
#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 1634 of file longrat.cc.

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

◆ nlGetNumerator()

number nlGetNumerator ( number & n,
const coeffs r )

Definition at line 1663 of file longrat.cc.

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

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

2537{
2538 number z=ALLOC_RNUMBER();
2539#if defined(LDEBUG)
2540 z->debug=123456;
2541#endif
2542 mpz_init_set_si(z->z,(long)i);
2543 mpz_init_set_si(z->n,(long)j);
2544 z->s = 0;
2545 nlNormalize(z,r);
2546 return z;
2547}
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 2549 of file longrat.cc.

2550{
2551 number z=ALLOC_RNUMBER();
2552#if defined(LDEBUG)
2553 z->debug=123456;
2554#endif
2555 mpz_init_set(z->z,i);
2556 mpz_init_set(z->n,j);
2557 z->s = 0;
2558 nlNormalize(z,r);
2559 return z;
2560}

◆ nlInitChar()

BOOLEAN nlInitChar ( coeffs r,
void * p )

Definition at line 3463 of file longrat.cc.

3464{
3465 r->is_domain=TRUE;
3466 r->rep=n_rep_gap_rat;
3467
3468 r->nCoeffIsEqual=nlCoeffIsEqual;
3469 //r->cfKillChar = ndKillChar; /* dummy */
3470 //r->cfCoeffString=nlCoeffString;
3471 r->cfCoeffName=nlCoeffName;
3472
3473 r->cfInitMPZ = nlInitMPZ;
3474 r->cfMPZ = nlMPZ;
3475
3476 r->cfMult = nlMult;
3477 r->cfSub = nlSub;
3478 r->cfAdd = nlAdd;
3479 r->cfExactDiv= nlExactDiv;
3480 if (p==NULL) /* Q */
3481 {
3482 r->is_field=TRUE;
3483 r->cfDiv = nlDiv;
3484 //r->cfGcd = ndGcd_dummy;
3485 r->cfSubringGcd = nlGcd;
3486 }
3487 else /* Z: coeffs_BIGINT */
3488 {
3489 r->is_field=FALSE;
3490 r->cfDiv = nlIntDiv;
3491 r->cfIntMod= nlIntMod;
3492 r->cfGcd = nlGcd;
3493 r->cfDivBy=nlDivBy;
3494 r->cfDivComp = nlDivComp;
3495 r->cfIsUnit = nlIsUnit;
3496 r->cfGetUnit = nlGetUnit;
3497 r->cfQuot1 = nlQuot1;
3498 r->cfLcm = nlLcm;
3499 r->cfXExtGcd=nlXExtGcd;
3500 r->cfQuotRem=nlQuotRem;
3501 }
3502 r->cfInit = nlInit;
3503 r->cfSize = nlSize;
3504 r->cfInt = nlInt;
3505
3506 r->cfChineseRemainder=nlChineseRemainderSym;
3507 r->cfFarey=nlFarey;
3508 r->cfInpNeg = nlNeg;
3509 r->cfInvers= nlInvers;
3510 r->cfCopy = nlCopy;
3511 r->cfRePart = nlCopy;
3512 //r->cfImPart = ndReturn0;
3513 r->cfWriteLong = nlWrite;
3514 r->cfRead = nlRead;
3515 r->cfNormalize=nlNormalize;
3516 r->cfGreater = nlGreater;
3517 r->cfEqual = nlEqual;
3518 r->cfIsZero = nlIsZero;
3519 r->cfIsOne = nlIsOne;
3520 r->cfIsMOne = nlIsMOne;
3521 r->cfGreaterZero = nlGreaterZero;
3522 r->cfPower = nlPower;
3523 r->cfGetDenom = nlGetDenom;
3524 r->cfGetNumerator = nlGetNumerator;
3525 r->cfExtGcd = nlExtGcd; // only for ring stuff and Z
3526 r->cfNormalizeHelper = nlNormalizeHelper;
3527 r->cfDelete= nlDelete;
3528 r->cfSetMap = nlSetMap;
3529 //r->cfName = ndName;
3530 r->cfInpMult=nlInpMult;
3531 r->cfInpAdd=nlInpAdd;
3532 //r->cfCoeffWrite=nlCoeffWrite;
3533
3534 r->cfClearContent = nlClearContent;
3535 r->cfClearDenominators = nlClearDenominators;
3536
3537#ifdef LDEBUG
3538 // debug stuff
3539 r->cfDBTest=nlDBTest;
3540#endif
3541 r->convSingNFactoryN=nlConvSingNFactoryN;
3542 r->convFactoryNSingN=nlConvFactoryNSingN;
3543
3544 r->cfRandom=nlRandom;
3545
3546 // io via ssi
3547 r->cfWriteFd=nlWriteFd;
3548 r->cfReadFd=nlReadFd;
3549
3550 //r->type = n_Q;
3551 r->ch = 0;
3552 r->has_simple_Alloc=FALSE;
3553 r->has_simple_Inverse=FALSE;
3554
3555 // variables for this type of coeffs:
3556 // (none)
3557 return FALSE;
3558}
#define TRUE
Definition auxiliary.h:101
@ n_rep_gap_rat
(number), see longrat.h
Definition coeffs.h:118
void nlWriteFd(number n, const ssiInfo *d, const coeffs)
Definition longrat.cc:3322
LINLINE void nlInpMult(number &a, number b, const coeffs r)
Definition longrat.cc:2777
LINLINE BOOLEAN nlEqual(number a, number b, const coeffs r)
Definition longrat.cc:2589
LINLINE number nlAdd(number la, number li, const coeffs r)
Definition longrat.cc:2693
long nlInt(number &n, const coeffs r)
Definition longrat.cc:741
static number nlLcm(number a, number b, const coeffs r)
Definition longrat.cc:3439
LINLINE number nlSub(number la, number li, const coeffs r)
Definition longrat.cc:2759
number nlIntMod(number a, number b, const coeffs r)
Definition longrat.cc:1017
LINLINE number nlCopy(number a, const coeffs r)
Definition longrat.cc:2645
LINLINE number nlNeg(number za, const coeffs r)
Definition longrat.cc:2674
number nlXExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition longrat.cc:2820
void nlPower(number x, int exp, number *lu, const coeffs r)
Definition longrat.cc:1251
number nlQuotRem(number a, number b, number *r, const coeffs R)
Definition longrat.cc:2872
number nlFarey(number nN, number nP, const coeffs CF)
Definition longrat.cc:2960
LINLINE BOOLEAN nlIsOne(number a, const coeffs r)
Definition longrat.cc:2616
number nlNormalizeHelper(number a, number b, const coeffs r)
Definition longrat.cc:1526
LINLINE void nlDelete(number *a, const coeffs r)
Definition longrat.cc:2658
BOOLEAN nlGreaterZero(number za, const coeffs r)
Definition longrat.cc:1304
LINLINE void nlInpAdd(number &a, number b, const coeffs r)
Definition longrat.cc:2711
number nlExactDiv(number a, number b, const coeffs r)
Definition longrat.cc:871
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:2811
number nlInvers(number a, const coeffs r)
Definition longrat.cc:791
BOOLEAN nlIsUnit(number a, const coeffs)
Definition longrat.cc:1132
static number nlConvFactoryNSingN(const CanonicalForm f, const coeffs r)
Definition longrat.cc:365
number nlChineseRemainderSym(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs CF)
Definition longrat.cc:3087
int nlDivComp(number a, number b, const coeffs r)
Definition longrat.cc:1092
char * nlCoeffName(const coeffs r)
Definition longrat.cc:3316
number nlExtGcd(number a, number b, number *s, number *t, const coeffs)
Definition longrat.cc:3031
LINLINE number nlMult(number a, number b, const coeffs r)
Definition longrat.cc:2729
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:3222
LINLINE BOOLEAN nlIsZero(number za, const coeffs r)
Definition longrat.cc:2625
number nlGetDenom(number &n, const coeffs r)
Definition longrat.cc:1634
number nlGcd(number a, number b, const coeffs r)
Definition longrat.cc:1341
number nlReadFd(const ssiInfo *d, const coeffs)
Definition longrat.cc:3368
int nlSize(number a, const coeffs)
Definition longrat.cc:712
nMapFunc nlSetMap(const coeffs src, const coeffs dst)
Definition longrat.cc:2474
BOOLEAN nlDBTest(number a, const char *f, const int l)
number nlDiv(number a, number b, const coeffs r)
Definition longrat.cc:1141
BOOLEAN nlIsMOne(number a, const coeffs r)
Definition longrat.cc:1329
static void nlClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
Definition longrat.cc:3131
number nlGetNumerator(number &n, const coeffs r)
Definition longrat.cc:1663
BOOLEAN nlCoeffIsEqual(const coeffs r, n_coeffType n, void *p)
Definition longrat.cc:3427
static CanonicalForm nlConvSingNFactoryN(number n, const BOOLEAN setChar, const coeffs)
Definition longrat.cc:327
number nlGetUnit(number n, const coeffs cf)
Definition longrat.cc:1103
coeffs nlQuot1(number c, const coeffs r)
Definition longrat.cc:1109
BOOLEAN nlGreater(number a, number b, const coeffs r)
Definition longrat.cc:1314
BOOLEAN nlDivBy(number a, number b, const coeffs)
Definition longrat.cc:1078
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:3449

◆ nlInpGcd()

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

Definition at line 2925 of file longrat.cc.

2926{
2927 if ((SR_HDL(b)|SR_HDL(a))&SR_INT)
2928 {
2929 number n=nlGcd(a,b,r);
2930 nlDelete(&a,r);
2931 a=n;
2932 }
2933 else
2934 {
2935 mpz_gcd(a->z,a->z,b->z);
2936 a=nlShort3_noinline(a);
2937 }
2938}
CanonicalForm b
Definition cfModGcd.cc:4111

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

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

2812{
2813 nlTest(n, r);
2814 nlNormalize(n, r);
2815 if (SR_HDL(n) & SR_INT) mpz_init_set_si(m, SR_TO_INT(n)); /* n fits in an int */
2816 else mpz_init_set(m, (mpz_ptr)n->z);
2817}
int m
Definition cfEzgcd.cc:128

◆ nlNormalize()

void nlNormalize ( number & x,
const coeffs r )

Definition at line 1482 of file longrat.cc.

1483{
1484 if ((SR_HDL(x) & SR_INT) ||(x==NULL))
1485 return;
1486 if (x->s==3)
1487 {
1489 nlTest(x,r);
1490 return;
1491 }
1492 else if (x->s==0)
1493 {
1494 if (mpz_cmp_si(x->n,1L)==0)
1495 {
1496 mpz_clear(x->n);
1497 x->s=3;
1498 x=nlShort3(x);
1499 }
1500 else
1501 {
1502 mpz_t gcd;
1503 mpz_init(gcd);
1504 mpz_gcd(gcd,x->z,x->n);
1505 x->s=1;
1506 if (mpz_cmp_si(gcd,1L)!=0)
1507 {
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)
1511 {
1512 mpz_clear(x->n);
1513 x->s=3;
1515 }
1516 }
1517 mpz_clear(gcd);
1518 }
1519 }
1520 nlTest(x, r);
1521}
static number nlShort3(number x)
Definition longrat.cc:109
int gcd(int a, int b)

◆ 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:113
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
static int SI_LOG2_LONG(long v)
Definition si_log2.h:22