My Project  UNKNOWN_GIT_VERSION
numbers.h
Go to the documentation of this file.
1 #ifndef NUMBERS_H
2 #define NUMBERS_H
3 /****************************************
4 * Computer Algebra System SINGULAR *
5 ****************************************/
6 /*
7 * ABSTRACT: compatility interface to coeffs
8 */
9 #include "coeffs/coeffs.h"
10 #include "omalloc/omalloc.h" /* for SIZEOF_DOUBLE, SIZEOF_LONG*/
11 
12 // the access methods
13 //
14 // the routines w.r.t. currRing:
15 // (should only be used in the context of currRing, i.e. in t
16 #define nCopy(n) n_Copy(n, currRing->cf)
17 #define nDelete(n) n_Delete(n, currRing->cf)
18 #define nMult(n1, n2) n_Mult(n1, n2, currRing->cf)
19 #define nAdd(n1, n2) n_Add(n1, n2, currRing->cf)
20 #define nIsZero(n) n_IsZero(n, currRing->cf)
21 #define nEqual(n1, n2) n_Equal(n1, n2, currRing->cf)
22 #define nInpNeg(n) n_InpNeg(n, currRing->cf)
23 #define nSub(n1, n2) n_Sub(n1, n2, currRing->cf)
24 #define nGetChar() n_GetChar(currRing->cf)
25 #define nInit(i) n_Init(i, currRing->cf)
26 #define nIsOne(n) n_IsOne(n, currRing->cf)
27 #define nIsMOne(n) n_IsMOne(n, currRing->cf)
28 #define nGreaterZero(n) n_GreaterZero(n, currRing->cf)
29 #define nGreater(a, b) n_Greater (a,b,currRing->cf)
30 #define nWrite(n) n_Write(n, currRing->cf, rShortOut(currRing))
31 #define nNormalize(n) n_Normalize(n,currRing->cf)
32 #define nGcd(a,b) n_Gcd(a,b,currRing->cf)
33 #define nDiv(a, b) n_Div(a,b,currRing->cf)
34 #define nInvers(a) n_Invers(a,currRing->cf)
35 #define nExactDiv(a, b) n_ExactDiv(a,b,currRing->cf)
36 #define nTest(a) n_Test(a,currRing->cf)
37 
38 #define nInpMult(a, b) n_InpMult(a,b,currRing->cf)
39 #define nPower(a, b, res) n_Power(a,b,res,currRing->cf)
40 #define nSize(n) n_Size(n,currRing->cf)
41 #define nGetDenom(N) n_GetDenom((N),currRing->cf)
42 #define nGetNumerator(N) n_GetNumerator((N),currRing->cf)
43 
44 #define nSetMap(R) n_SetMap(R,currRing->cf)
45 
46 /// only for debug, over any initalized currRing
47 #define nPrint(a) n_Print(a,currRing->cf)
48 
49 
50 
51 
52 // --------------------------------------------------------------
53 // internal to coeffs, but public for all realizations
54 
55 #if SIZEOF_DOUBE == SIZEOF_LONG
56 #define SHORT_REAL_LENGTH 16 // use double for real <= 15 digits
57 #else
58 #define SHORT_REAL_LENGTH 6 // use float for real <= 6 digits
59 #endif
60 
61 /* the dummy routines: */
62 // void nDummy1(number* d);
63 // void ndDelete(number* d, const coeffs r);
64 number ndGcd(number a, number b, const coeffs);
65 // number ndCopy(number a, const coeffs r);
66 number ndCopyMap(number a, const coeffs src, const coeffs dst);
67 // int ndSize(number a, const coeffs r);
68 // number ndGetDenom(number &n, const coeffs r);
69 // number ndGetNumerator(number &a,const coeffs r);
70 // number ndReturn0(number n, const coeffs r);
71 // number ndIntMod(number a, number b, const coeffs r);
72 
73 // void ndInpMult(number &a, number b, const coeffs r);
74 // void ndInpAdd(number &a, number b, const coeffs r);
75 
76 // void ndKillChar(coeffs);
77 
78 // number ndInit_bigint(number i, const coeffs dummy, const coeffs dst);
79 
80 // BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void * parameter);
81 CanonicalForm ndConvSingNFactoryN( number, BOOLEAN /*setChar*/, const coeffs);
82 
83 /// Test whether a is a zero divisor in r
84 /// i.e. not coprime with char. of r
85 /// very inefficient implementation:
86 /// should ONLY be used for debug stuff /tests
87 BOOLEAN n_IsZeroDivisor( number a, const coeffs r);
88 
89 const char* const nDivBy0 = "div by 0";
90 
91 // dummy routines
92 // void ndNormalize(number& d, const coeffs); // nNormalize...
93 
94 /// initialize an object of type coeff, return FALSE in case of success
95 typedef BOOLEAN (*cfInitCharProc)(coeffs, void *);
97 
98 /// initialize an object of type coeffs by its name, return NULL otherwise
99 typedef coeffs (*cfInitCfByNameProc)(char *s,n_coeffType n);
101 
102 /// find an existing coeff by its "CoeffName"
103 coeffs nFindCoeffByName(char *n);
104 
105 /// divide by the first (leading) number and return it, i.e. make monic
106 // void ndClearContent(ICoeffsEnumerator& numberCollectionEnumerator, number& c, const coeffs r);
107 
108 /// does nothing (just returns a dummy one number)
109 // void ndClearDenominators(ICoeffsEnumerator& numberCollectionEnumerator, number& d, const coeffs r);
110 
111 /// helper routine: read an int from a string (mod m), return a pointer to the rest
112 char* nEati(char *s, int *i, int m);
113 
114 /// extracts a long integer from s, returns the rest
115 char * nEatLong(char *s, mpz_ptr i);
116 #endif
omalloc.h
ndGcd
number ndGcd(number a, number b, const coeffs)
Definition: numbers.cc:162
nRegisterCfByName
void nRegisterCfByName(cfInitCfByNameProc p, n_coeffType n)
Definition: numbers.cc:580
nFindCoeffByName
coeffs nFindCoeffByName(char *n)
find an existing coeff by its "CoeffName"
Definition: numbers.cc:589
b
CanonicalForm b
Definition: cfModGcd.cc:4044
nEati
char * nEati(char *s, int *i, int m)
divide by the first (leading) number and return it, i.e. make monic
Definition: numbers.cc:631
CanonicalForm
factory's main class
Definition: canonicalform.h:77
n_coeffType
n_coeffType
Definition: coeffs.h:26
i
int i
Definition: cfEzgcd.cc:125
nEatLong
char * nEatLong(char *s, mpz_ptr i)
extracts a long integer from s, returns the rest
Definition: numbers.cc:652
nDivBy0
const char *const nDivBy0
Definition: numbers.h:88
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
cfInitCharProc
BOOLEAN(* cfInitCharProc)(coeffs, void *)
initialize an object of type coeff, return FALSE in case of success
Definition: numbers.h:94
coeffs
nRegister
n_coeffType nRegister(n_coeffType n, cfInitCharProc p)
Definition: numbers.cc:539
ndConvSingNFactoryN
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:273
ndCopyMap
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition: numbers.cc:252
m
int m
Definition: cfEzgcd.cc:121
cfInitCfByNameProc
coeffs(* cfInitCfByNameProc)(char *s, n_coeffType n)
initialize an object of type coeffs by its name, return NULL otherwise
Definition: numbers.h:98
p
int p
Definition: cfModGcd.cc:4019
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
n_IsZeroDivisor
BOOLEAN n_IsZeroDivisor(number a, const coeffs r)
Test whether a is a zero divisor in r i.e. not coprime with char. of r very inefficient implementatio...
Definition: numbers.cc:146
coeffs.h