My Project  debian-1:4.1.2-p1+ds-2
OPAEQ.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 *Dense Integer Polynomials
6 */
7 //Schauen was hier überhaupt sinn macht
8 
9 #include "misc/auxiliary.h"
10 
11 #ifdef SINGULAR_4_2
12 
13 #include "omalloc/omalloc.h"
14 #include "factory/factory.h"
15 #include "misc/mylimits.h"
16 #include "reporter/reporter.h"
17 
18 #include "coeffs.h"
19 #include "numbers.h"
20 #include "mpr_complex.h"
21 #include "AEQ.h"
22 #include "modulop.h"
23 
24 #include <string.h>
25 
26 BOOLEAN nAEQCoeffIsEqual (number a, number b, const coeffs r);
27 number nAEQMult (number a, number b, const coeffs r);
28 number nAEQSub (number a, number b, const coeffs r);
29 number nAEQAdd (number a, number b, const coeffs r);
30 number nAEQDiv (number a, number b, const coeffs r);
31 number nAEQIntMod (number a, number b, const coeffs r);// Hir wollte wir was gucken
32 number nAEQExactDiv (number a, number b, const coeffs r);
33 number nAEQInit (long i, const coeffs r);
34 number nAEQInitMPZ (mpz_t m, const coeffs r); //nachgucken/fragen
35 int nAEQSize (number a, const coeffs r);///
36 long nAEQInt (number &a, const coeffs r);
37 number nAEQMPZ (number a, const coeffs r); //nachgucken/fragen
38 number nAEQNeg (number c, const coeffs r);
39 number nAEQCopy (number a, number b, const coeffs r); // nachgicken
40 number nAEQRePart (number a, number b, const coeffs r); // nachgicken
41 number nAEQImPart (number a, number b, const coeffs r); // nachgicken
42 
43 void nAEQWriteLong (number a, const coeffs r);//
44 void nAEQWriteShort (number a, const coeffs r);//
45 
46 
47 const char * nAEQRead (const char *s, number *a, const coeffs r);
48 number nAEQNormalize (number a, number b, const coeffs r);//
49 BOOLEAN nAEQGreater (number a, number b, const coeffs r);//
50 BOOLEAN nAEQEqual (number a, number b, const coeffs r);
51 BOOLEAN nAEQIsZero (number a, const coeffs r);
52 BOOLEAN nAEQIsOne (number a, const coeffs r);
53 BOOLEAN nAEQIsMOne (number a, const coeffs r);
54 BOOLEAN nAEQGreaterZero (number a, number b, const coeffs r);
55 void nAEQPower (number a, int i, number * result, const coeffs r);
56 number nAEQGetDenom (number &a, const coeffs r);//
57 number nAEQGetNumerator (number &a, const coeffs r);//
58 number nAEQGcd (number a, number b, const coeffs r);
59 number nAEQLcm (number a, number b, const coeffs r);
60 
61 void nAEQDelete (number *a, const coeffs r);//
62 number nAEQSetMap (number a, const coeffs r);//
63 void nAEQInpMult (number &a ,number b, const coeffs r);//
64 void nAEQCoeffWrite (const coeffs r, BOOLEAN details);//
65 
66 BOOLEAN nAEQClearContent (number a, const coeffs r);//
67 BOOLEAN nAEQClearDenominators (number a, const coeffs r);//
68 
69 
70 
71 
72 // DEFINITION DER FUNKTIONEN
73 
74 number nAEQAdd(number a, number b, const coeffs)
75 {
76  Q_poly* f=reinterpret_cast<Q_poly*> (a);
77  Q_poly* g=reinterpret_cast<Q_poly*> (b);
78  Q_poly *res=new Q_poly;
79  res->Q_poly_set(*f);
80  res->Q_poly_add_to(*g);
81  return (number) res;
82 }
83 
84 number nAEQMult(number a, number b, const coeffs)
85 {
86  Q_poly* f=reinterpret_cast<Q_poly*> (a);
87  Q_poly* g=reinterpret_cast<Q_poly*> (b);
88  Q_poly *res=new Q_poly;
89  res->Q_poly_set(*f);
90  res->Q_poly_mult_n_to(*g);
91  return (number) res;
92 }
93 
94 number nAEQSub(number a, number b, const coeffs)
95 {
96  Q_poly* f=reinterpret_cast<Q_poly*> (a);
97  Q_poly* g=reinterpret_cast<Q_poly*> (b);
98  Q_poly *res=new Q_poly;
99  res->Q_poly_set(*f);
100  res->Q_poly_sub_to(*g);
101  return (number) res;
102 }
103 
104 
105 number nAEQDiv(number a, number b, const coeffs)
106 {
107  Q_poly* f=reinterpret_cast<Q_poly*> (a);
108  Q_poly* g=reinterpret_cast<Q_poly*> (b);
109  Q_poly *res=new Q_poly;
110  Q_poly *s=new Q_poly;
111  res->Q_poly_set(*f);
112  res->Q_poly_div_to(*res,*s,*g);
113  return (number) res;
114 }
115 
116 
117 number nAEQIntMod(number a, number, const coeffs)
118 {
119  return a;
120 }
121 
122 number nAEQExactDiv(number a, number b, const coeffs)
123 {
124  Q_poly* f=reinterpret_cast<Q_poly*> (a);
125  Q_poly* g=reinterpret_cast<Q_poly*> (b);
126  Q_poly *res=new Q_poly;
127  Q_poly *s=new Q_poly;
128  res->Q_poly_set(*f);
129  res->Q_poly_div_to(*res,*s,*g);
130  return (number) res;
131 }
132 
133 
134 
135 number nAEQInit(long i, const coeffs)
136 {
137  number res = (number) i;
138  return res;
139 }
140 
141 number nAEQInitMPZ(mpz_t m, const coeffs)
142 {
143  number res= (number) m;
144  return res;
145 }
146 
147 int nAEQSize (number a, const coeffs)
148 {
149  Q_poly* f=reinterpret_cast<Q_poly*> (a);
150  return f->deg;
151 }
152 
153 long nAEQInt(number &, const coeffs)
154 {
155  return 1;
156 }
157 
158 
159 number nAEQMPZ(number a, const coeffs)
160 {
161  return a;
162 }
163 
164 
165 number nAEQNeg(number c, const coeffs)
166 {
167  Q_poly* f=reinterpret_cast<Q_poly*> (c);
168  Q_poly *res=new Q_poly;
169  res->Q_poly_set(*f);
170  res->Q_poly_neg();
171  return (number) res;
172 }
173 
174 number nAEQCopy(number c, const coeffs)
175 {
176  return (number) c;
177 }
178 
179 number nAEQRePart(number c, const coeffs)
180 {
181  return (number) c;
182 }
183 
184 number nAEQImPart(number c, const coeffs)
185 {
186  return (number) c;
187 }
188 
189 void nAEQWriteLong (number , const coeffs)
190 {
191  return;
192 }
193 
194 void nAEQWriteShort (number , const coeffs)
195 {
196  return ;
197 }
198 
199 
200 const char * nAEQRead (const char *, number *, const coeffs)
201 {
202  return "";
203 }
204 
205 number nAEQNormalize (number a, number , const coeffs) // ?
206 {
207  return a;
208 }
209 
210 BOOLEAN nAEQGreater (number a, number b, const coeffs)
211 {
212  Q_poly* f=reinterpret_cast<Q_poly*> (a);
213  Q_poly* g=reinterpret_cast<Q_poly*> (b);
214  if (f->deg > g->deg) {return FALSE;}
215  else {return TRUE;}
216 }
217 
218 BOOLEAN nAEQEqual (number a, number b, const coeffs)
219 {
220  Q_poly* f=reinterpret_cast<Q_poly*> (a);
221  Q_poly* g=reinterpret_cast<Q_poly*> (b);
222  if (f->is_equal(*g) == 1) {return FALSE;}
223  else {return TRUE;}
224 }
225 
226 BOOLEAN nAEQIsZero (number a, const coeffs)
227 {
228  Q_poly* f=reinterpret_cast<Q_poly*> (a);
229  if (f->is_zero() == 1) {return FALSE;}
230  else {return TRUE;}
231 }
232 
233 BOOLEAN nAEQIsOne (number a, const coeffs)
234 {
235  Q_poly* f=reinterpret_cast<Q_poly*> (a);
236  if (f->is_one() == 1) {return FALSE;}
237  else {return TRUE;}
238 }
239 
240 BOOLEAN nAEQIsMOne (number a, const coeffs)
241 {
242  Q_poly* f=reinterpret_cast<Q_poly*> (a);
243  if (f->is_one() == 1) {return FALSE;}
244  else {return TRUE;}
245 }
246 
247 BOOLEAN nAEQGreaterZero (number a, const coeffs r)
248 {
249  if (nAEQIsZero(a, r) == FALSE) { return TRUE; }
250  else { return FALSE; }
251 }
252 
253 void nAEQPower (number, int, number *, const coeffs)
254 {
255  return;
256 }
257 
258 number nAEQGetDenom (number &, const coeffs)
259 {
260  return (number) 1;
261 }
262 
263 number nAEQGetNumerator (number &a, const coeffs)
264 {
265  return a;
266 }
267 
268 number nAEQGcd (number a, number b, const coeffs)
269 {
270  Q_poly* f=reinterpret_cast<Q_poly*> (a);
271  Q_poly* g=reinterpret_cast<Q_poly*> (b);
272  Q_poly *res=new Q_poly;
273  res->Q_poly_gcd(*f,*g);
274  return (number) res;
275 }
276 
277 number nAEQLcm (number a, number b, const coeffs)
278 {
279  Q_poly* f=reinterpret_cast<Q_poly*> (a);
280  Q_poly* g=reinterpret_cast<Q_poly*> (b);
281  Q_poly *gcd=new Q_poly;
282  Q_poly *res=new Q_poly;
283  Q_poly *s=new Q_poly;
284  gcd->Q_poly_gcd(*f,*g);
285  res->Q_poly_mult_n(*f,*g);
286  res->Q_poly_div_to(*res,*s,*gcd);
287  return (number) res;
288 }
289 
290 void nAEQDelete (number *, const coeffs)
291 {
292  return;
293 }
294 
295 /*
296 number nAEQSetMap (number a, const coeffs)
297 {
298  return a;
299 }
300 */
301 
302 void nAEQInpMult (number &, number, const coeffs)
303 {
304  return ;
305 }
306 
307 void nAEQCoeffWrite (const coeffs, BOOLEAN)
308 {
309  return;
310 }
311 
312 BOOLEAN nAEQClearContent (number, const coeffs)
313 {
314  return FALSE;
315 }
316 
317 BOOLEAN nAEQClearDenominators (number, const coeffs)
318 {
319  return FALSE;
320 }
321 
322 static char * n_QAECoeffName(const coeffs r)
323 {
324  return (char*)("QAE");
325 }
326 
327 static char * n_QAECoeffString(const coeffs r)
328 {
329  return omStrDup("QAE");
330 }
331 
332 
333 //INITIALISIERUNG FÜR SINGULAR
334 
335 
336 BOOLEAN n_QAEInitChar(coeffs r, void *)
337 {
338  // r->is_field,is_domain?
339  r->ch=0;
340  //r->cfKillChar=ndKillChar;
341  //r->nCoeffIsEqual=ndCoeffIsEqual;
342  r->cfMult = nAEQMult;
343  r->cfSub = nAEQSub;
344  r->cfAdd = nAEQAdd;
345  r->cfDiv = nAEQDiv;
346  r->cfIntMod= nAEQIntMod;
347  r->cfExactDiv= nAEQExactDiv;
348  r->cfInit = nAEQInit;
349  r->cfSize = nAEQSize;
350  r->cfInt = nAEQInt;
351  r->cfCoeffName = n_QAECoeffName;
352  r->cfCoeffString = n_QAECoeffString;
353 #ifdef HAVE_RINGS
354  //r->cfDivComp = NULL; // only for ring stuff
355  //r->cfIsUnit = NULL; // only for ring stuff
356  //r->cfGetUnit = NULL; // only for ring stuff
357  //r->cfExtGcd = NULL; // only for ring stuff
358  // r->cfDivBy = NULL; // only for ring stuff
359 #endif
360  r->cfInpNeg = nAEQNeg;
361  r->cfInvers= NULL;
362  //r->cfCopy = ndCopy;
363  //r->cfRePart = ndCopy;
364  //r->cfImPart = ndReturn0;
365  r->cfWriteLong = nAEQWriteLong;
366  r->cfRead = nAEQRead;
367  //r->cfNormalize=ndNormalize;
368  r->cfGreater = nAEQGreater;
369  r->cfEqual = nAEQEqual;
370  r->cfIsZero = nAEQIsZero;
371  r->cfIsOne = nAEQIsOne;
372  r->cfIsMOne = nAEQIsOne;
373  r->cfGreaterZero = nAEQGreaterZero;
374  r->cfPower = nAEQPower; // ZU BEARBEITEN
375  r->cfGetDenom = nAEQGetDenom;
376  r->cfGetNumerator = nAEQGetNumerator;
377  r->cfGcd = nAEQGcd;
378  r->cfLcm = nAEQLcm; // ZU BEARBEITEN
379  r->cfDelete= nAEQDelete;
380 
381  r->cfSetMap = npSetMap; // extern nMapFunc npSetMap(const coeffs src, const coeffs dst); // FIXME: WHY??? // TODO: this seems to be a bug!
382 
383  r->cfInpMult=nAEQInpMult; //????
384  r->cfCoeffWrite=nAEQCoeffWrite; //????
385 
386 
387  //r->type = n_AE;
388  r->has_simple_Alloc=TRUE;
389  r->has_simple_Inverse=TRUE;
390  return FALSE;
391 }
392 #endif
FALSE
#define FALSE
Definition: auxiliary.h:96
omalloc.h
mpr_complex.h
f
FILE * f
Definition: checklibs.c:9
npSetMap
nMapFunc npSetMap(const coeffs src, const coeffs dst)
Definition: modulop.cc:653
result
return result
Definition: facAbsBiFact.cc:76
g
g
Definition: cfModGcd.cc:4031
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:261
auxiliary.h
reporter.h
b
CanonicalForm b
Definition: cfModGcd.cc:4044
TRUE
#define TRUE
Definition: auxiliary.h:100
i
int i
Definition: cfEzgcd.cc:125
res
CanonicalForm res
Definition: facAbsFact.cc:64
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:87
coeffs
return
return
Definition: cfGcdAlgExt.cc:218
mylimits.h
m
int m
Definition: cfEzgcd.cc:121
NULL
#define NULL
Definition: omList.c:11
gcd
int gcd(int a, int b)
Definition: walkSupport.cc:836
AEQ.h
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
numbers.h
modulop.h
coeffs.h