My Project  UNKNOWN_GIT_VERSION
OPAE.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 #include "omalloc/omalloc.h"
13 #include "factory/factory.h"
14 #include "misc/mylimits.h"
15 #include "reporter/reporter.h"
16 
17 #include "coeffs/coeffs.h"
18 #include "coeffs/numbers.h"
19 #include "coeffs/mpr_complex.h"
20 
21 #include "OPAE.h"
22 #include "AE.h"
23 
24 #include <string.h>
25 
26 
27 BOOLEAN nAECoeffIsEqual (number a, number b, const coeffs r);
28 number nAEMult (number a, number b, const coeffs r);
29 number nAESub (number a, number b, const coeffs r);
30 number nAEAdd (number a, number b, const coeffs r);
31 number nAEDiv (number a, number b, const coeffs r);
32 number nAEIntMod (number a, number b, const coeffs r);// Hir wollte wir was gucken
33 number nAEExactDiv (number a, number b, const coeffs r);
34 number nAEInit (long i, const coeffs r);
35 number nAEInitMPZ (mpz_t m, const coeffs r); //nachgucken/fragen
36 int nAESize (number a, const coeffs r);///
37 long nAEInt (number &a, const coeffs r);
38 number nAEMPZ (number a, const coeffs r); //nachgucken/fragen
39 number nAENeg (number c, const coeffs r);
40 number nAECopy (number a, number b, const coeffs r); // nachgicken
41 number nAERePart (number a, number b, const coeffs r); // nachgicken
42 number nAEImPart (number a, number b, const coeffs r); // nachgicken
43 
44 void nAEWriteLong (number a, const coeffs r);//
45 void nAEWriteShort (number a, const coeffs r);//
46 
47 
48 const char * nAERead (const char *s, number *a, const coeffs r);
49 number nAENormalize (number a, number b, const coeffs r);//
50 BOOLEAN nAEGreater (number a, number b, const coeffs r);//
51 BOOLEAN nAEEqual (number a, number b, const coeffs r);
52 BOOLEAN nAEIsZero (number a, const coeffs r);
53 BOOLEAN nAEIsOne (number a, const coeffs r);
54 BOOLEAN nAEIsMOne (number a, const coeffs r);
55 BOOLEAN nAEGreaterZero (number a, number b, const coeffs r);
56 void nAEPower (number a, int i, number * result, const coeffs r);
57 number nAEGetDenom (number &a, const coeffs r);//
58 number nAEGetNumerator (number &a, const coeffs r);//
59 number nAEGcd (number a, number b, const coeffs r);
60 number nAELcm (number a, number b, const coeffs r);
61 
62 void nAEDelete (number *a, const coeffs r);//
63 number nAESetMap (number a, const coeffs r);//
64 void nAEInpMult (number &a ,number b, const coeffs r);//
65 void nAECoeffWrite (const coeffs r, BOOLEAN details);//
66 
67 BOOLEAN nAEClearContent (number a, const coeffs r);//
68 BOOLEAN nAEClearDenominators (number a, const coeffs r);//
69 
70 
71 
72 
73 // DEFINITION DER FUNKTIONEN
74 
75 number nAEAdd(number a, number b, const coeffs)
76 {
77  int_poly* f=reinterpret_cast<int_poly*> (a);
78  int_poly* g=reinterpret_cast<int_poly*> (b);
79  int_poly *res=new int_poly;
80  res->poly_set(*f);
81  res->poly_add_to(*g);
82  return (number) res;
83 }
84 
85 number nAEMult(number a, number b, const coeffs)
86 {
87  int_poly* f=reinterpret_cast<int_poly*> (a);
88  int_poly* g=reinterpret_cast<int_poly*> (b);
89  int_poly *res=new int_poly;
90  res->poly_set(*f);
91  res->poly_mult_n_to(*g);
92  return (number) res;
93 }
94 
95 number nAESub(number a, number b, const coeffs)
96 {
97  int_poly* f=reinterpret_cast<int_poly*> (a);
98  int_poly* g=reinterpret_cast<int_poly*> (b);
99  int_poly *res=new int_poly;
100  res->poly_set(*f);
101  res->poly_sub_to(*g);
102  return (number) res;
103 }
104 
105 
106 number nAEDiv(number a, number b, const coeffs)
107 {
108  int_poly* f=reinterpret_cast<int_poly*> (a);
109  int_poly* g=reinterpret_cast<int_poly*> (b);
110  int_poly *res=new int_poly;
111  res->poly_set(*f);
112  res->poly_div_to(*res,*f,*g);
113  return (number) res;
114 }
115 
116 
117 number nAEIntMod(number a, number, const coeffs)
118 {
119  return a;
120 }
121 
122 number nAEExactDiv(number a, number b, const coeffs)
123 {
124  int_poly* f=reinterpret_cast<int_poly*> (a);
125  int_poly* g=reinterpret_cast<int_poly*> (b);
126  int_poly *res=new int_poly;
127  res->poly_set(*f);
128  res->poly_div_to(*res,*f,*g);
129  return (number) res;
130 }
131 
132 
133 
134 number nAEInit(long i, const coeffs)
135 {
136  mpz_t m;
137  mpz_init_set_ui(m, i);
138  int_poly* res=new int_poly;
139  res->poly_set(m);
140  number res1=reinterpret_cast<number>(res);
141  return res1;
142 }
143 
144 number nAEInitMPZ(mpz_t m, const coeffs)
145 {
146  int_poly* res=new int_poly;
147  res->poly_set(m);
148  number res1=reinterpret_cast<number>(res);
149  return res1;
150 }
151 
152 
153 int nAESize (number a, const coeffs)
154 {
155  int_poly* f=reinterpret_cast<int_poly*> (a);
156  return f->deg;
157 }
158 
159 long nAEInt(number &, const coeffs)
160 {
161  return 1;
162 }
163 
164 
165 number nAEMPZ(number a, const coeffs)
166 {
167  return a;
168 }
169 
170 
171 number nAENeg(number c, const coeffs)
172 {
173  int_poly* f=reinterpret_cast<int_poly*> (c);
174  int_poly *res=new int_poly;
175  res->poly_set(*f);
176  res->poly_neg();
177  return (number) res;
178 }
179 
180 number nAECopy(number c, const coeffs)
181 {
182  return (number) c;
183 }
184 
185 number nAERePart(number c, const coeffs)
186 {
187  return (number) c;
188 }
189 
190 number nAEImPart(number c, const coeffs)
191 {
192  return (number) c;
193 }
194 
195 void nAEWriteLong (number a, const coeffs)
196 {
197  int_poly* f=reinterpret_cast <int_poly*>(a);
198  f->poly_print();
199  return ;
200 }
201 
202 void nAEWriteShort (number a, const coeffs)
203 {
204  int_poly* f=reinterpret_cast <int_poly*>(a);
205  f->poly_print();
206  return ;
207 }
208 
209 
210 const char * nAERead (const char *, number *, const coeffs)
211 {
212  char* c=new char;
213  *c='c';
214  return c;
215 }
216 
217 number nAENormalize (number a, number, const coeffs) // ?
218 {
219  return a;
220 }
221 
222 BOOLEAN nAEGreater (number a, number b, const coeffs)
223 {
224  int_poly* f=reinterpret_cast<int_poly*> (a);
225  int_poly* g=reinterpret_cast<int_poly*> (b);
226  if (f->deg > g->deg) {return FALSE;}
227  else {return TRUE;}
228 }
229 
230 BOOLEAN nAEEqual (number a, number b, const coeffs)
231 {
232  int_poly* f=reinterpret_cast<int_poly*> (a);
233  int_poly* g=reinterpret_cast<int_poly*> (b);
234  if (f->is_equal(*g) == 1) {return FALSE;}
235  else {return TRUE;}
236 }
237 
238 BOOLEAN nAEIsZero (number a, const coeffs)
239 {
240  int_poly* f=reinterpret_cast<int_poly*> (a);
241  if (f->is_zero() == 1) {return FALSE;}
242  else {return TRUE;}
243 }
244 
245 BOOLEAN nAEIsOne (number a, const coeffs)
246 {
247  int_poly* f=reinterpret_cast<int_poly*> (a);
248  if (f->is_one() == 1) {return FALSE;}
249  else {return TRUE;}
250 }
251 
252 BOOLEAN nAEIsMOne (number a, const coeffs)
253 {
254  int_poly* f=reinterpret_cast<int_poly*> (a);
255  if (f->is_one() == 1) {return FALSE;}
256  else {return TRUE;}
257 }
258 
259 BOOLEAN nAEGreaterZero (number a, const coeffs r)
260 {
261  if (nAEIsZero(a, r) == FALSE) { return TRUE; }
262  else { return FALSE; }
263 }
264 
265 void nAEPower (number, int, number *, const coeffs)
266 {
267  return;
268 }
269 
270 number nAEGetDenom (number &, const coeffs)
271 {
272  return (number) 1;
273 }
274 
275 number nAEGetNumerator (number &a, const coeffs)
276 {
277  return a;
278 }
279 
280 number nAEGcd (number a, number b, const coeffs)
281 {
282  int_poly* f=reinterpret_cast<int_poly*> (a);
283  int_poly* g=reinterpret_cast<int_poly*> (b);
284  int_poly *res=new int_poly;
285  res->poly_gcd(*f,*g);
286  return (number) res;
287 }
288 
289 number nAELcm (number a, number b, const coeffs)
290 {
291  int_poly* f=reinterpret_cast<int_poly*> (a);
292  int_poly* g=reinterpret_cast<int_poly*> (b);
293  int_poly *gcd=new int_poly;
294  int_poly *res=new int_poly;
295  gcd->poly_gcd(*f,*g);
296  res->poly_mult_n(*f,*g);
297  res->poly_div_to(*res,*f,*gcd);
298  return (number) res;
299 }
300 
301 void nAEDelete (number *, const coeffs)
302 {
303  return;
304 }
305 
306 nMapFunc nAESetMap (const coeffs src, const coeffs dst)
307 {
308  if (src==dst) return ndCopyMap; // UNDEFINED: nAECopyMap; // BUG :(
309  else return NULL;
310 }
311 
312 void nAEInpMult (number &, number, const coeffs)
313 {
314  return ;
315 }
316 
317 void nAECoeffWrite (const coeffs, BOOLEAN)
318 {
319  return;
320 }
321 
322 BOOLEAN nAEClearContent (number, const coeffs)
323 {
324  return FALSE;
325 }
326 
327 BOOLEAN nAEClearDenominators (number, const coeffs)
328 {
329  return FALSE;
330 }
331 
332 static char * n_AECoeffName(const coeffs r)
333 {
334  return (char*)("AE");
335 }
336 
337 static char * nAECoeffString(const coeffs r)
338 {
339  return omStrDup("AE");
340 }
341 
342 //INITIALISIERUNG FÜR SINGULAR
343 
344 
345 BOOLEAN n_AEInitChar(coeffs r, void *)
346 {
347  // r->is_field, r->is_domain?
348  r->ch = 0;
349  //r->cfKillChar = ndKillChar; /* dummy */
350  //r->nCoeffIsEqual=ndCoeffIsEqual;
351  r->cfMult = nAEMult;
352  r->cfSub = nAESub;
353  r->cfAdd = nAEAdd;
354  r->cfDiv = nAEDiv;
355  r->cfIntMod= nAEIntMod;
356  r->cfExactDiv= nAEExactDiv;
357  r->cfInit = nAEInit;
358  r->cfSize = nAESize;
359  r->cfInt = nAEInt;
360  r->cfCoeffName = n_AECoeffName;
361 #ifdef HAVE_RINGS
362  //r->cfDivComp = NULL; // only for ring stuff
363  //r->cfIsUnit = NULL; // only for ring stuff
364  //r->cfGetUnit = NULL; // only for ring stuff
365  //r->cfExtGcd = NULL; // only for ring stuff
366  // r->cfDivBy = NULL; // only for ring stuff
367 #endif
368  r->cfInpNeg = nAENeg;
369  r->cfInvers= NULL;
370  //r->cfCopy = ndCopy;
371  //r->cfRePart = ndCopy;
372  //r->cfImPart = ndReturn0;
373  r->cfWriteLong = nAEWriteLong;
374  r->cfRead = nAERead;
375  //r->cfNormalize=ndNormalize;
376  r->cfGreater = nAEGreater;
377  r->cfEqual = nAEEqual;
378  r->cfIsZero = nAEIsZero;
379  r->cfIsOne = nAEIsOne;
380  r->cfIsMOne = nAEIsOne;
381  r->cfGreaterZero = nAEGreaterZero;
382  r->cfPower = nAEPower; // ZU BEARBEITEN
383  r->cfGetDenom = nAEGetDenom;
384  r->cfGetNumerator = nAEGetNumerator;
385  r->cfGcd = nAEGcd;
386  r->cfLcm = nAELcm; // ZU BEARBEITEN
387  r->cfDelete= nAEDelete;
388  r->cfCoeffString=nAECoeffString;
389 
390  r->cfSetMap = nAESetMap;
391 
392  r->cfInpMult=nAEInpMult; //????
393  r->cfCoeffWrite=nAECoeffWrite; //????
394 
395 
396  //r->type = n_AE;
397  r->ch = 0;
398  r->has_simple_Alloc=TRUE;
399  r->has_simple_Inverse=TRUE;
400  return FALSE;
401 }
402 #endif
All the auxiliary stuff.
int BOOLEAN
Definition: auxiliary.h:85
#define TRUE
Definition: auxiliary.h:98
#define FALSE
Definition: auxiliary.h:94
int m
Definition: cfEzgcd.cc:121
int i
Definition: cfEzgcd.cc:125
return
Definition: cfGcdAlgExt.cc:218
g
Definition: cfModGcd.cc:4031
CanonicalForm b
Definition: cfModGcd.cc:4044
FILE * f
Definition: checklibs.c:9
Coefficient rings, fields and other domains suitable for Singular polynomials.
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
return result
Definition: facAbsBiFact.cc:76
const CanonicalForm int s
Definition: facAbsFact.cc:55
CanonicalForm res
Definition: facAbsFact.cc:64
The main handler for Singular numbers which are suitable for Singular polynomials.
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
Definition: numbers.cc:252
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define NULL
Definition: omList.c:10
int gcd(int a, int b)
Definition: walkSupport.cc:836