1 | #ifndef NUMBERS_H |
---|
2 | #define NUMBERS_H |
---|
3 | /**************************************** |
---|
4 | * Computer Algebra System SINGULAR * |
---|
5 | ****************************************/ |
---|
6 | /* $Id$ */ |
---|
7 | /* |
---|
8 | * ABSTRACT: interface to coefficient aritmetics |
---|
9 | */ |
---|
10 | #include "coeffs.h" |
---|
11 | |
---|
12 | #define SHORT_REAL_LENGTH 6 // use short reals for real <= 6 digits |
---|
13 | |
---|
14 | #define n_Copy(n, r) (r)->cfCopy(n,r) |
---|
15 | #define n_Delete(n, r) (r)->cfDelete(n,r) |
---|
16 | #define n_Mult(n1, n2, r) (r)->nMult(n1, n2,r) |
---|
17 | #define n_Add(n1, n2, r) (r)->nAdd(n1, n2,r) |
---|
18 | #define n_IsZero(n, r) (r)->nIsZero(n,r) |
---|
19 | #define n_Equal(n1, n2, r) (r)->nEqual(n1, n2,r) |
---|
20 | #define n_Neg(n, r) (r)->nNeg(n,r) |
---|
21 | #define n_Sub(n1, n2, r) (r)->nSub(n1, n2,r) |
---|
22 | #define n_GetChar(r) ((r)->ch) |
---|
23 | #define n_Init(i, r) (r)->cfInit(i,r) |
---|
24 | #define n_IsOne(n, r) (r)->nIsOne(n,r) |
---|
25 | #define n_IsMOne(n, r) (r)->nIsMOne(n,r) |
---|
26 | #define n_GreaterZero(n, r) (r)->nGreaterZero(n,r) |
---|
27 | #define n_Write(n, r) (r)->cfWrite(n,r) |
---|
28 | #define n_Normalize(n, r) (r)->nNormalize(n,r) |
---|
29 | #define n_Gcd(a, b, r) (r)->nGcd(a,b,r) |
---|
30 | #define n_IntDiv(a, b, r) (r)->nIntDiv(a,b,r) |
---|
31 | #define n_Div(a, b, r) (r)->nDiv(a,b,r) |
---|
32 | #define n_Invers(a, r) (r)->nInvers(a,r) |
---|
33 | #define n_ExactDiv(a, b, r) (r)->nExactDiv(a,b,r) |
---|
34 | #define n_Test(a,r) (r)->nDBTest(a,r,__FILE__,__LINE__) |
---|
35 | |
---|
36 | #define n_InpMult(a, b, r) (r)->nInpMult(a,b,r) |
---|
37 | #define n_Power(a, b, res, r) (r)->nPower(a,b,res,r) |
---|
38 | #define n_Size(n,r) (r)->nSize(n,r) |
---|
39 | #define n_GetDenom(N,r) (r)->cfGetDenom((N),r) |
---|
40 | #define n_GetNumerator(N,r) (r)->cfGetNumerator((N),r) |
---|
41 | |
---|
42 | #define n_New(n, r) nNew(n) |
---|
43 | |
---|
44 | /* variables */ |
---|
45 | extern unsigned short fftable[]; |
---|
46 | |
---|
47 | /* prototypes */ |
---|
48 | void nNew(number * a); |
---|
49 | #define nInit(i) n_Init(i,currRing) |
---|
50 | #define nWrite(A) n_Write(A,currRing) |
---|
51 | |
---|
52 | #define nTest(a) (1) |
---|
53 | |
---|
54 | // please use n_* counterparts instead!!! |
---|
55 | // #define nDelete(A) (currRing)->cf->cfDelete(A,currRing) |
---|
56 | // #define nGetDenom(N) (currRing->cf->cfGetDenom((N),currRing)) |
---|
57 | // #define nGetNumerator(N) (currRing->cf->cfGetNumerator((N),currRing)) |
---|
58 | |
---|
59 | |
---|
60 | #define nSetMap(R) (currRing->cf->cfSetMap(R,currRing)) |
---|
61 | |
---|
62 | void nDummy1(number* d); |
---|
63 | void ndDelete(number* d, const coeffs r); |
---|
64 | void nDummy2(number &d); |
---|
65 | number ndGcd(number a, number b, const coeffs); |
---|
66 | number ndCopy(number a, const coeffs r); |
---|
67 | number ndCopyMap(number a, const coeffs r, const coeffs aRing); |
---|
68 | |
---|
69 | void ndInpMult(number &a, number b, const coeffs r); |
---|
70 | number ndInpAdd(number &a, number b, const coeffs r); |
---|
71 | |
---|
72 | #ifdef LDEBUG |
---|
73 | void nDBDummy1(number* d,char *f, int l); |
---|
74 | #endif |
---|
75 | #define nGetChar() n_GetChar(currRing) |
---|
76 | |
---|
77 | void nInitChar(coeffs r); // do one-time initialisations |
---|
78 | void nKillChar(coeffs r); // undo all initialisations |
---|
79 | void nSetChar(coeffs r); // initialisations after each ring chage |
---|
80 | |
---|
81 | #define nDivBy0 "div by 0" |
---|
82 | |
---|
83 | // dummy routines |
---|
84 | void nDummy2(number& d); // nNormalize... |
---|
85 | |
---|
86 | // Tests: |
---|
87 | static inline BOOLEAN nField_is_Ring_2toM(const coeffs r) |
---|
88 | { return (r->ringtype == 1); } |
---|
89 | |
---|
90 | static inline BOOLEAN nField_is_Ring_ModN(const coeffs r) |
---|
91 | { return (r->ringtype == 2); } |
---|
92 | |
---|
93 | static inline BOOLEAN nField_is_Ring_PtoM(const coeffs r) |
---|
94 | { return (r->ringtype == 3); } |
---|
95 | |
---|
96 | static inline BOOLEAN nField_is_Ring_Z(const coeffs r) |
---|
97 | { return (r->ringtype == 4); } |
---|
98 | |
---|
99 | static inline BOOLEAN nField_is_Ring(const coeffs r) |
---|
100 | { return (r->ringtype != 0); } |
---|
101 | |
---|
102 | static inline BOOLEAN nField_is_Domain(const coeffs r) |
---|
103 | { return (r->ringtype == 4 || r->ringtype == 0); } |
---|
104 | |
---|
105 | static inline BOOLEAN nField_has_Units(const coeffs r) |
---|
106 | { return ((r->ringtype == 1) || (r->ringtype == 2) || (r->ringtype == 3)); } |
---|
107 | |
---|
108 | |
---|
109 | #ifdef _TRY |
---|
110 | #define rField_is_Q(r) nField_is_Q(r) |
---|
111 | #define rField_is_long_R(r) nField_is_long_R(r) |
---|
112 | #define rField_is_long_C(r) nField_is_long_C(r) |
---|
113 | #define rField_is_R(r) nField_is_R(r) |
---|
114 | #define rField_is_Zp(r) nField_is_Zp(r) |
---|
115 | #endif |
---|
116 | |
---|
117 | |
---|
118 | static inline n_coeffType nField_is(const coeffs r) |
---|
119 | { return r->fieldtype; } |
---|
120 | static inline BOOLEAN nField_is_Zp(const coeffs r) |
---|
121 | { return nField_is(r)==n_Zp; } |
---|
122 | |
---|
123 | static inline BOOLEAN nField_is_Zp(const coeffs r, int p) |
---|
124 | { return (nField_is_Zp(r) && (r->ch == ABS(p))); } |
---|
125 | |
---|
126 | static inline BOOLEAN nField_is_Q(const coeffs r) |
---|
127 | { return nField_is(r)==n_Q; } |
---|
128 | |
---|
129 | static inline BOOLEAN nField_is_numeric(const coeffs r) /* R, long R, long C */ |
---|
130 | { return (nField_is(r)==n_R) || (nField_is(r)==n_long_R) || (nField_is(r)==n_long_C); } |
---|
131 | |
---|
132 | static inline BOOLEAN nField_is_R(const coeffs r) |
---|
133 | { return nField_is(r)==n_R; } |
---|
134 | |
---|
135 | static inline BOOLEAN nField_is_GF(const coeffs r) |
---|
136 | { return nField_is(r)==n_GF; } |
---|
137 | |
---|
138 | static inline BOOLEAN nField_is_GF(const coeffs r, int q) |
---|
139 | { return (nField_is(r)==n_GF) && (r->ch == q); } |
---|
140 | |
---|
141 | static inline BOOLEAN nField_is_Zp_a(const coeffs r) |
---|
142 | { return (r->ringtype == 0) && (r->ch < -1); } |
---|
143 | |
---|
144 | static inline BOOLEAN nField_is_Zp_a(const coeffs r, int p) |
---|
145 | { return (r->ringtype == 0) && (r->ch < -1 ) && (-(r->ch) == ABS(p)); } |
---|
146 | |
---|
147 | static inline BOOLEAN nField_is_Q_a(const coeffs r) |
---|
148 | { return (r->ringtype == 0) && (r->ch == 1); } |
---|
149 | |
---|
150 | static inline BOOLEAN nField_is_long_R(const coeffs r) |
---|
151 | { return nField_is(r)==n_long_R; } |
---|
152 | |
---|
153 | static inline BOOLEAN nField_is_long_C(const coeffs r) |
---|
154 | { return nField_is(r)==n_long_C; } |
---|
155 | |
---|
156 | static inline BOOLEAN nField_has_simple_inverse(const coeffs r) |
---|
157 | /* { return (r->ch>1) || (r->ch== -1); } *//* Z/p, GF(p,n), R, long_R, long_C*/ |
---|
158 | #ifdef HAVE_RINGS |
---|
159 | { return (r->ringtype > 0) || (r->ch>1) || ((r->ch== -1) && (r->float_len < 10)); } /* Z/2^n, Z/p, GF(p,n), R, long_R, long_C*/ |
---|
160 | #else |
---|
161 | { return (r->ch>1) || ((r->ch== -1) && (r->float_len < 10)); } /* Z/p, GF(p,n), R, long_R, long_C*/ |
---|
162 | #endif |
---|
163 | |
---|
164 | static inline BOOLEAN nField_has_simple_Alloc(const coeffs r) |
---|
165 | { return (nField_is_Zp(r) |
---|
166 | || nField_is_GF(r) |
---|
167 | #ifdef HAVE_RINGS |
---|
168 | || nField_is_Ring_2toM(r) |
---|
169 | #endif |
---|
170 | || nField_is_R(r)); |
---|
171 | } |
---|
172 | /* Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies*/ |
---|
173 | |
---|
174 | static inline BOOLEAN nField_is_Extension(const coeffs r) |
---|
175 | { return (nField_is_Q_a(r)) || (nField_is_Zp_a(r)); } /* Z/p(a) and Q(a)*/ |
---|
176 | |
---|
177 | #endif |
---|