source: git/libpolys/coeffs/OPAE.cc @ 2206753

spielwiese
Last change on this file since 2206753 was 2206753, checked in by Oleksandr Motsak <motsak@…>, 9 years ago
Hiding all the implementation details (or adding the counting) mostly by moving internal declarations from private headers into corresponding source files rm: Remove internal includes (hiding privates) + cleanup chg: cleanup internal headers fix the usage of internal implementation functions of coeffs from outside of libpolys/coeffs (or libpolys/polys/ext_fiels) fix header includes for coeffs/AE*.{h,cc} add: FIXME&TODO mark reused privates also starting to fix bigint handling
  • Property mode set to 100644
File size: 9.7 KB
Line 
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_1
25
26BOOLEAN nAECoeffIsEqual     (number a, number b, const coeffs r);
27number  nAEMult        (number a, number b, const coeffs r);
28number  nAESub         (number a, number b, const coeffs r);
29number  nAEAdd         (number a, number b, const coeffs r);
30number  nAEDiv         (number a, number b, const coeffs r);
31number  nAEIntMod      (number a, number b, const coeffs r);// Hir wollte wir was gucken
32number  nAEExactDiv    (number a, number b, const coeffs r);
33number  nAEInit        (long i, const coeffs r);
34number  nAEInitMPZ     (mpz_t m, const coeffs r); //nachgucken/fragen
35int     nAESize        (number a, const coeffs r);///
36int     nAEInt         (number &a, const coeffs r);
37number  nAEMPZ         (number a, const coeffs r); //nachgucken/fragen
38number  nAENeg         (number c, const coeffs r);
39number  nAECopy        (number a, number b, const coeffs r); // nachgicken
40number  nAERePart      (number a, number b, const coeffs r); // nachgicken
41number  nAEImPart      (number a, number b, const coeffs r); // nachgicken
42
43void    nAEWriteLong   (number &a, const coeffs r);//
44void    nAEWriteShort  (number &a, const coeffs r);//
45
46
47const char *  nAERead  (const char *s, number *a, const coeffs r);
48number nAENormalize    (number a, number b, const coeffs r);//
49BOOLEAN nAEGreater     (number a, number b, const coeffs r);//
50BOOLEAN nAEEqual       (number a, number b, const coeffs r);
51BOOLEAN nAEIsZero      (number a, const coeffs r);
52BOOLEAN nAEIsOne       (number a, const coeffs r);
53BOOLEAN nAEIsMOne      (number a, const coeffs r);
54BOOLEAN nAEGreaterZero (number a, number b, const coeffs r);
55void    nAEPower       (number a, int i, number * result, const coeffs r);
56number nAEGetDenom     (number &a, const coeffs r);//
57number nAEGetNumerator (number &a, const coeffs r);//
58number nAEGcd          (number a, number b, const coeffs r);
59number nAELcm          (number a, number b, const coeffs r);
60
61void    nAEDelete       (number *a, const coeffs r);//
62number    nAESetMap      (number a, const coeffs r);//
63void    nAEInpMult      (number &a ,number b, const coeffs r);//
64void    nAECoeffWrite   (const coeffs r, BOOLEAN details);//
65
66BOOLEAN nAEClearContent  (number a, const coeffs r);//
67BOOLEAN nAEClearDenominators  (number a, const coeffs r);//
68
69
70
71
72// DEFINITION DER FUNKTIONEN
73
74number  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
84number  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
94number  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
105number  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
116number  nAEIntMod(number a, number, const coeffs)
117{
118    return a;
119}
120
121number  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
133number 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
143number 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
152int nAESize (number a, const coeffs)
153{
154    int_poly* f=reinterpret_cast<int_poly*> (a);
155    return f->deg;
156}
157
158int nAEInt(number &, const coeffs)
159{
160    return 1;
161}
162
163
164number nAEMPZ(number a, const coeffs)
165{
166    return a;
167}
168
169
170number 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
179number nAECopy(number c, const coeffs)
180{
181    return (number) c;
182}
183
184number nAERePart(number c, const coeffs)
185{
186    return (number) c;
187}
188
189number nAEImPart(number c, const coeffs)
190{
191    return (number) c;
192}
193
194void    nAEWriteLong   (number &a, const coeffs)
195{
196    int_poly* f=reinterpret_cast <int_poly*>(a);
197    f->poly_print();
198    return ;
199}
200
201void    nAEWriteShort  (number &a, const coeffs)
202{
203    int_poly* f=reinterpret_cast <int_poly*>(a);
204    f->poly_print();
205    return ;
206}
207
208
209const char *  nAERead  (const char *, number *, const coeffs)
210{
211    char* c=new char;
212    *c='c';
213    return c;
214}
215
216number nAENormalize    (number a, number, const coeffs) // ?
217{
218        return a;
219}
220
221BOOLEAN 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
229BOOLEAN 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
237BOOLEAN 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
244BOOLEAN 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
251BOOLEAN 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
258BOOLEAN nAEGreaterZero     (number a, const coeffs r)
259{
260        if (nAEIsZero(a, r) == FALSE) { return TRUE; }
261        else { return FALSE; }
262}
263
264void    nAEPower       (number, int, number *, const coeffs)
265{
266        return;
267}
268
269number nAEGetDenom      (number &, const coeffs)
270{
271        return (number) 1;
272}
273
274number nAEGetNumerator      (number &a, const coeffs)
275{
276        return a;
277}
278
279number 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
288number 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
300void    nAEDelete       (number *, const coeffs)
301{
302        return;
303}
304
305nMapFunc  nAESetMap (const coeffs src, const coeffs dst)
306{
307  if (src==dst) return ndCopyMap; // UNDEFINED: nAECopyMap; // BUG :(
308  else return NULL;
309}
310
311void    nAEInpMult       (number &, number, const coeffs)
312{
313        return ;
314}
315
316void    nAECoeffWrite   (const coeffs, BOOLEAN)
317{
318        return;
319}
320
321BOOLEAN nAEClearContent  (number, const coeffs)
322{
323        return FALSE;
324}
325
326BOOLEAN nAEClearDenominators  (number, const coeffs)
327{
328        return FALSE;
329}
330
331static char * n_AECoeffName(const coeffs r)
332{
333  return (char *)"AE";
334}
335
336//INITIALISIERUNG FÜR SINGULAR
337
338
339BOOLEAN n_AEInitChar(coeffs r, void *)
340{
341    // r->is_field, r->is_domain?
342    r->ch = 0;
343    //r->cfKillChar = ndKillChar; /* dummy */
344    //r->nCoeffIsEqual=ndCoeffIsEqual;
345    r->cfMult  = nAEMult;
346    r->cfSub   = nAESub;
347    r->cfAdd   = nAEAdd;
348    r->cfDiv   = nAEDiv;
349    r->cfIntMod= nAEIntMod;
350    r->cfExactDiv= nAEExactDiv;
351    r->cfInit = nAEInit;
352    r->cfSize  = nAESize;
353    r->cfInt  = nAEInt;
354    r->cfCoeffName = n_AECoeffName;
355#ifdef HAVE_RINGS
356    //r->cfDivComp = NULL; // only for ring stuff
357    //r->cfIsUnit = NULL; // only for ring stuff
358    //r->cfGetUnit = NULL; // only for ring stuff
359    //r->cfExtGcd = NULL; // only for ring stuff
360    // r->cfDivBy = NULL; // only for ring stuff
361#endif
362    r->cfInpNeg   = nAENeg;
363    r->cfInvers= NULL;
364    //r->cfCopy  = ndCopy;
365    //r->cfRePart = ndCopy;
366    //r->cfImPart = ndReturn0;
367    r->cfWriteLong = nAEWriteLong;
368    r->cfRead = nAERead;
369    //r->cfNormalize=ndNormalize;
370    r->cfGreater = nAEGreater;
371    r->cfEqual = nAEEqual;
372    r->cfIsZero = nAEIsZero;
373    r->cfIsOne = nAEIsOne;
374    r->cfIsMOne = nAEIsOne;
375    r->cfGreaterZero = nAEGreaterZero;
376    r->cfPower = nAEPower; // ZU BEARBEITEN
377    r->cfGetDenom = nAEGetDenom;
378    r->cfGetNumerator = nAEGetNumerator;
379    r->cfGcd  = nAEGcd;
380    r->cfLcm  = nAELcm; // ZU BEARBEITEN
381    r->cfDelete= nAEDelete;
382
383    r->cfSetMap = nAESetMap;
384   
385    r->cfInpMult=nAEInpMult; //????
386    r->cfCoeffWrite=nAECoeffWrite; //????
387
388
389    // the variables:
390    r->nNULL = (number) 0;
391    //r->type = n_AE;
392    r->ch = 0;
393    r->has_simple_Alloc=TRUE;
394    r->has_simple_Inverse=TRUE;
395    return FALSE;
396}
397#endif
Note: See TracBrowser for help on using the repository browser.