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