My Project
Loading...
Searching...
No Matches
Macros | Functions | Variables
longrat.cc File Reference
#include "misc/auxiliary.h"
#include "factory/factory.h"
#include "misc/sirandom.h"
#include "misc/prime.h"
#include "reporter/reporter.h"
#include "coeffs/coeffs.h"
#include "coeffs/numbers.h"
#include "coeffs/rmodulon.h"
#include "coeffs/longrat.h"
#include "coeffs/shortfl.h"
#include "coeffs/modulop.h"
#include "coeffs/mpr_complex.h"
#include <string.h>
#include <float.h>

Go to the source code of this file.

Macros

#define LINLINE
 
#define nlTest(a, r)   nlDBTest(a,__FILE__,__LINE__, r)
 
#define MAX_NUM_SIZE   28
 
#define POW_2_28   (1L<<28)
 
#define POW_2_28_32   (1L<<28)
 
#define LONG   int
 
#define LONGRAT_CC
 
#define BYTES_PER_MP_LIMB   sizeof(mp_limb_t)
 
#define MP_SMALL   1
 
#define mpz_isNeg(A)   ((A)->_mp_size<0)
 
#define mpz_limb_size(A)   ((A)->_mp_size)
 
#define mpz_limb_d(A)   ((A)->_mp_d)
 
#define GCD_NORM_COND(OLD, NEW)   (mpz_size1(NEW->z)>mpz_size1(OLD->z))
 

Functions

LINLINE BOOLEAN nlEqual (number a, number b, const coeffs r)
 
LINLINE number nlInit (long i, const coeffs r)
 
LINLINE BOOLEAN nlIsOne (number a, const coeffs r)
 
LINLINE BOOLEAN nlIsZero (number za, const coeffs r)
 
LINLINE number nlCopy (number a, const coeffs r)
 
LINLINE number nl_Copy (number a, const coeffs r)
 
LINLINE void nlDelete (number *a, const coeffs r)
 
LINLINE number nlNeg (number za, const coeffs r)
 
LINLINE number nlAdd (number la, number li, const coeffs r)
 
LINLINE number nlSub (number la, number li, const coeffs r)
 
LINLINE number nlMult (number a, number b, const coeffs r)
 
LINLINE void nlInpAdd (number &a, number b, const coeffs r)
 
LINLINE void nlInpMult (number &a, number b, const coeffs r)
 
number nlRInit (long i)
 
void nlNormalize (number &x, const coeffs r)
 
number nlGcd (number a, number b, const coeffs r)
 
number nlExtGcd (number a, number b, number *s, number *t, const coeffs)
 
number nlNormalizeHelper (number a, number b, const coeffs r)
 
BOOLEAN nlGreater (number a, number b, const coeffs r)
 
BOOLEAN nlIsMOne (number a, const coeffs r)
 
long nlInt (number &n, const coeffs r)
 
number nlBigInt (number &n)
 
BOOLEAN nlGreaterZero (number za, const coeffs r)
 
number nlInvers (number a, const coeffs r)
 
number nlDiv (number a, number b, const coeffs r)
 
number nlExactDiv (number a, number b, const coeffs r)
 
number nlIntDiv (number a, number b, const coeffs r)
 
number nlIntMod (number a, number b, const coeffs r)
 
void nlPower (number x, int exp, number *lu, const coeffs r)
 
const char * nlRead (const char *s, number *a, const coeffs r)
 
void nlWrite (number a, const coeffs r)
 
number nlFarey (number nN, number nP, const coeffs CF)
 
BOOLEAN nlDBTest (number a, const char *f, const int l)
 
nMapFunc nlSetMap (const coeffs src, const coeffs dst)
 
void nlInpIntDiv (number &a, number b, const coeffs r)
 
BOOLEAN nlDBTest (number a, const char *f, int l, const coeffs r)
 
static number nlShort3 (number x)
 
void _nlDelete_NoImm (number *a)
 
number nlShort3_noinline (number x)
 
static number nlInitMPZ (mpz_t m, const coeffs)
 
void mpz_mul_si (mpz_ptr r, mpz_srcptr s, long int si)
 
static number nlMapP (number from, const coeffs src, const coeffs dst)
 
static number nlMapLongR (number from, const coeffs src, const coeffs dst)
 
static number nlMapR (number from, const coeffs src, const coeffs dst)
 
static number nlMapGMP (number from, const coeffs, const coeffs dst)
 
number nlMapZ (number from, const coeffs, const coeffs dst)
 
number nlMapMachineInt (number from, const coeffs, const coeffs)
 
static CanonicalForm nlConvSingNFactoryN (number n, const BOOLEAN setChar, const coeffs)
 
static number nlConvFactoryNSingN (const CanonicalForm f, const coeffs r)
 
static number nlMapR_BI (number from, const coeffs src, const coeffs dst)
 
static number nlMapLongR_BI (number from, const coeffs src, const coeffs dst)
 
static number nlMapC (number from, const coeffs src, const coeffs dst)
 
int nlSize (number a, const coeffs)
 
number nlBigInt (number &i, const coeffs r)
 
BOOLEAN nlDivBy (number a, number b, const coeffs)
 
int nlDivComp (number a, number b, const coeffs r)
 
number nlGetUnit (number n, const coeffs cf)
 
coeffs nlQuot1 (number c, const coeffs r)
 
BOOLEAN nlIsUnit (number a, const coeffs)
 
static int int_extgcd (int a, int b, int *u, int *x, int *v, int *y)
 
number nlShort1 (number x)
 
number nlModP (number q, const coeffs, const coeffs Zp)
 
void nlGMP (number &i, mpz_t n, const coeffs r)
 
number nlGetDenom (number &n, const coeffs r)
 
number nlGetNumerator (number &n, const coeffs r)
 
BOOLEAN _nlEqual_aNoImm_OR_bNoImm (number a, number b)
 
number _nlCopy_NoImm (number a)
 
number _nlNeg_NoImm (number a)
 
static void nlNormalize_Gcd (number &x)
 
number _nlAdd_aNoImm_OR_bNoImm (number a, number b)
 
void _nlInpAdd_aNoImm_OR_bNoImm (number &a, number b)
 
number _nlSub_aNoImm_OR_bNoImm (number a, number b)
 
number _nlMult_aImm_bImm_rNoImm (number a, number b)
 
number _nlMult_aNoImm_OR_bNoImm (number a, number b)
 
number nlCopyMap (number a, const coeffs, const coeffs)
 
number nlMapQtoZ (number a, const coeffs src, const coeffs dst)
 
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 nlMPZ (mpz_t m, number &n, const coeffs r)
 
number nlXExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
 
number nlQuotRem (number a, number b, number *r, const coeffs R)
 
void nlInpGcd (number &a, number b, const coeffs r)
 
number nlChineseRemainderSym (number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs CF)
 
static void nlClearContent (ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
 
static void nlClearDenominators (ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
 
char * nlCoeffName (const coeffs r)
 
void nlWriteFd (number n, const ssiInfo *d, const coeffs)
 
number nlReadFd (const ssiInfo *d, const coeffs)
 
BOOLEAN nlCoeffIsEqual (const coeffs r, n_coeffType n, void *p)
 
static number nlLcm (number a, number b, const coeffs r)
 
static number nlRandom (siRandProc p, number v2, number, const coeffs cf)
 
BOOLEAN nlInitChar (coeffs r, void *p)
 

Variables

VAR int n_SwitchChinRem =0
 

Macro Definition Documentation

◆ BYTES_PER_MP_LIMB

#define BYTES_PER_MP_LIMB   sizeof(mp_limb_t)

Definition at line 136 of file longrat.cc.

◆ GCD_NORM_COND

#define GCD_NORM_COND (   OLD,
  NEW 
)    (mpz_size1(NEW->z)>mpz_size1(OLD->z))

Definition at line 1797 of file longrat.cc.

◆ LINLINE

#define LINLINE

Definition at line 31 of file longrat.cc.

◆ LONG

#define LONG   int

Definition at line 105 of file longrat.cc.

◆ LONGRAT_CC

#define LONGRAT_CC

Definition at line 133 of file longrat.cc.

◆ MAX_NUM_SIZE

#define MAX_NUM_SIZE   28

Definition at line 102 of file longrat.cc.

◆ MP_SMALL

#define MP_SMALL   1

Definition at line 144 of file longrat.cc.

◆ mpz_isNeg

#define mpz_isNeg (   A)    ((A)->_mp_size<0)

Definition at line 146 of file longrat.cc.

◆ mpz_limb_d

#define mpz_limb_d (   A)    ((A)->_mp_d)

Definition at line 148 of file longrat.cc.

◆ mpz_limb_size

#define mpz_limb_size (   A)    ((A)->_mp_size)

Definition at line 147 of file longrat.cc.

◆ nlTest

#define nlTest (   a,
 
)    nlDBTest(a,__FILE__,__LINE__, r)

Definition at line 87 of file longrat.cc.

◆ POW_2_28

#define POW_2_28   (1L<<28)

Definition at line 103 of file longrat.cc.

◆ POW_2_28_32

#define POW_2_28_32   (1L<<28)

Definition at line 104 of file longrat.cc.

Function Documentation

◆ _nlAdd_aNoImm_OR_bNoImm()

number _nlAdd_aNoImm_OR_bNoImm ( number  a,
number  b 
)

Definition at line 1819 of file longrat.cc.

1820{
1821 number u=ALLOC_RNUMBER();
1822#if defined(LDEBUG)
1823 u->debug=123456;
1824#endif
1825 mpz_init(u->z);
1826 if (SR_HDL(b) & SR_INT)
1827 {
1828 number x=a;
1829 a=b;
1830 b=x;
1831 }
1832 if (SR_HDL(a) & SR_INT)
1833 {
1834 switch (b->s)
1835 {
1836 case 0:
1837 case 1:/* a:short, b:1 */
1838 {
1839 mpz_t x;
1840 mpz_init(x);
1841 mpz_mul_si(x,b->n,SR_TO_INT(a));
1842 mpz_add(u->z,b->z,x);
1843 mpz_clear(x);
1844 if (mpz_sgn1(u->z)==0)
1845 {
1846 mpz_clear(u->z);
1847 FREE_RNUMBER(u);
1848 return INT_TO_SR(0);
1849 }
1850 if (mpz_cmp(u->z,b->n)==0)
1851 {
1852 mpz_clear(u->z);
1853 FREE_RNUMBER(u);
1854 return INT_TO_SR(1);
1855 }
1856 mpz_init_set(u->n,b->n);
1857 u->s = 0;
1858 if (GCD_NORM_COND(b,u)) { nlNormalize_Gcd(u); }
1859 break;
1860 }
1861 case 3:
1862 {
1863 if (((long)a)>0L)
1864 mpz_add_ui(u->z,b->z,SR_TO_INT(a));
1865 else
1866 mpz_sub_ui(u->z,b->z,-SR_TO_INT(a));
1867 u->s = 3;
1868 u=nlShort3(u);
1869 break;
1870 }
1871 }
1872 }
1873 else
1874 {
1875 switch (a->s)
1876 {
1877 case 0:
1878 case 1:
1879 {
1880 switch(b->s)
1881 {
1882 case 0:
1883 case 1:
1884 {
1885 mpz_t x;
1886 mpz_init(x);
1887
1888 mpz_mul(x,b->z,a->n);
1889 mpz_mul(u->z,a->z,b->n);
1890 mpz_add(u->z,u->z,x);
1891 mpz_clear(x);
1892
1893 if (mpz_sgn1(u->z)==0)
1894 {
1895 mpz_clear(u->z);
1896 FREE_RNUMBER(u);
1897 return INT_TO_SR(0);
1898 }
1899 mpz_init(u->n);
1900 mpz_mul(u->n,a->n,b->n);
1901 if (mpz_cmp(u->z,u->n)==0)
1902 {
1903 mpz_clear(u->z);
1904 mpz_clear(u->n);
1905 FREE_RNUMBER(u);
1906 return INT_TO_SR(1);
1907 }
1908 u->s = 0;
1909 if (GCD_NORM_COND(b,u)) { nlNormalize_Gcd(u); }
1910 break;
1911 }
1912 case 3: /* a:1 b:3 */
1913 {
1914 mpz_mul(u->z,b->z,a->n);
1915 mpz_add(u->z,u->z,a->z);
1916 if (mpz_sgn1(u->z)==0)
1917 {
1918 mpz_clear(u->z);
1919 FREE_RNUMBER(u);
1920 return INT_TO_SR(0);
1921 }
1922 if (mpz_cmp(u->z,a->n)==0)
1923 {
1924 mpz_clear(u->z);
1925 FREE_RNUMBER(u);
1926 return INT_TO_SR(1);
1927 }
1928 mpz_init_set(u->n,a->n);
1929 u->s = 0;
1930 if (GCD_NORM_COND(a,u)) { nlNormalize_Gcd(u); }
1931 break;
1932 }
1933 } /*switch (b->s) */
1934 break;
1935 }
1936 case 3:
1937 {
1938 switch(b->s)
1939 {
1940 case 0:
1941 case 1:/* a:3, b:1 */
1942 {
1943 mpz_mul(u->z,a->z,b->n);
1944 mpz_add(u->z,u->z,b->z);
1945 if (mpz_sgn1(u->z)==0)
1946 {
1947 mpz_clear(u->z);
1948 FREE_RNUMBER(u);
1949 return INT_TO_SR(0);
1950 }
1951 if (mpz_cmp(u->z,b->n)==0)
1952 {
1953 mpz_clear(u->z);
1954 FREE_RNUMBER(u);
1955 return INT_TO_SR(1);
1956 }
1957 mpz_init_set(u->n,b->n);
1958 u->s = 0;
1959 if (GCD_NORM_COND(b,u)) { nlNormalize_Gcd(u); }
1960 break;
1961 }
1962 case 3:
1963 {
1964 mpz_add(u->z,a->z,b->z);
1965 u->s = 3;
1966 u=nlShort3(u);
1967 break;
1968 }
1969 }
1970 break;
1971 }
1972 }
1973 }
1974 return u;
1975}
Variable x
Definition: cfModGcd.cc:4082
CanonicalForm b
Definition: cfModGcd.cc:4103
#define ALLOC_RNUMBER()
Definition: coeffs.h:87
#define FREE_RNUMBER(x)
Definition: coeffs.h:86
void mpz_mul_si(mpz_ptr r, mpz_srcptr s, long int si)
Definition: longrat.cc:177
static void nlNormalize_Gcd(number &x)
Definition: longrat.cc:1799
static number nlShort3(number x)
Definition: longrat.cc:109
#define GCD_NORM_COND(OLD, NEW)
Definition: longrat.cc:1797
#define SR_INT
Definition: longrat.h:67
#define INT_TO_SR(INT)
Definition: longrat.h:68
#define SR_TO_INT(SR)
Definition: longrat.h:69
#define mpz_sgn1(A)
Definition: si_gmp.h:18
#define SR_HDL(A)
Definition: tgb.cc:35

◆ _nlCopy_NoImm()

number _nlCopy_NoImm ( number  a)

Definition at line 1747 of file longrat.cc.

1748{
1749 assume(!(SR_HDL(a) & SR_INT));
1750 //nlTest(a, r);
1751 number b=ALLOC_RNUMBER();
1752#if defined(LDEBUG)
1753 b->debug=123456;
1754#endif
1755 switch (a->s)
1756 {
1757 case 0:
1758 case 1:
1759 mpz_init_set(b->n,a->n);
1760 case 3:
1761 mpz_init_set(b->z,a->z);
1762 break;
1763 }
1764 b->s = a->s;
1765 return b;
1766}
#define assume(x)
Definition: mod2.h:389

◆ _nlDelete_NoImm()

void _nlDelete_NoImm ( number *  a)

Definition at line 1768 of file longrat.cc.

1769{
1770 {
1771 switch ((*a)->s)
1772 {
1773 case 0:
1774 case 1:
1775 mpz_clear((*a)->n);
1776 case 3:
1777 mpz_clear((*a)->z);
1778 }
1779 #ifdef LDEBUG
1780 memset(*a,0,sizeof(**a));
1781 #endif
1782 FREE_RNUMBER(*a); // omFreeBin((void *) *a, rnumber_bin);
1783 }
1784}

◆ _nlEqual_aNoImm_OR_bNoImm()

BOOLEAN _nlEqual_aNoImm_OR_bNoImm ( number  a,
number  b 
)

Definition at line 1700 of file longrat.cc.

1701{
1702 assume(! (SR_HDL(a) & SR_HDL(b) & SR_INT));
1703// long - short
1704 BOOLEAN bo;
1705 if (SR_HDL(b) & SR_INT)
1706 {
1707 if (a->s!=0) return FALSE;
1708 number n=b; b=a; a=n;
1709 }
1710// short - long
1711 if (SR_HDL(a) & SR_INT)
1712 {
1713 if (b->s!=0)
1714 return FALSE;
1715 if ((((long)a) > 0L) && (mpz_isNeg(b->z)))
1716 return FALSE;
1717 if ((((long)a) < 0L) && (!mpz_isNeg(b->z)))
1718 return FALSE;
1719 mpz_t bb;
1720 mpz_init(bb);
1721 mpz_mul_si(bb,b->n,(long)SR_TO_INT(a));
1722 bo=(mpz_cmp(bb,b->z)==0);
1723 mpz_clear(bb);
1724 return bo;
1725 }
1726// long - long
1727 if (((a->s==1) && (b->s==3))
1728 || ((b->s==1) && (a->s==3)))
1729 return FALSE;
1730 if (mpz_isNeg(a->z)&&(!mpz_isNeg(b->z)))
1731 return FALSE;
1732 if (mpz_isNeg(b->z)&&(!mpz_isNeg(a->z)))
1733 return FALSE;
1734 mpz_t aa;
1735 mpz_t bb;
1736 mpz_init_set(aa,a->z);
1737 mpz_init_set(bb,b->z);
1738 if (a->s<2) mpz_mul(bb,bb,a->n);
1739 if (b->s<2) mpz_mul(aa,aa,b->n);
1740 bo=(mpz_cmp(aa,bb)==0);
1741 mpz_clear(aa);
1742 mpz_clear(bb);
1743 return bo;
1744}
int BOOLEAN
Definition: auxiliary.h:87
#define FALSE
Definition: auxiliary.h:96
#define mpz_isNeg(A)
Definition: longrat.cc:146

◆ _nlInpAdd_aNoImm_OR_bNoImm()

void _nlInpAdd_aNoImm_OR_bNoImm ( number &  a,
number  b 
)

Definition at line 1977 of file longrat.cc.

1978{
1979 if (SR_HDL(b) & SR_INT)
1980 {
1981 switch (a->s)
1982 {
1983 case 0:
1984 case 1:/* b:short, a:1 */
1985 {
1986 mpz_t x;
1987 mpz_init(x);
1988 mpz_mul_si(x,a->n,SR_TO_INT(b));
1989 mpz_add(a->z,a->z,x);
1990 mpz_clear(x);
1991 nlNormalize_Gcd(a);
1992 break;
1993 }
1994 case 3:
1995 {
1996 if (((long)b)>0L)
1997 mpz_add_ui(a->z,a->z,SR_TO_INT(b));
1998 else
1999 mpz_sub_ui(a->z,a->z,-SR_TO_INT(b));
2000 a->s = 3;
2001 a=nlShort3_noinline(a);
2002 break;
2003 }
2004 }
2005 return;
2006 }
2007 else if (SR_HDL(a) & SR_INT)
2008 {
2009 number u=ALLOC_RNUMBER();
2010 #if defined(LDEBUG)
2011 u->debug=123456;
2012 #endif
2013 mpz_init(u->z);
2014 switch (b->s)
2015 {
2016 case 0:
2017 case 1:/* a:short, b:1 */
2018 {
2019 mpz_t x;
2020 mpz_init(x);
2021
2022 mpz_mul_si(x,b->n,SR_TO_INT(a));
2023 mpz_add(u->z,b->z,x);
2024 mpz_clear(x);
2025 // result cannot be 0, if coeffs are normalized
2026 mpz_init_set(u->n,b->n);
2027 u->s=0;
2028 if (GCD_NORM_COND(b,u)) { nlNormalize_Gcd(u); }
2029 else { u=nlShort1(u); }
2030 break;
2031 }
2032 case 3:
2033 {
2034 if (((long)a)>0L)
2035 mpz_add_ui(u->z,b->z,SR_TO_INT(a));
2036 else
2037 mpz_sub_ui(u->z,b->z,-SR_TO_INT(a));
2038 // result cannot be 0, if coeffs are normalized
2039 u->s = 3;
2040 u=nlShort3_noinline(u);
2041 break;
2042 }
2043 }
2044 a=u;
2045 }
2046 else
2047 {
2048 switch (a->s)
2049 {
2050 case 0:
2051 case 1:
2052 {
2053 switch(b->s)
2054 {
2055 case 0:
2056 case 1: /* a:1 b:1 */
2057 {
2058 mpz_t x;
2059 mpz_t y;
2060 mpz_init(x);
2061 mpz_init(y);
2062 mpz_mul(x,b->z,a->n);
2063 mpz_mul(y,a->z,b->n);
2064 mpz_add(a->z,x,y);
2065 mpz_clear(x);
2066 mpz_clear(y);
2067 mpz_mul(a->n,a->n,b->n);
2068 a->s=0;
2069 if (GCD_NORM_COND(b,a)) { nlNormalize_Gcd(a); }
2070 else { a=nlShort1(a);}
2071 break;
2072 }
2073 case 3: /* a:1 b:3 */
2074 {
2075 mpz_t x;
2076 mpz_init(x);
2077 mpz_mul(x,b->z,a->n);
2078 mpz_add(a->z,a->z,x);
2079 mpz_clear(x);
2080 a->s=0;
2081 if (GCD_NORM_COND(b,a)) { nlNormalize_Gcd(a); }
2082 else { a=nlShort1(a);}
2083 break;
2084 }
2085 } /*switch (b->s) */
2086 break;
2087 }
2088 case 3:
2089 {
2090 switch(b->s)
2091 {
2092 case 0:
2093 case 1:/* a:3, b:1 */
2094 {
2095 mpz_t x;
2096 mpz_init(x);
2097 mpz_mul(x,a->z,b->n);
2098 mpz_add(a->z,b->z,x);
2099 mpz_clear(x);
2100 mpz_init_set(a->n,b->n);
2101 a->s=0;
2102 if (GCD_NORM_COND(b,a)) { nlNormalize_Gcd(a); }
2103 else { a=nlShort1(a);}
2104 break;
2105 }
2106 case 3:
2107 {
2108 mpz_add(a->z,a->z,b->z);
2109 a->s = 3;
2110 a=nlShort3_noinline(a);
2111 break;
2112 }
2113 }
2114 break;
2115 }
2116 }
2117 }
2118}
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:53
number nlShort3_noinline(number x)
Definition: longrat.cc:159
number nlShort1(number x)
Definition: longrat.cc:1465

◆ _nlMult_aImm_bImm_rNoImm()

number _nlMult_aImm_bImm_rNoImm ( number  a,
number  b 
)

Definition at line 2331 of file longrat.cc.

2332{
2333 number u=ALLOC_RNUMBER();
2334#if defined(LDEBUG)
2335 u->debug=123456;
2336#endif
2337 u->s=3;
2338 mpz_init_set_si(u->z,SR_TO_INT(a));
2339 mpz_mul_si(u->z,u->z,SR_TO_INT(b));
2340 return u;
2341}

◆ _nlMult_aNoImm_OR_bNoImm()

number _nlMult_aNoImm_OR_bNoImm ( number  a,
number  b 
)

Definition at line 2344 of file longrat.cc.

2345{
2346 assume(! (SR_HDL(a) & SR_HDL(b) & SR_INT));
2347 number u=ALLOC_RNUMBER();
2348#if defined(LDEBUG)
2349 u->debug=123456;
2350#endif
2351 mpz_init(u->z);
2352 if (SR_HDL(b) & SR_INT)
2353 {
2354 number x=a;
2355 a=b;
2356 b=x;
2357 }
2358 if (SR_HDL(a) & SR_INT)
2359 {
2360 u->s=b->s;
2361 if (u->s==1) u->s=0;
2362 if (((long)a)>0L)
2363 {
2364 mpz_mul_ui(u->z,b->z,(unsigned long)SR_TO_INT(a));
2365 }
2366 else
2367 {
2368 if (a==INT_TO_SR(-1))
2369 {
2370 mpz_set(u->z,b->z);
2371 mpz_neg(u->z,u->z);
2372 u->s=b->s;
2373 }
2374 else
2375 {
2376 mpz_mul_ui(u->z,b->z,(unsigned long)-SR_TO_INT(a));
2377 mpz_neg(u->z,u->z);
2378 }
2379 }
2380 if (u->s<2)
2381 {
2382 if (mpz_cmp(u->z,b->n)==0)
2383 {
2384 mpz_clear(u->z);
2385 FREE_RNUMBER(u);
2386 return INT_TO_SR(1);
2387 }
2388 mpz_init_set(u->n,b->n);
2389 if (GCD_NORM_COND(b,u)) { nlNormalize_Gcd(u); }
2390 }
2391 else //u->s==3
2392 {
2393 u=nlShort3(u);
2394 }
2395 }
2396 else
2397 {
2398 mpz_mul(u->z,a->z,b->z);
2399 u->s = 0;
2400 if(a->s==3)
2401 {
2402 if(b->s==3)
2403 {
2404 u->s = 3;
2405 }
2406 else
2407 {
2408 if (mpz_cmp(u->z,b->n)==0)
2409 {
2410 mpz_clear(u->z);
2411 FREE_RNUMBER(u);
2412 return INT_TO_SR(1);
2413 }
2414 mpz_init_set(u->n,b->n);
2415 if (GCD_NORM_COND(b,u)) { nlNormalize_Gcd(u); }
2416 }
2417 }
2418 else
2419 {
2420 if(b->s==3)
2421 {
2422 if (mpz_cmp(u->z,a->n)==0)
2423 {
2424 mpz_clear(u->z);
2425 FREE_RNUMBER(u);
2426 return INT_TO_SR(1);
2427 }
2428 mpz_init_set(u->n,a->n);
2429 if (GCD_NORM_COND(a,u)) { nlNormalize_Gcd(u); }
2430 }
2431 else
2432 {
2433 mpz_init(u->n);
2434 mpz_mul(u->n,a->n,b->n);
2435 if (mpz_cmp(u->z,u->n)==0)
2436 {
2437 mpz_clear(u->z);
2438 mpz_clear(u->n);
2439 FREE_RNUMBER(u);
2440 return INT_TO_SR(1);
2441 }
2442 if (GCD_NORM_COND(a,u)) { nlNormalize_Gcd(u); }
2443 }
2444 }
2445 }
2446 return u;
2447}

◆ _nlNeg_NoImm()

number _nlNeg_NoImm ( number  a)

Definition at line 1786 of file longrat.cc.

1787{
1788 mpz_neg(a->z,a->z);
1789 if (a->s==3)
1790 {
1791 a=nlShort3(a);
1792 }
1793 return a;
1794}

◆ _nlSub_aNoImm_OR_bNoImm()

number _nlSub_aNoImm_OR_bNoImm ( number  a,
number  b 
)

Definition at line 2120 of file longrat.cc.

2121{
2122 number u=ALLOC_RNUMBER();
2123#if defined(LDEBUG)
2124 u->debug=123456;
2125#endif
2126 mpz_init(u->z);
2127 if (SR_HDL(a) & SR_INT)
2128 {
2129 switch (b->s)
2130 {
2131 case 0:
2132 case 1:/* a:short, b:1 */
2133 {
2134 mpz_t x;
2135 mpz_init(x);
2136 mpz_mul_si(x,b->n,SR_TO_INT(a));
2137 mpz_sub(u->z,x,b->z);
2138 mpz_clear(x);
2139 if (mpz_sgn1(u->z)==0)
2140 {
2141 mpz_clear(u->z);
2142 FREE_RNUMBER(u);
2143 return INT_TO_SR(0);
2144 }
2145 if (mpz_cmp(u->z,b->n)==0)
2146 {
2147 mpz_clear(u->z);
2148 FREE_RNUMBER(u);
2149 return INT_TO_SR(1);
2150 }
2151 mpz_init_set(u->n,b->n);
2152 u->s=0;
2153 if (GCD_NORM_COND(b,u)) { nlNormalize_Gcd(u); }
2154 break;
2155 }
2156 case 3:
2157 {
2158 if (((long)a)>0L)
2159 {
2160 mpz_sub_ui(u->z,b->z,SR_TO_INT(a));
2161 mpz_neg(u->z,u->z);
2162 }
2163 else
2164 {
2165 mpz_add_ui(u->z,b->z,-SR_TO_INT(a));
2166 mpz_neg(u->z,u->z);
2167 }
2168 u->s = 3;
2169 u=nlShort3(u);
2170 break;
2171 }
2172 }
2173 }
2174 else if (SR_HDL(b) & SR_INT)
2175 {
2176 switch (a->s)
2177 {
2178 case 0:
2179 case 1:/* b:short, a:1 */
2180 {
2181 mpz_t x;
2182 mpz_init(x);
2183 mpz_mul_si(x,a->n,SR_TO_INT(b));
2184 mpz_sub(u->z,a->z,x);
2185 mpz_clear(x);
2186 if (mpz_sgn1(u->z)==0)
2187 {
2188 mpz_clear(u->z);
2189 FREE_RNUMBER(u);
2190 return INT_TO_SR(0);
2191 }
2192 if (mpz_cmp(u->z,a->n)==0)
2193 {
2194 mpz_clear(u->z);
2195 FREE_RNUMBER(u);
2196 return INT_TO_SR(1);
2197 }
2198 mpz_init_set(u->n,a->n);
2199 u->s=0;
2200 if (GCD_NORM_COND(a,u)) { nlNormalize_Gcd(u); }
2201 break;
2202 }
2203 case 3:
2204 {
2205 if (((long)b)>0L)
2206 {
2207 mpz_sub_ui(u->z,a->z,SR_TO_INT(b));
2208 }
2209 else
2210 {
2211 mpz_add_ui(u->z,a->z,-SR_TO_INT(b));
2212 }
2213 u->s = 3;
2214 u=nlShort3(u);
2215 break;
2216 }
2217 }
2218 }
2219 else
2220 {
2221 switch (a->s)
2222 {
2223 case 0:
2224 case 1:
2225 {
2226 switch(b->s)
2227 {
2228 case 0:
2229 case 1:
2230 {
2231 mpz_t x;
2232 mpz_t y;
2233 mpz_init(x);
2234 mpz_init(y);
2235 mpz_mul(x,b->z,a->n);
2236 mpz_mul(y,a->z,b->n);
2237 mpz_sub(u->z,y,x);
2238 mpz_clear(x);
2239 mpz_clear(y);
2240 if (mpz_sgn1(u->z)==0)
2241 {
2242 mpz_clear(u->z);
2243 FREE_RNUMBER(u);
2244 return INT_TO_SR(0);
2245 }
2246 mpz_init(u->n);
2247 mpz_mul(u->n,a->n,b->n);
2248 if (mpz_cmp(u->z,u->n)==0)
2249 {
2250 mpz_clear(u->z);
2251 mpz_clear(u->n);
2252 FREE_RNUMBER(u);
2253 return INT_TO_SR(1);
2254 }
2255 u->s=0;
2256 if (GCD_NORM_COND(a,u)) { nlNormalize_Gcd(u); }
2257 break;
2258 }
2259 case 3: /* a:1, b:3 */
2260 {
2261 mpz_t x;
2262 mpz_init(x);
2263 mpz_mul(x,b->z,a->n);
2264 mpz_sub(u->z,a->z,x);
2265 mpz_clear(x);
2266 if (mpz_sgn1(u->z)==0)
2267 {
2268 mpz_clear(u->z);
2269 FREE_RNUMBER(u);
2270 return INT_TO_SR(0);
2271 }
2272 if (mpz_cmp(u->z,a->n)==0)
2273 {
2274 mpz_clear(u->z);
2275 FREE_RNUMBER(u);
2276 return INT_TO_SR(1);
2277 }
2278 mpz_init_set(u->n,a->n);
2279 u->s=0;
2280 if (GCD_NORM_COND(a,u)) { nlNormalize_Gcd(u); }
2281 break;
2282 }
2283 }
2284 break;
2285 }
2286 case 3:
2287 {
2288 switch(b->s)
2289 {
2290 case 0:
2291 case 1: /* a:3, b:1 */
2292 {
2293 mpz_t x;
2294 mpz_init(x);
2295 mpz_mul(x,a->z,b->n);
2296 mpz_sub(u->z,x,b->z);
2297 mpz_clear(x);
2298 if (mpz_sgn1(u->z)==0)
2299 {
2300 mpz_clear(u->z);
2301 FREE_RNUMBER(u);
2302 return INT_TO_SR(0);
2303 }
2304 if (mpz_cmp(u->z,b->n)==0)
2305 {
2306 mpz_clear(u->z);
2307 FREE_RNUMBER(u);
2308 return INT_TO_SR(1);
2309 }
2310 mpz_init_set(u->n,b->n);
2311 u->s=0;
2312 if (GCD_NORM_COND(b,u)) { nlNormalize_Gcd(u); }
2313 break;
2314 }
2315 case 3: /* a:3 , b:3 */
2316 {
2317 mpz_sub(u->z,a->z,b->z);
2318 u->s = 3;
2319 u=nlShort3(u);
2320 break;
2321 }
2322 }
2323 break;
2324 }
2325 }
2326 }
2327 return u;
2328}

◆ int_extgcd()

static int int_extgcd ( int  a,
int  b,
int *  u,
int *  x,
int *  v,
int *  y 
)
static

Definition at line 1415 of file longrat.cc.

1416{
1417 int q, r;
1418 if (a==0)
1419 {
1420 *u = 0;
1421 *v = 1;
1422 *x = -1;
1423 *y = 0;
1424 return b;
1425 }
1426 if (b==0)
1427 {
1428 *u = 1;
1429 *v = 0;
1430 *x = 0;
1431 *y = 1;
1432 return a;
1433 }
1434 *u=1;
1435 *v=0;
1436 *x=0;
1437 *y=1;
1438 do
1439 {
1440 q = a/b;
1441 r = a%b;
1442 assume (q*b+r == a);
1443 a = b;
1444 b = r;
1445
1446 r = -(*v)*q+(*u);
1447 (*u) =(*v);
1448 (*v) = r;
1449
1450 r = -(*y)*q+(*x);
1451 (*x) = (*y);
1452 (*y) = r;
1453 } while (b);
1454
1455 return a;
1456}
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39

◆ mpz_mul_si()

void mpz_mul_si ( mpz_ptr  r,
mpz_srcptr  s,
long int  si 
)

Definition at line 177 of file longrat.cc.

178{
179 if (si>=0)
180 mpz_mul_ui(r,s,si);
181 else
182 {
183 mpz_mul_ui(r,s,-si);
184 mpz_neg(r,r);
185 }
186}
const CanonicalForm int s
Definition: facAbsFact.cc:51

◆ nl_Copy()

LINLINE number nl_Copy ( number  a,
const coeffs  r 
)

◆ nlAdd()

LINLINE number nlAdd ( number  la,
number  li,
const coeffs  r 
)

Definition at line 2701 of file longrat.cc.

2702{
2703 if (SR_HDL(a) & SR_HDL(b) & SR_INT)
2704 {
2705 LONG r=SR_HDL(a)+SR_HDL(b)-1L;
2706 if ( ((r << 1) >> 1) == r )
2707 return (number)(long)r;
2708 else
2709 return nlRInit(SR_TO_INT(r));
2710 }
2711 number u = _nlAdd_aNoImm_OR_bNoImm(a, b);
2712 nlTest(u, R);
2713 return u;
2714}
#define nlTest(a, r)
Definition: longrat.cc:87
number nlRInit(long i)
Definition: longrat.cc:2530
number _nlAdd_aNoImm_OR_bNoImm(number a, number b)
Definition: longrat.cc:1819
#define LONG
Definition: longrat.cc:105
#define R
Definition: sirandom.c:27

◆ nlBigInt() [1/2]

number nlBigInt ( number &  i,
const coeffs  r 
)

Definition at line 775 of file longrat.cc.

776{
777 nlTest(i, r);
778 nlNormalize(i,r);
779 if (SR_HDL(i) & SR_INT) return (i);
780 if (i->s==3)
781 {
782 return nlCopy(i,r);
783 }
784 number tmp=nlRInit(1);
785 mpz_tdiv_q(tmp->z,i->z,i->n);
786 tmp=nlShort3(tmp);
787 return tmp;
788}
int i
Definition: cfEzgcd.cc:132
LINLINE number nlCopy(number a, const coeffs r)
Definition: longrat.cc:2653
void nlNormalize(number &x, const coeffs r)
Definition: longrat.cc:1486

◆ nlBigInt() [2/2]

number nlBigInt ( number &  n)

◆ 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
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}
void Off(int sw)
switches
void FACTORY_PUBLIC setCharacteristic(int c)
Definition: cf_char.cc:28
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
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
#define Q
Definition: sirandom.c:26

◆ nlClearContent()

static void nlClearContent ( ICoeffsEnumerator numberCollectionEnumerator,
number &  c,
const coeffs  cf 
)
static

Definition at line 3139 of file longrat.cc.

3140{
3141 assume(cf != NULL);
3142
3143 numberCollectionEnumerator.Reset();
3144
3145 if( !numberCollectionEnumerator.MoveNext() ) // empty zero polynomial?
3146 {
3147 c = nlInit(1, cf);
3148 return;
3149 }
3150
3151 // all coeffs are given by integers!!!
3152
3153 // part 1, find a small candidate for gcd
3154 number cand1,cand;
3155 int s1,s;
3156 s=2147483647; // max. int
3157
3158 const BOOLEAN lc_is_pos=nlGreaterZero(numberCollectionEnumerator.Current(),cf);
3159
3160 int normalcount = 0;
3161 do
3162 {
3163 number& n = numberCollectionEnumerator.Current();
3164 nlNormalize(n, cf); ++normalcount;
3165 cand1 = n;
3166
3167 if (SR_HDL(cand1)&SR_INT) { cand=cand1; break; }
3168 assume(cand1->s==3); // all coeffs should be integers // ==0?!! after printing
3169 s1=mpz_size1(cand1->z);
3170 if (s>s1)
3171 {
3172 cand=cand1;
3173 s=s1;
3174 }
3175 } while (numberCollectionEnumerator.MoveNext() );
3176
3177// assume( nlGreaterZero(cand,cf) ); // cand may be a negative integer!
3178
3179 cand=nlCopy(cand,cf);
3180 // part 2: compute gcd(cand,all coeffs)
3181
3182 numberCollectionEnumerator.Reset();
3183
3184 while (numberCollectionEnumerator.MoveNext() )
3185 {
3186 number& n = numberCollectionEnumerator.Current();
3187
3188 if( (--normalcount) <= 0)
3189 nlNormalize(n, cf);
3190
3191 nlInpGcd(cand, n, cf);
3193
3194 if(nlIsOne(cand,cf))
3195 {
3196 c = cand;
3197
3198 if(!lc_is_pos)
3199 {
3200 // make the leading coeff positive
3201 c = nlNeg(c, cf);
3202 numberCollectionEnumerator.Reset();
3203
3204 while (numberCollectionEnumerator.MoveNext() )
3205 {
3206 number& nn = numberCollectionEnumerator.Current();
3207 nn = nlNeg(nn, cf);
3208 }
3209 }
3210 return;
3211 }
3212 }
3213
3214 // part3: all coeffs = all coeffs / cand
3215 if (!lc_is_pos)
3216 cand = nlNeg(cand,cf);
3217
3218 c = cand;
3219 numberCollectionEnumerator.Reset();
3220
3221 while (numberCollectionEnumerator.MoveNext() )
3222 {
3223 number& n = numberCollectionEnumerator.Current();
3224 number t=nlExactDiv(n, cand, cf); // simple integer exact division, no ratios to remain
3225 nlDelete(&n, cf);
3226 n = t;
3227 }
3228}
const CanonicalForm const CanonicalForm const CanonicalForm const CanonicalForm & cand
Definition: cfModGcd.cc:69
CanonicalForm cf
Definition: cfModGcd.cc:4083
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...
LINLINE number nlNeg(number za, const coeffs r)
Definition: longrat.cc:2682
LINLINE BOOLEAN nlIsOne(number a, const coeffs r)
Definition: longrat.cc:2624
LINLINE void nlDelete(number *a, const coeffs r)
Definition: longrat.cc:2666
BOOLEAN nlGreaterZero(number za, const coeffs r)
Definition: longrat.cc:1308
number nlExactDiv(number a, number b, const coeffs r)
Definition: longrat.cc:873
void nlInpGcd(number &a, number b, const coeffs r)
Definition: longrat.cc:2933
#define NULL
Definition: omList.c:12
#define mpz_size1(A)
Definition: si_gmp.h:17

◆ nlClearDenominators()

static void nlClearDenominators ( ICoeffsEnumerator numberCollectionEnumerator,
number &  c,
const coeffs  cf 
)
static

Definition at line 3230 of file longrat.cc.

3231{
3232 assume(cf != NULL);
3233
3234 numberCollectionEnumerator.Reset();
3235
3236 if( !numberCollectionEnumerator.MoveNext() ) // empty zero polynomial?
3237 {
3238 c = nlInit(1, cf);
3239// assume( n_GreaterZero(c, cf) );
3240 return;
3241 }
3242
3243 // all coeffs are given by integers after returning from this routine
3244
3245 // part 1, collect product of all denominators /gcds
3246 number cand;
3248#if defined(LDEBUG)
3249 cand->debug=123456;
3250#endif
3251 cand->s=3;
3252
3253 int s=0;
3254
3255 const BOOLEAN lc_is_pos=nlGreaterZero(numberCollectionEnumerator.Current(),cf);
3256
3257 do
3258 {
3259 number& cand1 = numberCollectionEnumerator.Current();
3260
3261 if (!(SR_HDL(cand1)&SR_INT))
3262 {
3263 nlNormalize(cand1, cf);
3264 if ((!(SR_HDL(cand1)&SR_INT)) // not a short int
3265 && (cand1->s==1)) // and is a normalised rational
3266 {
3267 if (s==0) // first denom, we meet
3268 {
3269 mpz_init_set(cand->z, cand1->n); // cand->z = cand1->n
3270 s=1;
3271 }
3272 else // we have already something
3273 {
3274 mpz_lcm(cand->z, cand->z, cand1->n);
3275 }
3276 }
3277 }
3278 }
3279 while (numberCollectionEnumerator.MoveNext() );
3280
3281
3282 if (s==0) // nothing to do, all coeffs are already integers
3283 {
3284// mpz_clear(tmp);
3286 if (lc_is_pos)
3287 c=nlInit(1,cf);
3288 else
3289 {
3290 // make the leading coeff positive
3291 c=nlInit(-1,cf);
3292
3293 // TODO: incorporate the following into the loop below?
3294 numberCollectionEnumerator.Reset();
3295 while (numberCollectionEnumerator.MoveNext() )
3296 {
3297 number& n = numberCollectionEnumerator.Current();
3298 n = nlNeg(n, cf);
3299 }
3300 }
3301// assume( n_GreaterZero(c, cf) );
3302 return;
3303 }
3304
3305 cand = nlShort3(cand);
3306
3307 // part2: all coeffs = all coeffs * cand
3308 // make the lead coeff positive
3309 numberCollectionEnumerator.Reset();
3310
3311 if (!lc_is_pos)
3312 cand = nlNeg(cand, cf);
3313
3314 c = cand;
3315
3316 while (numberCollectionEnumerator.MoveNext() )
3317 {
3318 number &n = numberCollectionEnumerator.Current();
3319 nlInpMult(n, cand, cf);
3320 }
3321
3322}
LINLINE void nlInpMult(number &a, number b, const coeffs r)
Definition: longrat.cc:2785

◆ nlCoeffIsEqual()

BOOLEAN nlCoeffIsEqual ( const coeffs  r,
n_coeffType  n,
void *  p 
)

Definition at line 3439 of file longrat.cc.

3440{
3441 /* test, if r is an instance of nInitCoeffs(n,parameter) */
3442 /* if parameter is not needed */
3443 if (n==r->type)
3444 {
3445 if ((p==NULL)&&(r->cfDiv==nlDiv)) return TRUE;
3446 if ((p!=NULL)&&(r->cfDiv!=nlDiv)) return TRUE;
3447 }
3448 return FALSE;
3449}
#define TRUE
Definition: auxiliary.h:100
number nlDiv(number a, number b, const coeffs r)
Definition: longrat.cc:1145

◆ nlCoeffName()

char * nlCoeffName ( const coeffs  r)

Definition at line 3324 of file longrat.cc.

3325{
3326 if (r->cfDiv==nlDiv) return (char*)"QQ";
3327 else return (char*)"ZZ";
3328}

◆ nlConvFactoryNSingN()

static number nlConvFactoryNSingN ( const CanonicalForm  f,
const coeffs  r 
)
static

Definition at line 368 of file longrat.cc.

369{
370 if (f.isImm())
371 {
372 return nlInit(f.intval(),r);
373 }
374 else
375 {
376 number z = ALLOC_RNUMBER();
377#if defined(LDEBUG)
378 z->debug=123456;
379#endif
380 gmp_numerator( f, z->z );
381 if ( f.den().isOne() )
382 {
383 z->s = 3;
384 z=nlShort3(z);
385 }
386 else
387 {
388 gmp_denominator( f, z->n );
389 z->s = 1;
390 }
391 return z;
392 }
393}
FILE * f
Definition: checklibs.c:9
void gmp_denominator(const CanonicalForm &f, mpz_ptr result)
Definition: singext.cc:40
void gmp_numerator(const CanonicalForm &f, mpz_ptr result)
Definition: singext.cc:20

◆ nlConvSingNFactoryN()

static CanonicalForm nlConvSingNFactoryN ( number  n,
const BOOLEAN  setChar,
const  coeffs 
)
static

Definition at line 330 of file longrat.cc.

331{
332 if (setChar) setCharacteristic( 0 );
333
335 if ( SR_HDL(n) & SR_INT )
336 {
337 long nn=SR_TO_INT(n);
338 term = nn;
339 }
340 else
341 {
342 if ( n->s == 3 )
343 {
344 mpz_t dummy;
345 long lz=mpz_get_si(n->z);
346 if (mpz_cmp_si(n->z,lz)==0) term=lz;
347 else
348 {
349 mpz_init_set( dummy,n->z );
350 term = make_cf( dummy );
351 }
352 }
353 else
354 {
355 // assume s==0 or s==1
356 mpz_t num, den;
358 mpz_init_set( num, n->z );
359 mpz_init_set( den, n->n );
360 term = make_cf( num, den, ( n->s != 1 ));
361 }
362 }
363 return term;
364}
void On(int sw)
switches
CanonicalForm num(const CanonicalForm &f)
CanonicalForm den(const CanonicalForm &f)
Definition: int_poly.h:33
CanonicalForm make_cf(const mpz_ptr n)
Definition: singext.cc:66

◆ nlCopy()

LINLINE number nlCopy ( number  a,
const coeffs  r 
)

Definition at line 2653 of file longrat.cc.

2654{
2655 if (SR_HDL(a) & SR_INT)
2656 {
2657 return a;
2658 }
2659 return _nlCopy_NoImm(a);
2660}
number _nlCopy_NoImm(number a)
Definition: longrat.cc:1747

◆ nlCopyMap()

number nlCopyMap ( number  a,
const  coeffs,
const  coeffs 
)

Definition at line 2452 of file longrat.cc.

2453{
2454 if ((SR_HDL(a) & SR_INT)||(a==NULL))
2455 {
2456 return a;
2457 }
2458 return _nlCopy_NoImm(a);
2459}

◆ nlDBTest() [1/2]

BOOLEAN nlDBTest ( number  a,
const char *  f,
const int  l 
)

◆ nlDBTest() [2/2]

BOOLEAN nlDBTest ( number  a,
const char *  f,
int  l,
const coeffs  r 
)

Definition at line 238 of file longrat.cc.

239{
240 if (a==NULL)
241 {
242 Print("!!longrat: NULL in %s:%d\n",f,l);
243 return FALSE;
244 }
245 //if ((int)a==1) Print("!! 0x1 as number ? %s %d\n",f,l);
246 if ((((long)a)&3L)==3L)
247 {
248 Print(" !!longrat:ptr(3) in %s:%d\n",f,l);
249 return FALSE;
250 }
251 if ((((long)a)&3L)==1L)
252 {
253 if (((((LONG)(long)a)<<1)>>1)!=((LONG)(long)a))
254 {
255 Print(" !!longrat:arith:%lx in %s:%d\n",(long)a, f,l);
256 return FALSE;
257 }
258 return TRUE;
259 }
260 /* TODO: If next line is active, then computations in algebraic field
261 extensions over Q will throw a lot of assume violations although
262 everything is computed correctly and no seg fault appears.
263 Maybe the test is not appropriate in this case. */
264 omCheckIf(omCheckAddrSize(a,sizeof(*a)), return FALSE);
265 if (a->debug!=123456)
266 {
267 Print("!!longrat:debug:%d in %s:%d\n",a->debug,f,l);
268 a->debug=123456;
269 return FALSE;
270 }
271 if ((a->s<0)||(a->s>4))
272 {
273 Print("!!longrat:s=%d in %s:%d\n",a->s,f,l);
274 return FALSE;
275 }
276 /* TODO: If next line is active, then computations in algebraic field
277 extensions over Q will throw a lot of assume violations although
278 everything is computed correctly and no seg fault appears.
279 Maybe the test is not appropriate in this case. */
280 //omCheckAddrSize(a->z[0]._mp_d,a->z[0]._mp_alloc*BYTES_PER_MP_LIMB);
281 if (a->z[0]._mp_alloc==0)
282 Print("!!longrat:z->alloc=0 in %s:%d\n",f,l);
283
284 if (a->s<2)
285 {
286 if ((a->n[0]._mp_d[0]==0)&&(a->n[0]._mp_alloc<=1))
287 {
288 Print("!!longrat: n==0 in %s:%d\n",f,l);
289 return FALSE;
290 }
291 /* TODO: If next line is active, then computations in algebraic field
292 extensions over Q will throw a lot of assume violations although
293 everything is computed correctly and no seg fault appears.
294 Maybe the test is not appropriate in this case. */
295 //omCheckIf(omCheckAddrSize(a->n[0]._mp_d,a->n[0]._mp_alloc*BYTES_PER_MP_LIMB), return FALSE);
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))
299 {
300 Print("!!longrat:integer as rational in %s:%d\n",f,l);
301 mpz_clear(a->n); a->s=3;
302 return FALSE;
303 }
304 else if (mpz_isNeg(a->n))
305 {
306 Print("!!longrat:div. by negative in %s:%d\n",f,l);
307 mpz_neg(a->z,a->z);
308 mpz_neg(a->n,a->n);
309 return FALSE;
310 }
311 return TRUE;
312 }
313 //if (a->s==2)
314 //{
315 // Print("!!longrat:s=2 in %s:%d\n",f,l);
316 // return FALSE;
317 //}
318 if (mpz_size1(a->z)>MP_SMALL) return TRUE;
319 LONG ui=(LONG)mpz_get_si(a->z);
320 if ((((ui<<3)>>3)==ui)
321 && (mpz_cmp_si(a->z,(long)ui)==0))
322 {
323 Print("!!longrat:im int %d in %s:%d\n",ui,f,l);
324 return FALSE;
325 }
326 return TRUE;
327}
int l
Definition: cfEzgcd.cc:100
#define Print
Definition: emacs.cc:80
#define MP_SMALL
Definition: longrat.cc:144
#define omCheckIf(cond, test)
Definition: omAllocDecl.h:323
#define omCheckAddrSize(addr, size)
Definition: omAllocDecl.h:327

◆ nlDelete()

LINLINE 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}
void _nlDelete_NoImm(number *a)
Definition: longrat.cc:1768

◆ nlDiv()

number nlDiv ( number  a,
number  b,
const coeffs  r 
)

Definition at line 1145 of file longrat.cc.

1146{
1147 if (nlIsZero(b,r))
1148 {
1150 return INT_TO_SR(0);
1151 }
1152 number u;
1153// ---------- short / short ------------------------------------
1154 if (SR_HDL(a) & SR_HDL(b) & SR_INT)
1155 {
1156 LONG i=SR_TO_INT(a);
1157 LONG j=SR_TO_INT(b);
1158 if (j==1L) return a;
1159 if ((i==-POW_2_28) && (j== -1L))
1160 {
1161 return nlRInit(POW_2_28);
1162 }
1163 LONG r=i%j;
1164 if (r==0)
1165 {
1166 return INT_TO_SR(i/j);
1167 }
1168 u=ALLOC_RNUMBER();
1169 u->s=0;
1170 #if defined(LDEBUG)
1171 u->debug=123456;
1172 #endif
1173 mpz_init_set_si(u->z,(long)i);
1174 mpz_init_set_si(u->n,(long)j);
1175 }
1176 else
1177 {
1178 u=ALLOC_RNUMBER();
1179 u->s=0;
1180 #if defined(LDEBUG)
1181 u->debug=123456;
1182 #endif
1183 mpz_init(u->z);
1184// ---------- short / long ------------------------------------
1185 if (SR_HDL(a) & SR_INT)
1186 {
1187 // short a / (z/n) -> (a*n)/z
1188 if (b->s<2)
1189 {
1190 mpz_mul_si(u->z,b->n,SR_TO_INT(a));
1191 }
1192 else
1193 // short a / long z -> a/z
1194 {
1195 mpz_set_si(u->z,SR_TO_INT(a));
1196 }
1197 if (mpz_cmp(u->z,b->z)==0)
1198 {
1199 mpz_clear(u->z);
1200 FREE_RNUMBER(u);
1201 return INT_TO_SR(1);
1202 }
1203 mpz_init_set(u->n,b->z);
1204 }
1205// ---------- long / short ------------------------------------
1206 else if (SR_HDL(b) & SR_INT)
1207 {
1208 mpz_set(u->z,a->z);
1209 // (z/n) / b -> z/(n*b)
1210 if (a->s<2)
1211 {
1212 mpz_init_set(u->n,a->n);
1213 if (((long)b)>0L)
1214 mpz_mul_ui(u->n,u->n,SR_TO_INT(b));
1215 else
1216 {
1217 mpz_mul_ui(u->n,u->n,-SR_TO_INT(b));
1218 mpz_neg(u->z,u->z);
1219 }
1220 }
1221 else
1222 // long z / short b -> z/b
1223 {
1224 //mpz_set(u->z,a->z);
1225 mpz_init_set_si(u->n,SR_TO_INT(b));
1226 }
1227 }
1228// ---------- long / long ------------------------------------
1229 else
1230 {
1231 mpz_set(u->z,a->z);
1232 mpz_init_set(u->n,b->z);
1233 if (a->s<2) mpz_mul(u->n,u->n,a->n);
1234 if (b->s<2) mpz_mul(u->z,u->z,b->n);
1235 }
1236 }
1237 if (mpz_isNeg(u->n))
1238 {
1239 mpz_neg(u->z,u->z);
1240 mpz_neg(u->n,u->n);
1241 }
1242 if (mpz_cmp_si(u->n,1L)==0)
1243 {
1244 mpz_clear(u->n);
1245 u->s=3;
1246 u=nlShort3(u);
1247 }
1248 nlTest(u, r);
1249 return u;
1250}
int j
Definition: facHensel.cc:110
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define POW_2_28
Definition: longrat.cc:103
LINLINE BOOLEAN nlIsZero(number za, const coeffs r)
Definition: longrat.cc:2633
const char *const nDivBy0
Definition: numbers.h:89

◆ nlDivBy()

BOOLEAN nlDivBy ( number  a,
number  b,
const  coeffs 
)

Definition at line 1080 of file longrat.cc.

1081{
1082 if (SR_HDL(a) & SR_HDL(b) & SR_INT)
1083 {
1084 return ((SR_TO_INT(a) % SR_TO_INT(b))==0);
1085 }
1086 if (SR_HDL(b) & SR_INT)
1087 {
1088 return (mpz_divisible_ui_p(a->z,SR_TO_INT(b))!=0);
1089 }
1090 if (SR_HDL(a) & SR_INT) return FALSE;
1091 return mpz_divisible_p(a->z, b->z) != 0;
1092}

◆ nlDivComp()

int nlDivComp ( number  a,
number  b,
const coeffs  r 
)

Definition at line 1094 of file longrat.cc.

1095{
1096 if (nlDivBy(a, b, r))
1097 {
1098 if (nlDivBy(b, a, r)) return 2;
1099 return -1;
1100 }
1101 if (nlDivBy(b, a, r)) return 1;
1102 return 0;
1103}
BOOLEAN nlDivBy(number a, number b, const coeffs)
Definition: longrat.cc:1080

◆ nlEqual()

LINLINE BOOLEAN nlEqual ( number  a,
number  b,
const coeffs  r 
)

Definition at line 2597 of file longrat.cc.

2598{
2599 nlTest(a, r);
2600 nlTest(b, r);
2601// short - short
2602 if (SR_HDL(a) & SR_HDL(b) & SR_INT) return a==b;
2603 return _nlEqual_aNoImm_OR_bNoImm(a, b);
2604}
BOOLEAN _nlEqual_aNoImm_OR_bNoImm(number a, number b)
Definition: longrat.cc:1700

◆ nlExactDiv()

number nlExactDiv ( number  a,
number  b,
const coeffs  r 
)

Definition at line 873 of file longrat.cc.

874{
875 if (b==INT_TO_SR(0))
876 {
878 return INT_TO_SR(0);
879 }
880 number u;
881 if (SR_HDL(a) & SR_HDL(b) & SR_INT)
882 {
883 /* the small int -(1<<28) divided by -1 is the large int (1<<28) */
884 if ((a==INT_TO_SR(-(POW_2_28)))&&(b==INT_TO_SR(-1L)))
885 {
886 return nlRInit(POW_2_28);
887 }
888 long aa=SR_TO_INT(a);
889 long bb=SR_TO_INT(b);
890 return INT_TO_SR(aa/bb);
891 }
892 number aa=NULL;
893 number bb=NULL;
894 if (SR_HDL(a) & SR_INT)
895 {
896 aa=nlRInit(SR_TO_INT(a));
897 a=aa;
898 }
899 if (SR_HDL(b) & SR_INT)
900 {
901 bb=nlRInit(SR_TO_INT(b));
902 b=bb;
903 }
904 u=ALLOC_RNUMBER();
905#if defined(LDEBUG)
906 u->debug=123456;
907#endif
908 mpz_init(u->z);
909 /* u=a/b */
910 u->s = 3;
911 assume(a->s==3);
912 assume(b->s==3);
913 mpz_divexact(u->z,a->z,b->z);
914 if (aa!=NULL)
915 {
916 mpz_clear(aa->z);
917#if defined(LDEBUG)
918 aa->debug=654324;
919#endif
920 FREE_RNUMBER(aa); // omFreeBin((void *)aa, rnumber_bin);
921 }
922 if (bb!=NULL)
923 {
924 mpz_clear(bb->z);
925#if defined(LDEBUG)
926 bb->debug=654324;
927#endif
928 FREE_RNUMBER(bb); // omFreeBin((void *)bb, rnumber_bin);
929 }
930 u=nlShort3(u);
931 nlTest(u, r);
932 return u;
933}

◆ nlExtGcd()

number nlExtGcd ( number  a,
number  b,
number *  s,
number *  t,
const  coeffs 
)

Definition at line 3039 of file longrat.cc.

3040{
3041 mpz_ptr aa,bb;
3042 *s=ALLOC_RNUMBER();
3043 mpz_init((*s)->z); (*s)->s=3;
3044 (*t)=ALLOC_RNUMBER();
3045 mpz_init((*t)->z); (*t)->s=3;
3046 number g=ALLOC_RNUMBER();
3047 mpz_init(g->z); g->s=3;
3048 #ifdef LDEBUG
3049 g->debug=123456;
3050 (*s)->debug=123456;
3051 (*t)->debug=123456;
3052 #endif
3053 if (SR_HDL(a) & SR_INT)
3054 {
3055 aa=(mpz_ptr)omAlloc(sizeof(mpz_t));
3056 mpz_init_set_si(aa,SR_TO_INT(a));
3057 }
3058 else
3059 {
3060 aa=a->z;
3061 }
3062 if (SR_HDL(b) & SR_INT)
3063 {
3064 bb=(mpz_ptr)omAlloc(sizeof(mpz_t));
3065 mpz_init_set_si(bb,SR_TO_INT(b));
3066 }
3067 else
3068 {
3069 bb=b->z;
3070 }
3071 mpz_gcdext(g->z,(*s)->z,(*t)->z,aa,bb);
3072 g=nlShort3(g);
3073 (*s)=nlShort3((*s));
3074 (*t)=nlShort3((*t));
3075 if (SR_HDL(a) & SR_INT)
3076 {
3077 mpz_clear(aa);
3078 omFreeSize(aa, sizeof(mpz_t));
3079 }
3080 if (SR_HDL(b) & SR_INT)
3081 {
3082 mpz_clear(bb);
3083 omFreeSize(bb, sizeof(mpz_t));
3084 }
3085 return g;
3086}
g
Definition: cfModGcd.cc:4090
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omAlloc(size)
Definition: omAllocDecl.h:210

◆ nlFarey()

number nlFarey ( number  nN,
number  nP,
const coeffs  CF 
)

Definition at line 2968 of file longrat.cc.

2969{
2970 mpz_t A,B,C,D,E,N,P,tmp;
2971 if (SR_HDL(nP) & SR_INT) mpz_init_set_si(P,SR_TO_INT(nP));
2972 else mpz_init_set(P,nP->z);
2973 const mp_bitcnt_t bits=2*(mpz_size1(P)+1)*GMP_LIMB_BITS;
2974 mpz_init2(N,bits);
2975 if (SR_HDL(nN) & SR_INT) mpz_set_si(N,SR_TO_INT(nN));
2976 else mpz_set(N,nN->z);
2977 assume(!mpz_isNeg(P));
2978 if (mpz_isNeg(N)) mpz_add(N,N,P);
2979 mpz_init2(A,bits); mpz_set_ui(A,0L);
2980 mpz_init2(B,bits); mpz_set_ui(B,1L);
2981 mpz_init2(C,bits); mpz_set_ui(C,0L);
2982 mpz_init2(D,bits);
2983 mpz_init2(E,bits); mpz_set(E,P);
2984 mpz_init2(tmp,bits);
2985 number z=INT_TO_SR(0);
2986 while(mpz_sgn1(N)!=0)
2987 {
2988 mpz_mul(tmp,N,N);
2989 mpz_add(tmp,tmp,tmp);
2990 if (mpz_cmp(tmp,P)<0)
2991 {
2992 if (mpz_isNeg(B))
2993 {
2994 mpz_neg(B,B);
2995 mpz_neg(N,N);
2996 }
2997 // check for gcd(N,B)==1
2998 mpz_gcd(tmp,N,B);
2999 if (mpz_cmp_ui(tmp,1)==0)
3000 {
3001 // return N/B
3002 z=ALLOC_RNUMBER();
3003 #ifdef LDEBUG
3004 z->debug=123456;
3005 #endif
3006 memcpy(z->z,N,sizeof(mpz_t));
3007 memcpy(z->n,B,sizeof(mpz_t));
3008 z->s = 0;
3009 nlNormalize(z,r);
3010 }
3011 else
3012 {
3013 // return nN (the input) instead of "fail"
3014 z=nlCopy(nN,r);
3015 mpz_clear(B);
3016 mpz_clear(N);
3017 }
3018 break;
3019 }
3020 //mpz_mod(D,E,N);
3021 //mpz_div(tmp,E,N);
3022 mpz_divmod(tmp,D,E,N);
3023 mpz_mul(tmp,tmp,B);
3024 mpz_sub(C,A,tmp);
3025 mpz_set(E,N);
3026 mpz_set(N,D);
3027 mpz_set(A,B);
3028 mpz_set(B,C);
3029 }
3030 mpz_clear(tmp);
3031 mpz_clear(A);
3032 mpz_clear(C);
3033 mpz_clear(D);
3034 mpz_clear(E);
3035 mpz_clear(P);
3036 return z;
3037}
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
REvaluation E(1, terms.length(), IntRandom(25))
b *CanonicalForm B
Definition: facBivar.cc:52
#define D(A)
Definition: gentable.cc:131
#define A
Definition: sirandom.c:24

◆ nlGcd()

number nlGcd ( number  a,
number  b,
const coeffs  r 
)

Definition at line 1345 of file longrat.cc.

1346{
1347 number result;
1348 nlTest(a, r);
1349 nlTest(b, r);
1350 //nlNormalize(a);
1351 //nlNormalize(b);
1352 if ((a==INT_TO_SR(1L))||(a==INT_TO_SR(-1L))
1353 || (b==INT_TO_SR(1L))||(b==INT_TO_SR(-1L)))
1354 return INT_TO_SR(1L);
1355 if (a==INT_TO_SR(0)) /* gcd(0,b) ->b */
1356 return nlCopy(b,r);
1357 if (b==INT_TO_SR(0)) /* gcd(a,0) -> a */
1358 return nlCopy(a,r);
1359 if (SR_HDL(a) & SR_HDL(b) & SR_INT)
1360 {
1361 long i=SR_TO_INT(a);
1362 long j=SR_TO_INT(b);
1363 long l;
1364 i=ABS(i);
1365 j=ABS(j);
1366 do
1367 {
1368 l=i%j;
1369 i=j;
1370 j=l;
1371 } while (l!=0L);
1372 if (i==POW_2_28)
1374 else
1376 nlTest(result,r);
1377 return result;
1378 }
1379 if (((!(SR_HDL(a) & SR_INT))&&(a->s<2))
1380 || ((!(SR_HDL(b) & SR_INT))&&(b->s<2))) return INT_TO_SR(1);
1381 if (SR_HDL(a) & SR_INT)
1382 {
1383 LONG aa=ABS(SR_TO_INT(a));
1384 unsigned long t=mpz_gcd_ui(NULL,b->z,(long)aa);
1385 if (t==POW_2_28)
1387 else
1388 result=INT_TO_SR(t);
1389 }
1390 else
1391 if (SR_HDL(b) & SR_INT)
1392 {
1393 LONG bb=ABS(SR_TO_INT(b));
1394 unsigned long t=mpz_gcd_ui(NULL,a->z,(long)bb);
1395 if (t==POW_2_28)
1397 else
1398 result=INT_TO_SR(t);
1399 }
1400 else
1401 {
1403 result->s = 3;
1404 #ifdef LDEBUG
1405 result->debug=123456;
1406 #endif
1407 mpz_init(result->z);
1408 mpz_gcd(result->z,a->z,b->z);
1410 }
1411 nlTest(result, r);
1412 return result;
1413}
static int ABS(int v)
Definition: auxiliary.h:112
#define ALLOC0_RNUMBER()
Definition: coeffs.h:88
return result
Definition: facAbsBiFact.cc:75

◆ 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}

◆ 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}

◆ nlGetUnit()

number nlGetUnit ( number  n,
const coeffs  cf 
)

Definition at line 1105 of file longrat.cc.

1106{
1107 if (nlGreaterZero(n,cf)) return INT_TO_SR(1);
1108 else return INT_TO_SR(-1);
1109}

◆ nlGMP()

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

Definition at line 1619 of file longrat.cc.

1620{
1621 // Hier brauche ich einfach die GMP Zahl
1622 nlTest(i, r);
1623 nlNormalize(i, r);
1624 if (SR_HDL(i) & SR_INT)
1625 {
1626 mpz_set_si(n, SR_TO_INT(i));
1627 return;
1628 }
1629 if (i->s!=3)
1630 {
1631 WarnS("Omitted denominator during coefficient mapping !");
1632 }
1633 mpz_set(n, i->z);
1634}
#define WarnS
Definition: emacs.cc:78

◆ nlGreater()

BOOLEAN nlGreater ( number  a,
number  b,
const coeffs  r 
)

Definition at line 1318 of file longrat.cc.

1319{
1320 nlTest(a, r);
1321 nlTest(b, r);
1322 number re;
1323 BOOLEAN rr;
1324 re=nlSub(a,b,r);
1325 rr=(!nlIsZero(re,r)) && (nlGreaterZero(re,r));
1326 nlDelete(&re,r);
1327 return rr;
1328}
LINLINE number nlSub(number la, number li, const coeffs r)
Definition: longrat.cc:2767

◆ nlGreaterZero()

BOOLEAN nlGreaterZero ( number  za,
const coeffs  r 
)

Definition at line 1308 of file longrat.cc.

1309{
1310 nlTest(a, r);
1311 if (SR_HDL(a) & SR_INT) return SR_HDL(a)>1L /* represents number(0) */;
1312 return (!mpz_isNeg(a->z));
1313}

◆ nlInit()

LINLINE number nlInit ( long  i,
const coeffs  r 
)

Definition at line 2606 of file longrat.cc.

2607{
2608 number n;
2609 #if MAX_NUM_SIZE == 60
2610 if (((i << 3) >> 3) == i) n=INT_TO_SR(i);
2611 else n=nlRInit(i);
2612 #else
2613 LONG ii=(LONG)i;
2614 if ( ((((long)ii)==i) && ((ii << 3) >> 3) == ii )) n=INT_TO_SR(ii);
2615 else n=nlRInit(i);
2616 #endif
2617 nlTest(n, r);
2618 return n;
2619}

◆ 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}

◆ 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}
@ 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 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
number nlIntMod(number a, number b, const coeffs r)
Definition: longrat.cc:1019
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
number nlNormalizeHelper(number a, number b, const coeffs r)
Definition: longrat.cc:1530
LINLINE void nlInpAdd(number &a, number b, const coeffs r)
Definition: longrat.cc:2719
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: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
char * nlCoeffName(const coeffs r)
Definition: longrat.cc:3324
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
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
BOOLEAN nlDBTest(number a, const char *f, const int l)
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
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

◆ nlInitMPZ()

static number nlInitMPZ ( mpz_t  m,
const  coeffs 
)
static

Definition at line 164 of file longrat.cc.

165{
166 number z = ALLOC_RNUMBER();
167 z->s = 3;
168 #ifdef LDEBUG
169 z->debug=123456;
170 #endif
171 mpz_init_set(z->z, m);
172 z=nlShort3(z);
173 return z;
174}
int m
Definition: cfEzgcd.cc:128

◆ nlInpAdd()

LINLINE void nlInpAdd ( number &  a,
number  b,
const coeffs  r 
)

Definition at line 2719 of file longrat.cc.

2720{
2721 // a=a+b
2722 if (SR_HDL(a) & SR_HDL(b) & SR_INT)
2723 {
2724 LONG r=SR_HDL(a)+SR_HDL(b)-1L;
2725 if ( ((r << 1) >> 1) == r )
2726 a=(number)(long)r;
2727 else
2728 a=nlRInit(SR_TO_INT(r));
2729 }
2730 else
2731 {
2733 nlTest(a,r);
2734 }
2735}
void _nlInpAdd_aNoImm_OR_bNoImm(number &a, number b)
Definition: longrat.cc:1977

◆ 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}

◆ nlInpIntDiv()

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

Definition at line 2948 of file longrat.cc.

2949{
2950 if ((SR_HDL(b)|SR_HDL(a))&SR_INT)
2951 {
2952 number n=nlIntDiv(a,b, r);
2953 nlDelete(&a,r);
2954 a=n;
2955 }
2956 else
2957 {
2958 mpz_t rr;
2959 mpz_init(rr);
2960 mpz_mod(rr,a->z,b->z);
2961 mpz_sub(a->z,a->z,rr);
2962 mpz_clear(rr);
2963 mpz_divexact(a->z,a->z,b->z);
2964 a=nlShort3_noinline(a);
2965 }
2966}

◆ nlInpMult()

LINLINE void nlInpMult ( number &  a,
number  b,
const coeffs  r 
)

Definition at line 2785 of file longrat.cc.

2786{
2787 number aa=a;
2788 if (((SR_HDL(b)|SR_HDL(aa))&SR_INT))
2789 {
2790 number n=nlMult(aa,b,r);
2791 nlDelete(&a,r);
2792 a=n;
2793 }
2794 else
2795 {
2796 mpz_mul(aa->z,a->z,b->z);
2797 if (aa->s==3)
2798 {
2799 if(b->s!=3)
2800 {
2801 mpz_init_set(a->n,b->n);
2802 a->s=0;
2803 }
2804 }
2805 else
2806 {
2807 if(b->s!=3)
2808 {
2809 mpz_mul(a->n,a->n,b->n);
2810 }
2811 a->s=0;
2812 }
2813 }
2814}

◆ nlInt()

long nlInt ( number &  n,
const coeffs  r 
)

Definition at line 743 of file longrat.cc.

744{
745 nlTest(i, r);
746 nlNormalize(i,r);
747 if (SR_HDL(i) & SR_INT)
748 {
749 return SR_TO_INT(i);
750 }
751 if (i->s==3)
752 {
753 if(mpz_size1(i->z)>MP_SMALL) return 0;
754 long ul=mpz_get_si(i->z);
755 if (mpz_cmp_si(i->z,ul)!=0) return 0;
756 return ul;
757 }
758 mpz_t tmp;
759 long ul;
760 mpz_init(tmp);
761 mpz_tdiv_q(tmp,i->z,i->n);
762 if(mpz_size1(tmp)>MP_SMALL) ul=0;
763 else
764 {
765 ul=mpz_get_si(tmp);
766 if (mpz_cmp_si(tmp,ul)!=0) ul=0;
767 }
768 mpz_clear(tmp);
769 return ul;
770}

◆ nlIntDiv()

number nlIntDiv ( number  a,
number  b,
const coeffs  r 
)

Definition at line 938 of file longrat.cc.

939{
940 if (b==INT_TO_SR(0))
941 {
943 return INT_TO_SR(0);
944 }
945 number u;
946 if (SR_HDL(a) & SR_HDL(b) & SR_INT)
947 {
948 /* the small int -(1<<28) divided by -1 is the large int (1<<28) */
949 if ((a==INT_TO_SR(-(POW_2_28)))&&(b==INT_TO_SR(-1L)))
950 {
951 return nlRInit(POW_2_28);
952 }
953 LONG aa=SR_TO_INT(a);
954 LONG bb=SR_TO_INT(b);
955 LONG rr=aa%bb;
956 if (rr<0) rr+=ABS(bb);
957 LONG cc=(aa-rr)/bb;
958 return INT_TO_SR(cc);
959 }
960 number aa=NULL;
961 if (SR_HDL(a) & SR_INT)
962 {
963 /* the small int -(1<<28) divided by 2^28 is 1 */
964 if (a==INT_TO_SR(-(POW_2_28)))
965 {
966 if(mpz_cmp_si(b->z,(POW_2_28))==0)
967 {
968 return INT_TO_SR(-1);
969 }
970 }
971 aa=nlRInit(SR_TO_INT(a));
972 a=aa;
973 }
974 number bb=NULL;
975 if (SR_HDL(b) & SR_INT)
976 {
977 bb=nlRInit(SR_TO_INT(b));
978 b=bb;
979 }
980 u=ALLOC_RNUMBER();
981#if defined(LDEBUG)
982 u->debug=123456;
983#endif
984 assume(a->s==3);
985 assume(b->s==3);
986 /* u=u/b */
987 mpz_t rr;
988 mpz_init(rr);
989 mpz_mod(rr,a->z,b->z);
990 u->s = 3;
991 mpz_init(u->z);
992 mpz_sub(u->z,a->z,rr);
993 mpz_clear(rr);
994 mpz_divexact(u->z,u->z,b->z);
995 if (aa!=NULL)
996 {
997 mpz_clear(aa->z);
998#if defined(LDEBUG)
999 aa->debug=654324;
1000#endif
1001 FREE_RNUMBER(aa);
1002 }
1003 if (bb!=NULL)
1004 {
1005 mpz_clear(bb->z);
1006#if defined(LDEBUG)
1007 bb->debug=654324;
1008#endif
1009 FREE_RNUMBER(bb);
1010 }
1011 u=nlShort3(u);
1012 nlTest(u,r);
1013 return u;
1014}

◆ nlIntMod()

number nlIntMod ( number  a,
number  b,
const coeffs  r 
)

Definition at line 1019 of file longrat.cc.

1020{
1021 if (b==INT_TO_SR(0))
1022 {
1024 return INT_TO_SR(0);
1025 }
1026 if (a==INT_TO_SR(0))
1027 return INT_TO_SR(0);
1028 number u;
1029 if (SR_HDL(a) & SR_HDL(b) & SR_INT)
1030 {
1031 LONG aa=SR_TO_INT(a);
1032 LONG bb=SR_TO_INT(b);
1033 LONG c=aa % bb;
1034 if (c<0) c+=ABS(bb);
1035 return INT_TO_SR(c);
1036 }
1037 if (SR_HDL(a) & SR_INT)
1038 {
1039 LONG ai=SR_TO_INT(a);
1040 mpz_t aa;
1041 mpz_init_set_si(aa, ai);
1042 u=ALLOC_RNUMBER();
1043#if defined(LDEBUG)
1044 u->debug=123456;
1045#endif
1046 u->s = 3;
1047 mpz_init(u->z);
1048 mpz_mod(u->z, aa, b->z);
1049 mpz_clear(aa);
1050 u=nlShort3(u);
1051 nlTest(u,r);
1052 return u;
1053 }
1054 number bb=NULL;
1055 if (SR_HDL(b) & SR_INT)
1056 {
1057 bb=nlRInit(SR_TO_INT(b));
1058 b=bb;
1059 }
1060 u=ALLOC_RNUMBER();
1061#if defined(LDEBUG)
1062 u->debug=123456;
1063#endif
1064 mpz_init(u->z);
1065 u->s = 3;
1066 mpz_mod(u->z, a->z, b->z);
1067 if (bb!=NULL)
1068 {
1069 mpz_clear(bb->z);
1070#if defined(LDEBUG)
1071 bb->debug=654324;
1072#endif
1073 FREE_RNUMBER(bb);
1074 }
1075 u=nlShort3(u);
1076 nlTest(u,r);
1077 return u;
1078}

◆ nlInvers()

number nlInvers ( number  a,
const coeffs  r 
)

Definition at line 793 of file longrat.cc.

794{
795 nlTest(a, r);
796 number n;
797 if (SR_HDL(a) & SR_INT)
798 {
799 if ((a==INT_TO_SR(1L)) || (a==INT_TO_SR(-1L)))
800 {
801 return a;
802 }
803 if (nlIsZero(a,r))
804 {
806 return INT_TO_SR(0);
807 }
808 n=ALLOC_RNUMBER();
809#if defined(LDEBUG)
810 n->debug=123456;
811#endif
812 n->s=1;
813 if (((long)a)>0L)
814 {
815 mpz_init_set_ui(n->z,1L);
816 mpz_init_set_si(n->n,(long)SR_TO_INT(a));
817 }
818 else
819 {
820 mpz_init_set_si(n->z,-1L);
821 mpz_init_set_si(n->n,(long)-SR_TO_INT(a));
822 }
823 nlTest(n, r);
824 return n;
825 }
826 n=ALLOC_RNUMBER();
827#if defined(LDEBUG)
828 n->debug=123456;
829#endif
830 {
831 mpz_init_set(n->n,a->z);
832 switch (a->s)
833 {
834 case 0:
835 case 1:
836 n->s=a->s;
837 mpz_init_set(n->z,a->n);
838 if (mpz_isNeg(n->n)) /* && n->s<2*/
839 {
840 mpz_neg(n->z,n->z);
841 mpz_neg(n->n,n->n);
842 }
843 if (mpz_cmp_ui(n->n,1L)==0)
844 {
845 mpz_clear(n->n);
846 n->s=3;
847 n=nlShort3(n);
848 }
849 break;
850 case 3:
851 // i.e. |a| > 2^...
852 n->s=1;
853 if (mpz_isNeg(n->n)) /* && n->s<2*/
854 {
855 mpz_neg(n->n,n->n);
856 mpz_init_set_si(n->z,-1L);
857 }
858 else
859 {
860 mpz_init_set_ui(n->z,1L);
861 }
862 break;
863 }
864 }
865 nlTest(n, r);
866 return n;
867}

◆ nlIsMOne()

BOOLEAN nlIsMOne ( number  a,
const coeffs  r 
)

Definition at line 1333 of file longrat.cc.

1334{
1335#ifdef LDEBUG
1336 if (a==NULL) return FALSE;
1337 nlTest(a, r);
1338#endif
1339 return (a==INT_TO_SR(-1L));
1340}

◆ nlIsOne()

LINLINE BOOLEAN nlIsOne ( number  a,
const coeffs  r 
)

Definition at line 2624 of file longrat.cc.

2625{
2626#ifdef LDEBUG
2627 if (a==NULL) return FALSE;
2628 nlTest(a, r);
2629#endif
2630 return (a==INT_TO_SR(1));
2631}

◆ nlIsUnit()

BOOLEAN nlIsUnit ( number  a,
const  coeffs 
)

Definition at line 1136 of file longrat.cc.

1137{
1138 return ((SR_HDL(a) & SR_INT) && (ABS(SR_TO_INT(a))==1));
1139}

◆ nlIsZero()

LINLINE BOOLEAN nlIsZero ( number  za,
const coeffs  r 
)

Definition at line 2633 of file longrat.cc.

2634{
2635 #if 0
2636 if (a==INT_TO_SR(0)) return TRUE;
2637 if ((SR_HDL(a) & SR_INT)||(a==NULL)) return FALSE;
2638 if (mpz_cmp_si(a->z,0L)==0)
2639 {
2640 printf("gmp-0 in nlIsZero\n");
2641 dErrorBreak();
2642 return TRUE;
2643 }
2644 return FALSE;
2645 #else
2646 return (a==NULL)|| (a==INT_TO_SR(0));
2647 #endif
2648}
void dErrorBreak(void)

◆ nlLcm()

static number nlLcm ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 3451 of file longrat.cc.

3452{
3453 number g=nlGcd(a,b,r);
3454 number n1=nlMult(a,b,r);
3455 number n2=nlExactDiv(n1,g,r);
3456 nlDelete(&g,r);
3457 nlDelete(&n1,r);
3458 return n2;
3459}

◆ nlMapC()

static number nlMapC ( number  from,
const coeffs  src,
const coeffs  dst 
)
static

Definition at line 548 of file longrat.cc.

549{
550 assume( getCoeffType(src) == n_long_C );
551 if ( ! ((gmp_complex*)from)->imag().isZero() )
552 return INT_TO_SR(0);
553
554 if (dst->is_field==FALSE) /* ->ZZ */
555 {
556 char *s=floatToStr(((gmp_complex*)from)->real(),src->float_len);
557 mpz_t z;
558 mpz_init(z);
559 char *ss=nEatLong(s,z);
560 if (*ss=='\0')
561 {
562 omFree(s);
563 number n=nlInitMPZ(z,dst);
564 mpz_clear(z);
565 return n;
566 }
567 omFree(s);
568 mpz_clear(z);
569 WarnS("conversion problem in CC -> ZZ mapping");
570 return INT_TO_SR(0);
571 }
572
573 mpf_t *f = ((gmp_complex*)from)->real()._mpfp();
574
575 number res;
576 mpz_ptr dest,ndest;
577 int size, i,negative;
578 int e,al,bl;
579 mp_ptr qp,dd,nn;
580
581 size = (*f)[0]._mp_size;
582 if (size == 0)
583 return INT_TO_SR(0);
584 if(size<0)
585 {
586 negative = 1;
587 size = -size;
588 }
589 else
590 negative = 0;
591
592 qp = (*f)[0]._mp_d;
593 while(qp[0]==0)
594 {
595 qp++;
596 size--;
597 }
598
599 e=(*f)[0]._mp_exp-size;
600 res = ALLOC_RNUMBER();
601#if defined(LDEBUG)
602 res->debug=123456;
603#endif
604 dest = res->z;
605
606 void* (*allocfunc) (size_t);
607 mp_get_memory_functions (&allocfunc,NULL, NULL);
608 if (e<0)
609 {
610 al = dest->_mp_size = size;
611 if (al<2) al = 2;
612 dd = (mp_ptr)allocfunc(sizeof(mp_limb_t)*al);
613 for (i=0;i<size;i++) dd[i] = qp[i];
614 bl = 1-e;
615 nn = (mp_ptr)allocfunc(sizeof(mp_limb_t)*bl);
616 memset(nn,0,sizeof(mp_limb_t)*bl);
617 nn[bl-1] = 1;
618 ndest = res->n;
619 ndest->_mp_d = nn;
620 ndest->_mp_alloc = ndest->_mp_size = bl;
621 res->s = 0;
622 }
623 else
624 {
625 al = dest->_mp_size = size+e;
626 if (al<2) al = 2;
627 dd = (mp_ptr)allocfunc(sizeof(mp_limb_t)*al);
628 memset(dd,0,sizeof(mp_limb_t)*al);
629 for (i=0;i<size;i++) dd[i+e] = qp[i];
630 for (i=0;i<e;i++) dd[i] = 0;
631 res->s = 3;
632 }
633
634 dest->_mp_d = dd;
635 dest->_mp_alloc = al;
636 if (negative) mpz_neg(dest,dest);
637
638 if (res->s==0)
639 nlNormalize(res,dst);
640 else if (mpz_size1(res->z)<=MP_SMALL)
641 {
642 // res is new, res->ref is 1
644 }
645 nlTest(res, dst);
646 return res;
647}
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
gmp_complex numbers based on
Definition: mpr_complex.h:179
@ n_long_C
complex floating point (GMP) numbers
Definition: coeffs.h:41
CanonicalForm res
Definition: facAbsFact.cc:60
bool isZero(const CFArray &A)
checks if entries of A are zero
char * floatToStr(const gmp_float &r, const unsigned int oprec)
Definition: mpr_complex.cc:578
bool negative(N n)
Definition: ValueTraits.h:119
char * nEatLong(char *s, mpz_ptr i)
extracts a long integer from s, returns the rest
Definition: numbers.cc:718
#define omFree(addr)
Definition: omAllocDecl.h:261

◆ nlMapGMP()

static number nlMapGMP ( number  from,
const  coeffs,
const coeffs  dst 
)
inlinestatic

Definition at line 206 of file longrat.cc.

207{
208 return nlInitMPZ((mpz_ptr)from,dst);
209}

◆ nlMapLongR()

static number nlMapLongR ( number  from,
const coeffs  src,
const coeffs  dst 
)
static

Definition at line 435 of file longrat.cc.

436{
437 assume( getCoeffType(src) == n_long_R );
438
439 gmp_float *ff=(gmp_float*)from;
440 mpf_t *f=ff->_mpfp();
441 number res;
442 mpz_ptr dest,ndest;
443 int size, i,negative;
444 int e,al,bl;
445 mp_ptr qp,dd,nn;
446
447 size = (*f)[0]._mp_size;
448 if (size == 0)
449 return INT_TO_SR(0);
450 if(size<0)
451 {
452 negative = 1;
453 size = -size;
454 }
455 else
456 negative = 0;
457
458 qp = (*f)[0]._mp_d;
459 while(qp[0]==0)
460 {
461 qp++;
462 size--;
463 }
464
465 e=(*f)[0]._mp_exp-size;
466 res = ALLOC_RNUMBER();
467#if defined(LDEBUG)
468 res->debug=123456;
469#endif
470 dest = res->z;
471
472 void* (*allocfunc) (size_t);
473 mp_get_memory_functions (&allocfunc,NULL, NULL);
474 if (e<0)
475 {
476 al = dest->_mp_size = size;
477 if (al<2) al = 2;
478 dd = (mp_ptr)allocfunc(sizeof(mp_limb_t)*al);
479 for (i=0;i<size;i++) dd[i] = qp[i];
480 bl = 1-e;
481 nn = (mp_ptr)allocfunc(sizeof(mp_limb_t)*bl);
482 memset(nn,0,sizeof(mp_limb_t)*bl);
483 nn[bl-1] = 1;
484 ndest = res->n;
485 ndest->_mp_d = nn;
486 ndest->_mp_alloc = ndest->_mp_size = bl;
487 res->s = 0;
488 }
489 else
490 {
491 al = dest->_mp_size = size+e;
492 if (al<2) al = 2;
493 dd = (mp_ptr)allocfunc(sizeof(mp_limb_t)*al);
494 memset(dd,0,sizeof(mp_limb_t)*al);
495 for (i=0;i<size;i++) dd[i+e] = qp[i];
496 for (i=0;i<e;i++) dd[i] = 0;
497 res->s = 3;
498 }
499
500 dest->_mp_d = dd;
501 dest->_mp_alloc = al;
502 if (negative) mpz_neg(dest,dest);
503
504 if (res->s==0)
505 nlNormalize(res,dst);
506 else if (mpz_size1(res->z)<=MP_SMALL)
507 {
508 // res is new, res->ref is 1
510 }
511 nlTest(res, dst);
512 return res;
513}
mpf_t * _mpfp()
Definition: mpr_complex.h:134
@ n_long_R
real floating point (GMP) numbers
Definition: coeffs.h:33

◆ nlMapLongR_BI()

static number nlMapLongR_BI ( number  from,
const coeffs  src,
const coeffs  dst 
)
static

Definition at line 515 of file longrat.cc.

516{
517 assume( getCoeffType(src) == n_long_R );
518
519 gmp_float *ff=(gmp_float*)from;
520 if (mpf_fits_slong_p(ff->t))
521 {
522 long l=mpf_get_si(ff->t);
523 return nlInit(l,dst);
524 }
525 char *out=floatToStr(*(gmp_float*)from, src->float_len);
526 char *p=strchr(out,'.');
527 *p='\0';
528 number res;
529 res = ALLOC_RNUMBER();
530#if defined(LDEBUG)
531 res->debug=123456;
532#endif
533 res->s=3;
534 mpz_init(res->z);
535 if (out[0]=='-')
536 {
537 mpz_set_str(res->z,out+1,10);
538 res=nlNeg(res,dst);
539 }
540 else
541 {
542 mpz_set_str(res->z,out,10);
543 }
544 omFree( (void *)out );
545 return res;
546}

◆ nlMapMachineInt()

number nlMapMachineInt ( number  from,
const  coeffs,
const  coeffs 
)

Definition at line 223 of file longrat.cc.

224{
225 number z=ALLOC_RNUMBER();
226#if defined(LDEBUG)
227 z->debug=123456;
228#endif
229 mpz_init_set_ui(z->z,(unsigned long) from);
230 z->s = 3;
231 z=nlShort3(z);
232 return z;
233}

◆ nlMapP()

static number nlMapP ( number  from,
const coeffs  src,
const coeffs  dst 
)
static

Definition at line 189 of file longrat.cc.

190{
191 assume( getCoeffType(src) == n_Zp );
192
193 number to = nlInit(npInt(from,src), dst); // FIXME? TODO? // extern long npInt (number &n, const coeffs r);
194
195 return to;
196}
@ n_Zp
\F{p < 2^31}
Definition: coeffs.h:29
long npInt(number &n, const coeffs r)
Definition: modulop.cc:83

◆ nlMapQtoZ()

number nlMapQtoZ ( number  a,
const coeffs  src,
const coeffs  dst 
)

Definition at line 2461 of file longrat.cc.

2462{
2463 if ((SR_HDL(a) & SR_INT)||(a==NULL))
2464 {
2465 return a;
2466 }
2467 if (a->s==3) return _nlCopy_NoImm(a);
2468 number a0=a;
2469 BOOLEAN a1=FALSE;
2470 if (a->s==0) { a0=_nlCopy_NoImm(a); a1=TRUE; }
2471 number b1=nlGetNumerator(a0,src);
2472 number b2=nlGetDenom(a0,src);
2473 number b=nlIntDiv(b1,b2,dst);
2474 nlDelete(&b1,src);
2475 nlDelete(&b2,src);
2476 if (a1) _nlDelete_NoImm(&a0);
2477 return b;
2478}

◆ nlMapR()

static number nlMapR ( number  from,
const coeffs  src,
const coeffs  dst 
)
static

Definition at line 395 of file longrat.cc.

396{
397 assume( getCoeffType(src) == n_R );
398
399 double f=nrFloat(from); // FIXME? TODO? // extern float nrFloat(number n);
400 if (f==0.0) return INT_TO_SR(0);
401 int f_sign=1;
402 if (f<0.0)
403 {
404 f_sign=-1;
405 f=-f;
406 }
407 int i=0;
408 mpz_t h1;
409 mpz_init_set_ui(h1,1);
410 while((FLT_RADIX*f) < DBL_MAX && i<DBL_MANT_DIG)
411 {
412 f*=FLT_RADIX;
413 mpz_mul_ui(h1,h1,FLT_RADIX);
414 i++;
415 }
416 number re=nlRInit(1);
417 mpz_set_d(re->z,f);
418 memcpy(&(re->n),&h1,sizeof(h1));
419 re->s=0; /* not normalized */
420 if(f_sign==-1) re=nlNeg(re,dst);
421 nlNormalize(re,dst);
422 return re;
423}
@ n_R
single prescision (6,6) real numbers
Definition: coeffs.h:31
SI_FLOAT nrFloat(number n)
Converts a n_R number into a float. Needed by Maps.
Definition: shortfl.cc:48

◆ nlMapR_BI()

static number nlMapR_BI ( number  from,
const coeffs  src,
const coeffs  dst 
)
static

Definition at line 425 of file longrat.cc.

426{
427 assume( getCoeffType(src) == n_R );
428
429 double f=nrFloat(from); // FIXME? TODO? // extern float nrFloat(number n);
430 if (f==0.0) return INT_TO_SR(0);
431 long l=long(f);
432 return nlInit(l,dst);
433}

◆ nlMapZ()

number nlMapZ ( number  from,
const  coeffs,
const coeffs  dst 
)

Definition at line 211 of file longrat.cc.

212{
213 if (SR_HDL(from) & SR_INT)
214 {
215 return from;
216 }
217 return nlInitMPZ((mpz_ptr)from,dst);
218}

◆ nlModP()

number nlModP ( number  q,
const  coeffs,
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

◆ 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}

◆ nlMult()

LINLINE number nlMult ( number  a,
number  b,
const coeffs  r 
)

Definition at line 2737 of file longrat.cc.

2738{
2739 nlTest(a, R);
2740 nlTest(b, R);
2741 if (a==INT_TO_SR(0)) return INT_TO_SR(0);
2742 if (b==INT_TO_SR(0)) return INT_TO_SR(0);
2743 if (SR_HDL(a) & SR_HDL(b) & SR_INT)
2744 {
2745 LONG r=(LONG)((unsigned LONG)(SR_HDL(a)-1L))*((unsigned LONG)(SR_HDL(b)>>1));
2746 if ((r/(SR_HDL(b)>>1))==(SR_HDL(a)-1L))
2747 {
2748 number u=((number) ((r>>1)+SR_INT));
2749 if (((((LONG)SR_HDL(u))<<1)>>1)==SR_HDL(u)) return (u);
2750 return nlRInit(SR_HDL(u)>>2);
2751 }
2752 number u = _nlMult_aImm_bImm_rNoImm(a, b);
2753 nlTest(u, R);
2754 return u;
2755
2756 }
2757 number u = _nlMult_aNoImm_OR_bNoImm(a, b);
2758 nlTest(u, R);
2759 return u;
2760
2761}
number _nlMult_aImm_bImm_rNoImm(number a, number b)
Definition: longrat.cc:2331
number _nlMult_aNoImm_OR_bNoImm(number a, number b)
Definition: longrat.cc:2344

◆ nlNeg()

LINLINE number nlNeg ( number  za,
const coeffs  r 
)

Definition at line 2682 of file longrat.cc.

2683{
2684 nlTest(a, R);
2685 if(SR_HDL(a) &SR_INT)
2686 {
2687 LONG r=SR_TO_INT(a);
2688 if (r==(-(POW_2_28))) a=nlRInit(POW_2_28);
2689 else a=INT_TO_SR(-r);
2690 return a;
2691 }
2692 a = _nlNeg_NoImm(a);
2693 nlTest(a, R);
2694 return a;
2695
2696}
number _nlNeg_NoImm(number a)
Definition: longrat.cc:1786

◆ 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}
int gcd(int a, int b)
Definition: walkSupport.cc:836

◆ nlNormalize_Gcd()

static void nlNormalize_Gcd ( number &  x)
static

Definition at line 1799 of file longrat.cc.

1800{
1801 mpz_t gcd;
1802 mpz_init(gcd);
1803 mpz_gcd(gcd,x->z,x->n);
1804 x->s=1;
1805 if (mpz_cmp_si(gcd,1L)!=0)
1806 {
1807 mpz_divexact(x->z,x->z,gcd);
1808 mpz_divexact(x->n,x->n,gcd);
1809 if (mpz_cmp_si(x->n,1L)==0)
1810 {
1811 mpz_clear(x->n);
1812 x->s=3;
1814 }
1815 }
1816 mpz_clear(gcd);
1817}

◆ nlNormalizeHelper()

number nlNormalizeHelper ( number  a,
number  b,
const coeffs  r 
)

Definition at line 1530 of file longrat.cc.

1531{
1532 number result;
1533 nlTest(a, r);
1534 nlTest(b, r);
1535 if ((SR_HDL(b) & SR_INT)
1536 || (b->s==3))
1537 {
1538 // b is 1/(b->n) => b->n is 1 => result is a
1539 return nlCopy(a,r);
1540 }
1542#if defined(LDEBUG)
1543 result->debug=123456;
1544#endif
1545 result->s=3;
1546 mpz_t gcd;
1547 mpz_init(gcd);
1548 mpz_init(result->z);
1549 if (SR_HDL(a) & SR_INT)
1550 mpz_gcd_ui(gcd,b->n,ABS(SR_TO_INT(a)));
1551 else
1552 mpz_gcd(gcd,a->z,b->n);
1553 if (mpz_cmp_si(gcd,1L)!=0)
1554 {
1555 mpz_t bt;
1556 mpz_init(bt);
1557 mpz_divexact(bt,b->n,gcd);
1558 if (SR_HDL(a) & SR_INT)
1559 mpz_mul_si(result->z,bt,SR_TO_INT(a));
1560 else
1561 mpz_mul(result->z,bt,a->z);
1562 mpz_clear(bt);
1563 }
1564 else
1565 if (SR_HDL(a) & SR_INT)
1566 mpz_mul_si(result->z,b->n,SR_TO_INT(a));
1567 else
1568 mpz_mul(result->z,b->n,a->z);
1569 mpz_clear(gcd);
1571 nlTest(result, r);
1572 return result;
1573}

◆ nlPower()

void nlPower ( number  x,
int  exp,
number *  lu,
const coeffs  r 
)

Definition at line 1255 of file longrat.cc.

1256{
1257 *u = INT_TO_SR(0); // 0^e, e!=0
1258 if (exp==0)
1259 *u= INT_TO_SR(1);
1260 else if (!nlIsZero(x,r))
1261 {
1262 nlTest(x, r);
1263 number aa=NULL;
1264 if (SR_HDL(x) & SR_INT)
1265 {
1266 aa=nlRInit(SR_TO_INT(x));
1267 x=aa;
1268 }
1269 else if (x->s==0)
1270 nlNormalize(x,r);
1271 *u=ALLOC_RNUMBER();
1272#if defined(LDEBUG)
1273 (*u)->debug=123456;
1274#endif
1275 mpz_init((*u)->z);
1276 mpz_pow_ui((*u)->z,x->z,(unsigned long)exp);
1277 if (x->s<2)
1278 {
1279 if (mpz_cmp_si(x->n,1L)==0)
1280 {
1281 x->s=3;
1282 mpz_clear(x->n);
1283 }
1284 else
1285 {
1286 mpz_init((*u)->n);
1287 mpz_pow_ui((*u)->n,x->n,(unsigned long)exp);
1288 }
1289 }
1290 (*u)->s = x->s;
1291 if ((*u)->s==3) *u=nlShort3(*u);
1292 if (aa!=NULL)
1293 {
1294 mpz_clear(aa->z);
1295 FREE_RNUMBER(aa);
1296 }
1297 }
1298#ifdef LDEBUG
1299 if (exp<0) Print("nlPower: neg. exp. %d\n",exp);
1300 nlTest(*u, r);
1301#endif
1302}
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:357

◆ nlQuot1()

coeffs nlQuot1 ( number  c,
const coeffs  r 
)

Definition at line 1111 of file longrat.cc.

1112{
1113 long ch = r->cfInt(c, r);
1114 int p=IsPrime(ch);
1115 coeffs rr=NULL;
1116 if (((long)p)==ch)
1117 {
1118 rr = nInitChar(n_Zp,(void*)ch);
1119 }
1120 #ifdef HAVE_RINGS
1121 else
1122 {
1123 mpz_t dummy;
1124 mpz_init_set_ui(dummy, ch);
1125 ZnmInfo info;
1126 info.base = dummy;
1127 info.exp = (unsigned long) 1;
1128 rr = nInitChar(n_Zn, (void*)&info);
1129 mpz_clear(dummy);
1130 }
1131 #endif
1132 return(rr);
1133}
@ n_Zn
only used if HAVE_RINGS is defined
Definition: coeffs.h:44
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:413
#define info
Definition: libparse.cc:1256
The main handler for Singular numbers which are suitable for Singular polynomials.
int IsPrime(int p)
Definition: prime.cc:61

◆ nlQuotRem()

number nlQuotRem ( number  a,
number  b,
number *  r,
const coeffs  R 
)

Definition at line 2880 of file longrat.cc.

2881{
2882 assume(SR_TO_INT(b)!=0);
2883 if (SR_HDL(a) & SR_HDL(b) & SR_INT)
2884 {
2885 if (r!=NULL)
2886 *r = INT_TO_SR(SR_TO_INT(a) % SR_TO_INT(b));
2887 return INT_TO_SR(SR_TO_INT(a)/SR_TO_INT(b));
2888 }
2889 else if (SR_HDL(a) & SR_INT)
2890 {
2891 // -2^xx / 2^xx
2892 if ((a==INT_TO_SR(-(POW_2_28)))&&(b==INT_TO_SR(-1L)))
2893 {
2894 if (r!=NULL) *r=INT_TO_SR(0);
2895 return nlRInit(POW_2_28);
2896 }
2897 //a is small, b is not, so q=0, r=a
2898 if (r!=NULL)
2899 *r = a;
2900 return INT_TO_SR(0);
2901 }
2902 else if (SR_HDL(b) & SR_INT)
2903 {
2904 unsigned long rr;
2905 mpz_t qq;
2906 mpz_init(qq);
2907 mpz_t rrr;
2908 mpz_init(rrr);
2909 rr = mpz_divmod_ui(qq, rrr, a->z, (unsigned long)ABS(SR_TO_INT(b)));
2910 mpz_clear(rrr);
2911
2912 if (r!=NULL)
2913 *r = INT_TO_SR(rr);
2914 if (SR_TO_INT(b)<0)
2915 {
2916 mpz_neg(qq, qq);
2917 }
2918 return nlInitMPZ(qq,R);
2919 }
2920 mpz_t qq,rr;
2921 mpz_init(qq);
2922 mpz_init(rr);
2923 mpz_divmod(qq, rr, a->z, b->z);
2924 if (r!=NULL)
2925 *r = nlInitMPZ(rr,R);
2926 else
2927 {
2928 mpz_clear(rr);
2929 }
2930 return nlInitMPZ(qq,R);
2931}

◆ nlRandom()

static number nlRandom ( siRandProc  p,
number  v2,
number  ,
const coeffs  cf 
)
static

Definition at line 3461 of file longrat.cc.

3462{
3463 number a=nlInit(p(),cf);
3464 if (v2!=NULL)
3465 {
3466 number b=nlInit(p(),cf);
3467 number c=nlDiv(a,b,cf);
3468 nlDelete(&b,cf);
3469 nlDelete(&a,cf);
3470 a=c;
3471 }
3472 return a;
3473}

◆ nlRead()

const char * nlRead ( const char *  s,
number *  a,
const coeffs  r 
)

Definition at line 31 of file longrat0.cc.

32{
33 if (*s<'0' || *s>'9')
34 {
35 *a = INT_TO_SR(1); /* nlInit(1) */
36 return s;
37 }
38 *a=(number)ALLOC_RNUMBER();
39 {
40 (*a)->s = 3;
41#if defined(LDEBUG)
42 (*a)->debug=123456;
43#endif
44 mpz_ptr z=(*a)->z;
45 mpz_ptr n=(*a)->n;
46 mpz_init(z);
47 s = nEatLong((char *)s, z);
48 if (*s == '/')
49 {
50 mpz_init(n);
51 (*a)->s = 0;
52 s++;
53 s = nEatLong((char *)s, n);
54 if (mpz_cmp_si(n,0L)==0)
55 {
57 mpz_clear(n);
58 (*a)->s = 3;
59 }
60 else if (mpz_cmp_si(n,1L)==0)
61 {
62 mpz_clear(n);
63 (*a)->s=3;
64 }
65 }
66 if (mpz_cmp_si(z,0L)==0)
67 {
68 mpz_clear(z);
69 FREE_RNUMBER(*a);
70 *a=INT_TO_SR(0);
71 }
72 else if ((*a)->s==3)
73 {
74 number nlShort3_noinline(number x);
75 *a=nlShort3_noinline(*a);
76 }
77 else
78 {
79 number aa=*a;
80 nlNormalize(aa,r); // FIXME? TODO? // extern void nlNormalize(number &x, const coeffs r);
81 *a=aa;
82 }
83 }
84 return s;
85}

◆ nlReadFd()

number nlReadFd ( const ssiInfo d,
const  coeffs 
)

Definition at line 3376 of file longrat.cc.

3377{
3378 int sub_type=-1;
3379 sub_type=s_readint(d->f_read);
3380 switch(sub_type)
3381 {
3382 case 0:
3383 case 1:
3384 {// read mpz_t, mpz_t
3385 number n=nlRInit(0);
3386 mpz_init(n->n);
3387 s_readmpz(d->f_read,n->z);
3388 s_readmpz(d->f_read,n->n);
3389 n->s=sub_type;
3390 return n;
3391 }
3392
3393 case 3:
3394 {// read mpz_t
3395 number n=nlRInit(0);
3396 s_readmpz(d->f_read,n->z);
3397 n->s=3; /*sub_type*/
3398 #if SIZEOF_LONG == 8
3399 n=nlShort3(n);
3400 #endif
3401 return n;
3402 }
3403 case 4:
3404 {
3405 LONG dd=s_readlong(d->f_read);
3406 //#if SIZEOF_LONG == 8
3407 return INT_TO_SR(dd);
3408 //#else
3409 //return nlInit(dd,NULL);
3410 //#endif
3411 }
3412 case 5:
3413 case 6:
3414 {// read raw mpz_t, mpz_t
3415 number n=nlRInit(0);
3416 mpz_init(n->n);
3417 s_readmpz_base (d->f_read,n->z, SSI_BASE);
3418 s_readmpz_base (d->f_read,n->n, SSI_BASE);
3419 n->s=sub_type-5;
3420 return n;
3421 }
3422 case 8:
3423 {// read raw mpz_t
3424 number n=nlRInit(0);
3425 s_readmpz_base (d->f_read,n->z, SSI_BASE);
3426 n->s=sub_type=3; /*subtype-5*/
3427 #if SIZEOF_LONG == 8
3428 n=nlShort3(n);
3429 #endif
3430 return n;
3431 }
3432
3433 default: Werror("error in reading number: invalid subtype %d",sub_type);
3434 return NULL;
3435 }
3436 return NULL;
3437}
#define SSI_BASE
Definition: auxiliary.h:135
void Werror(const char *fmt,...)
Definition: reporter.cc:189
void s_readmpz(s_buff F, mpz_t a)
Definition: s_buff.cc:184
void s_readmpz_base(s_buff F, mpz_ptr a, int base)
Definition: s_buff.cc:209
int s_readint(s_buff F)
Definition: s_buff.cc:112
long s_readlong(s_buff F)
Definition: s_buff.cc:140
s_buff f_read
Definition: s_buff.h:22

◆ nlRInit()

number nlRInit ( long  i)

Definition at line 2530 of file longrat.cc.

2531{
2532 number z=ALLOC_RNUMBER();
2533#if defined(LDEBUG)
2534 z->debug=123456;
2535#endif
2536 mpz_init_set_si(z->z,i);
2537 z->s = 3;
2538 return z;
2539}

◆ nlSetMap()

nMapFunc nlSetMap ( const coeffs  src,
const coeffs  dst 
)

Definition at line 2480 of file longrat.cc.

2481{
2482 if (src->rep==n_rep_gap_rat) /*Q, coeffs_BIGINT */
2483 {
2484 if ((src->is_field==dst->is_field) /* Q->Q, Z->Z*/
2485 || (src->is_field==FALSE)) /* Z->Q */
2486 return nlCopyMap;
2487 return nlMapQtoZ; /* Q->Z */
2488 }
2489 if ((src->rep==n_rep_int) && nCoeff_is_Zp(src))
2490 {
2491 return nlMapP;
2492 }
2493 if ((src->rep==n_rep_float) && nCoeff_is_R(src))
2494 {
2495 if (dst->is_field) /* R -> Q */
2496 return nlMapR;
2497 else
2498 return nlMapR_BI; /* R -> bigint */
2499 }
2500 if ((src->rep==n_rep_gmp_float) && nCoeff_is_long_R(src))
2501 {
2502 if (dst->is_field)
2503 return nlMapLongR; /* long R -> Q */
2504 else
2505 return nlMapLongR_BI;
2506 }
2507 if (nCoeff_is_long_C(src))
2508 {
2509 return nlMapC; /* C -> Q */
2510 }
2511#ifdef HAVE_RINGS
2512 if (src->rep==n_rep_gmp) // nCoeff_is_Z(src) || nCoeff_is_Ring_PtoM(src) || nCoeff_is_Zn(src))
2513 {
2514 return nlMapGMP;
2515 }
2516 if (src->rep==n_rep_gap_gmp)
2517 {
2518 return nlMapZ;
2519 }
2520 if ((src->rep==n_rep_int) && nCoeff_is_Ring_2toM(src))
2521 {
2522 return nlMapMachineInt;
2523 }
2524#endif
2525 return NULL;
2526}
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:888
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:797
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition: coeffs.h:721
@ n_rep_gap_gmp
(), see rinteger.h, new impl.
Definition: coeffs.h:112
@ n_rep_float
(float), see shortfl.h
Definition: coeffs.h:116
@ n_rep_int
(int), see modulop.h
Definition: coeffs.h:110
@ n_rep_gmp_float
(gmp_float), see
Definition: coeffs.h:117
@ n_rep_gmp
(mpz_ptr), see rmodulon,h
Definition: coeffs.h:115
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition: coeffs.h:833
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:891
static number nlMapP(number from, const coeffs src, const coeffs dst)
Definition: longrat.cc:189
number nlMapZ(number from, const coeffs, const coeffs dst)
Definition: longrat.cc:211
static number nlMapLongR_BI(number from, const coeffs src, const coeffs dst)
Definition: longrat.cc:515
static number nlMapC(number from, const coeffs src, const coeffs dst)
Definition: longrat.cc:548
number nlCopyMap(number a, const coeffs, const coeffs)
Definition: longrat.cc:2452
static number nlMapGMP(number from, const coeffs, const coeffs dst)
Definition: longrat.cc:206
static number nlMapLongR(number from, const coeffs src, const coeffs dst)
Definition: longrat.cc:435
number nlMapMachineInt(number from, const coeffs, const coeffs)
Definition: longrat.cc:223
static number nlMapR(number from, const coeffs src, const coeffs dst)
Definition: longrat.cc:395
static number nlMapR_BI(number from, const coeffs src, const coeffs dst)
Definition: longrat.cc:425
number nlMapQtoZ(number a, const coeffs src, const coeffs dst)
Definition: longrat.cc:2461

◆ nlShort1()

number nlShort1 ( number  x)

Definition at line 1465 of file longrat.cc.

1466{
1467 assume(x->s<2);
1468 if (mpz_sgn1(x->z)==0)
1469 {
1471 return INT_TO_SR(0);
1472 }
1473 if (x->s<2)
1474 {
1475 if (mpz_cmp(x->z,x->n)==0)
1476 {
1478 return INT_TO_SR(1);
1479 }
1480 }
1481 return x;
1482}

◆ nlShort3()

static number nlShort3 ( number  x)
inlinestatic

Definition at line 109 of file longrat.cc.

110{
111 assume(x->s==3);
112 if (mpz_sgn1(x->z)==0)
113 {
114 mpz_clear(x->z);
116 return INT_TO_SR(0);
117 }
118 if (mpz_size1(x->z)<=MP_SMALL)
119 {
120 LONG ui=mpz_get_si(x->z);
121 if ((((ui<<3)>>3)==ui)
122 && (mpz_cmp_si(x->z,(long)ui)==0))
123 {
124 mpz_clear(x->z);
126 return INT_TO_SR(ui);
127 }
128 }
129 return x;
130}

◆ nlShort3_noinline()

number nlShort3_noinline ( number  x)

Definition at line 159 of file longrat.cc.

160{
161 return nlShort3(x);
162}

◆ nlSize()

int nlSize ( number  a,
const  coeffs 
)

Definition at line 714 of file longrat.cc.

715{
716 if (a==INT_TO_SR(0))
717 return 0; /* rational 0*/
718 if (SR_HDL(a) & SR_INT)
719 return 1; /* immediate int */
720 int s=a->z[0]._mp_alloc;
721// while ((s>0) &&(a->z._mp_d[s]==0L)) s--;
722//#if SIZEOF_LONG == 8
723// if (a->z._mp_d[s] < (unsigned long)0x100000000L) s=s*2-1;
724// else s *=2;
725//#endif
726// s++;
727 if (a->s<2)
728 {
729 int d=a->n[0]._mp_alloc;
730// while ((d>0) && (a->n._mp_d[d]==0L)) d--;
731//#if SIZEOF_LONG == 8
732// if (a->n._mp_d[d] < (unsigned long)0x100000000L) d=d*2-1;
733// else d *=2;
734//#endif
735 s+=d;
736 }
737 return s;
738}

◆ nlSub()

LINLINE number nlSub ( number  la,
number  li,
const coeffs  r 
)

Definition at line 2767 of file longrat.cc.

2768{
2769 if (SR_HDL(a) & SR_HDL(b) & SR_INT)
2770 {
2771 LONG r=SR_HDL(a)-SR_HDL(b)+1;
2772 if ( ((r << 1) >> 1) == r )
2773 {
2774 return (number)(long)r;
2775 }
2776 else
2777 return nlRInit(SR_TO_INT(r));
2778 }
2779 number u = _nlSub_aNoImm_OR_bNoImm(a, b);
2780 nlTest(u, r);
2781 return u;
2782
2783}
number _nlSub_aNoImm_OR_bNoImm(number a, number b)
Definition: longrat.cc:2120

◆ nlWrite()

void nlWrite ( number  a,
const coeffs  r 
)

Definition at line 90 of file longrat0.cc.

91{
92 char *s,*z;
93 if (SR_HDL(a) & SR_INT)
94 {
95 StringAppend("%ld",SR_TO_INT(a));
96 }
97 else if (a==NULL)
98 {
99 StringAppendS("o");
100 }
101 else
102 {
103 int l=mpz_sizeinbase(a->z,10);
104 if (a->s<2) l=si_max(l,(int)mpz_sizeinbase(a->n,10));
105 l+=2;
106 s=(char*)omAlloc(l);
107 z=mpz_get_str(s,10,a->z);
108 StringAppendS(z);
109 if (a->s!=3)
110 {
111 StringAppendS("/");
112 z=mpz_get_str(s,10,a->n);
113 StringAppendS(z);
114 }
115 omFreeSize((void *)s,l);
116 }
117}
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
#define StringAppend
Definition: emacs.cc:79
#define SR_HDL(A)
Definition: longrat0.cc:22
#define SR_TO_INT(SR)
Definition: longrat0.cc:25
void StringAppendS(const char *st)
Definition: reporter.cc:107

◆ nlWriteFd()

void nlWriteFd ( number  n,
const ssiInfo d,
const  coeffs 
)

Definition at line 3330 of file longrat.cc.

3331{
3332 if(SR_HDL(n) & SR_INT)
3333 {
3334 #if SIZEOF_LONG == 4
3335 fprintf(d->f_write,"4 %ld ",SR_TO_INT(n));
3336 #else
3337 long nn=SR_TO_INT(n);
3338 if ((nn<POW_2_28_32)&&(nn>= -POW_2_28_32))
3339 {
3340 int nnn=(int)nn;
3341 fprintf(d->f_write,"4 %d ",nnn);
3342 }
3343 else
3344 {
3345 mpz_t tmp;
3346 mpz_init_set_si(tmp,nn);
3347 fputs("8 ",d->f_write);
3348 mpz_out_str (d->f_write,SSI_BASE, tmp);
3349 fputc(' ',d->f_write);
3350 mpz_clear(tmp);
3351 }
3352 #endif
3353 }
3354 else if (n->s<2)
3355 {
3356 //gmp_fprintf(f,"%d %Zd %Zd ",n->s,n->z,n->n);
3357 fprintf(d->f_write,"%d ",n->s+5);
3358 mpz_out_str (d->f_write,SSI_BASE, n->z);
3359 fputc(' ',d->f_write);
3360 mpz_out_str (d->f_write,SSI_BASE, n->n);
3361 fputc(' ',d->f_write);
3362
3363 //if (d->f_debug!=NULL) gmp_fprintf(d->f_debug,"number: s=%d gmp/gmp \"%Zd %Zd\" ",n->s,n->z,n->n);
3364 }
3365 else /*n->s==3*/
3366 {
3367 //gmp_fprintf(d->f_write,"3 %Zd ",n->z);
3368 fputs("8 ",d->f_write);
3369 mpz_out_str (d->f_write,SSI_BASE, n->z);
3370 fputc(' ',d->f_write);
3371
3372 //if (d->f_debug!=NULL) gmp_fprintf(d->f_debug,"number: gmp \"%Zd\" ",n->z);
3373 }
3374}
#define POW_2_28_32
Definition: longrat.cc:104
FILE * f_write
Definition: s_buff.h:23

◆ nlXExtGcd()

number nlXExtGcd ( number  a,
number  b,
number *  s,
number *  t,
number *  u,
number *  v,
const coeffs  r 
)

Definition at line 2828 of file longrat.cc.

2829{
2830 if (SR_HDL(a) & SR_HDL(b) & SR_INT)
2831 {
2832 int uu, vv, x, y;
2833 int g = int_extgcd(SR_TO_INT(a), SR_TO_INT(b), &uu, &vv, &x, &y);
2834 *s = INT_TO_SR(uu);
2835 *t = INT_TO_SR(vv);
2836 *u = INT_TO_SR(x);
2837 *v = INT_TO_SR(y);
2838 return INT_TO_SR(g);
2839 }
2840 else
2841 {
2842 mpz_t aa, bb;
2843 if (SR_HDL(a) & SR_INT)
2844 {
2845 mpz_init_set_si(aa, SR_TO_INT(a));
2846 }
2847 else
2848 {
2849 mpz_init_set(aa, a->z);
2850 }
2851 if (SR_HDL(b) & SR_INT)
2852 {
2853 mpz_init_set_si(bb, SR_TO_INT(b));
2854 }
2855 else
2856 {
2857 mpz_init_set(bb, b->z);
2858 }
2859 mpz_t erg; mpz_t bs; mpz_t bt;
2860 mpz_init(erg);
2861 mpz_init(bs);
2862 mpz_init(bt);
2863
2864 mpz_gcdext(erg, bs, bt, aa, bb);
2865
2866 mpz_div(aa, aa, erg);
2867 *u=nlInitMPZ(bb,r);
2868 *u=nlNeg(*u,r);
2869 *v=nlInitMPZ(aa,r);
2870
2871 mpz_clear(aa);
2872 mpz_clear(bb);
2873
2874 *s = nlInitMPZ(bs,r);
2875 *t = nlInitMPZ(bt,r);
2876 return nlInitMPZ(erg,r);
2877 }
2878}
static int int_extgcd(int a, int b, int *u, int *x, int *v, int *y)
Definition: longrat.cc:1415

Variable Documentation

◆ n_SwitchChinRem

VAR int n_SwitchChinRem =0

Definition at line 3094 of file longrat.cc.