source: git/libpolys/coeffs/OPAEp.cc @ 9bad87

spielwiese
Last change on this file since 9bad87 was 9bad87, checked in by Hans Schoenemann <hannes@…>, 9 years ago
aditionl coeff areas require coeff data type in the interpreter
  • Property mode set to 100644
File size: 7.8 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/*
5* Dense Polynomials modulo p
6*/
7//Schauen was hier ÃŒberhaupt sinn macht
8
9#include <misc/auxiliary.h>
10
11#ifdef SINGULAR_4_1
12
13#include <factory/factory.h>
14
15#include <string.h>
16#include <omalloc/omalloc.h>
17#include <coeffs/coeffs.h>
18#include <reporter/reporter.h>
19#include <coeffs/numbers.h>
20#include <coeffs/longrat.h>
21#include <coeffs/modulop.h>
22#include <coeffs/mpr_complex.h>
23#include <misc/mylimits.h>
24#include <coeffs/OPAEp.h>
25#include <coeffs/AEp.h>
26
27
28
29
30
31// DEFINITION DER FUNKTIONEN
32
33number  nAEpAdd(number a, number b, const coeffs)
34{
35    p_poly* f=reinterpret_cast<p_poly*> (a);
36    p_poly* g=reinterpret_cast<p_poly*> (b);
37    p_poly *res=new p_poly;
38    res->p_poly_set(*f);
39    res->p_poly_add_to(*g);
40    return (number) res;
41}
42
43number  nAEpMult(number a, number b, const coeffs)
44{
45    p_poly* f=reinterpret_cast<p_poly*> (a);
46    p_poly* g=reinterpret_cast<p_poly*> (b);
47    p_poly *res=new p_poly;
48    res->p_poly_set(*f);
49    res->p_poly_mult_n_to(*g);
50    return (number) res;
51}
52
53number  nAEpSub(number a, number b, const coeffs)
54{
55    p_poly* f=reinterpret_cast<p_poly*> (a);
56    p_poly* g=reinterpret_cast<p_poly*> (b);
57    p_poly *res=new p_poly;
58    res->p_poly_set(*f);
59    res->p_poly_sub_to(*g);
60    return (number) res;
61}
62
63
64number  nAEpDiv(number a, number b, const coeffs)
65{
66    p_poly* f=reinterpret_cast<p_poly*> (a);
67    p_poly* g=reinterpret_cast<p_poly*> (b);
68    p_poly *res=new p_poly;
69    p_poly *s=new p_poly;
70    res->p_poly_set(*f);
71    res->p_poly_div_to(*res,*s,*g);
72    return (number) res;
73}
74
75
76number  nAEpIntMod(number a, number, const coeffs)
77{
78    return a;
79}
80
81number  nAEpExactDiv(number a, number b, const coeffs)
82{
83    p_poly* f=reinterpret_cast<p_poly*> (a);
84    p_poly* g=reinterpret_cast<p_poly*> (b);
85    p_poly *res=new p_poly;
86    p_poly *s=new p_poly;
87    res->p_poly_set(*f);
88    res->p_poly_div_to(*res,*s,*g);
89    return (number) res;
90}
91
92
93
94number nAEpInit(long i, const coeffs)
95{
96    int j=7;
97    mpz_t m;
98    mpz_init_set_ui(m, i);
99    p_poly* res=new p_poly;
100    res->p_poly_set(m, j);
101    number res1=reinterpret_cast<number>(res);
102    return  res1;
103}
104
105number nAEpInitMPZ(mpz_t m, const coeffs)
106{
107    int j=7;
108    p_poly* res=new p_poly;
109    res->p_poly_set(m, j);
110    number res1=reinterpret_cast<number>(res);
111    return  res1;
112
113}
114
115int nAEpSize (number a, const coeffs)
116{
117    p_poly* f=reinterpret_cast<p_poly*> (a);
118    return f->deg;
119}
120
121int nAEpInt(number &, const coeffs)
122{
123    return 1;
124}
125
126
127number nAEpMPZ(number a, const coeffs)
128{
129    return a;
130}
131
132
133number nAEpNeg(number c, const coeffs)
134{
135    p_poly* f=reinterpret_cast<p_poly*> (c);
136    p_poly *res=new p_poly;
137    res->p_poly_set(*f);
138    res->p_poly_neg();
139    return (number) res;
140}
141
142number nAEpCopy(number c, const coeffs)
143{
144    return c;
145}
146
147number nAEpRePart(number c, const coeffs)
148{
149    return c;
150}
151
152number nAEpImPart(number c, const coeffs)
153{
154    return  c;
155}
156
157void    nAEpWriteLong   (number &a, const coeffs)
158{
159    p_poly* f=reinterpret_cast <p_poly*>(a);
160    f->p_poly_print();
161
162    return;
163}
164
165void    nAEpWriteShort  (number &a, const coeffs)
166{
167    p_poly* f=reinterpret_cast <p_poly*>(a);
168    f->p_poly_print();
169    return ;
170}
171
172
173const char *  nAEpRead  (const char *, number *a, const coeffs)
174{
175    p_poly& f=reinterpret_cast <p_poly&>(a);
176    f.p_poly_insert();
177    f.p_poly_print();
178    *a=reinterpret_cast <number>(&f);
179    char* c=new char;
180    *c='c';
181    return c;
182}
183
184number nAEpNormalize    (number a, number, const coeffs) // ?
185{
186    return a;
187}
188
189BOOLEAN nAEpGreater     (number a, number b, const coeffs)
190{
191    p_poly* f=reinterpret_cast<p_poly*> (a);
192    p_poly* g=reinterpret_cast<p_poly*> (b);
193    if (f->deg > g->deg) {return FALSE;}
194    else {return TRUE;}
195}
196
197BOOLEAN nAEpEqual     (number a, number b, const coeffs)
198{
199    p_poly* f=reinterpret_cast<p_poly*> (a);
200    p_poly* g=reinterpret_cast<p_poly*> (b);
201    if (f->is_equal(*g) == 1) {return FALSE;}
202    else {return TRUE;}
203}
204
205BOOLEAN nAEpIsZero      (number a, const coeffs)
206{
207    p_poly* f=reinterpret_cast<p_poly*> (a);
208    if (f->is_zero() == 1) {return FALSE;}
209    else {return TRUE;}
210}
211
212BOOLEAN nAEpIsOne      (number a, const coeffs)
213{
214    p_poly* f=reinterpret_cast<p_poly*> (a);
215    if (f->is_one() == 1) {return FALSE;}
216    else {return TRUE;}
217}
218
219BOOLEAN nAEpIsMOne      (number a, const coeffs r)
220{
221    number b=nAEpNeg(a, r);
222    p_poly* f=reinterpret_cast<p_poly*> (b);
223    if (f->is_one() == 1) {return FALSE;}
224    else {return TRUE;}
225}
226
227BOOLEAN nAEpGreaterZero     (number a, const coeffs r)
228{
229    if (nAEpIsZero(a, r) == FALSE) { return TRUE; }
230    else { return FALSE; }
231}
232
233void    nAEpPower       (number, int, number *, const coeffs)
234{
235    return;
236}
237
238number nAEpGetDenom      (number &, const coeffs)
239{
240    return (number) 1;
241}
242
243number nAEpGetNumerator      (number &a, const coeffs)
244{
245    return a;
246}
247
248number nAEpGcd           (number a, number b, const coeffs)
249{
250    p_poly* f=reinterpret_cast<p_poly*> (a);
251    p_poly* g=reinterpret_cast<p_poly*> (b);
252    p_poly *res=new p_poly;
253    res->p_poly_gcd(*f,*g);
254    return (number) res;
255}
256
257number nAEpLcm          (number a, number b, const coeffs)
258{
259    p_poly* f=reinterpret_cast<p_poly*> (a);
260    p_poly* g=reinterpret_cast<p_poly*> (b);
261    p_poly *gcd=new p_poly;
262    p_poly *res=new p_poly;
263    p_poly *s=new p_poly;
264    gcd->p_poly_gcd(*f,*g);
265    res->p_poly_mult_n(*f,*g);
266    res->p_poly_div_to(*res,*s,*gcd);
267    return (number) res;
268}
269
270void    nAEpDelete       (number *, const coeffs)
271{
272    return;
273}
274
275/*
276number    nAEpSetMap        (number a, const coeffs)
277{
278        return a;
279}
280*/
281
282void    nAEpInpMult       (number &a, number b, const coeffs)
283{
284    p_poly* f=reinterpret_cast<p_poly*> (a);
285    p_poly* g=reinterpret_cast<p_poly*> (b);
286    f->p_poly_mult_n_to(*g);
287    a=(number) f;
288    return ;
289}
290
291void    nAEpCoeffWrite   (const coeffs, BOOLEAN)
292{
293    return;
294}
295
296BOOLEAN nAEpClearContent  (number, const coeffs)
297{
298    return FALSE;
299}
300
301BOOLEAN nAEpClearDenominators  (number, const coeffs)
302{
303    return FALSE;
304}
305
306
307
308//INITIALISIERUNG FÜR SINGULAR
309
310
311BOOLEAN n_pAEInitChar(coeffs r, void *p)
312{
313    // r->is_field, is_domain
314    //Charakteristik abgreifen!
315    const int c = (int) (long) p;
316
317
318    r->ch=c;
319    r->cfKillChar=NULL;
320    //r->nCoeffIsEqual=ndCoeffIsEqual;
321    r->cfMult  = nAEpMult;
322    r->cfSub   = nAEpSub;
323    r->cfAdd   = nAEpAdd;
324    r->cfDiv   = nAEpDiv;
325    r->cfIntMod= nAEpIntMod;
326    r->cfExactDiv= nAEpExactDiv;
327    r->cfInit = nAEpInit;
328    r->cfSize  = nAEpSize;
329    r->cfInt  = nAEpInt;
330#ifdef HAVE_RINGS
331    //r->cfDivComp = NULL; // only for ring stuff
332    //r->cfIsUnit = NULL; // only for ring stuff
333    //r->cfGetUnit = NULL; // only for ring stuff
334    //r->cfExtGcd = NULL; // only for ring stuff
335    // r->cfDivBy = NULL; // only for ring stuff
336#endif
337    r->cfInpNeg   = nAEpNeg;
338    r->cfInvers= NULL;
339    //r->cfCopy  = ndCopy;
340    //r->cfRePart = ndCopy;
341    //r->cfImPart = ndReturn0;
342    r->cfWriteLong = nAEpWriteLong;
343    r->cfRead = nAEpRead;
344    //r->cfNormalize=ndNormalize;
345    r->cfGreater = nAEpGreater;
346    r->cfEqual = nAEpEqual;
347    r->cfIsZero = nAEpIsZero;
348    r->cfIsOne = nAEpIsOne;
349    r->cfIsMOne = nAEpIsOne;
350    r->cfGreaterZero = nAEpGreaterZero;
351    r->cfPower = nAEpPower; // ZU BEARBEITEN
352    r->cfGetDenom = nAEpGetDenom;
353    r->cfGetNumerator = nAEpGetNumerator;
354    r->cfGcd  = nAEpGcd;
355    r->cfLcm  = nAEpLcm; // ZU BEARBEITEN
356    r->cfDelete= nAEpDelete;
357
358    extern nMapFunc npSetMap(const coeffs src, const coeffs dst); // FIXME: BUG?
359    r->cfSetMap = npSetMap; // WHY??? // TODO: this seems to be a bug!
360
361    r->cfInpMult=nAEpInpMult; //????
362    r->cfCoeffWrite=nAEpCoeffWrite; //????
363
364
365    // the variables:
366    r->nNULL = (number) 0;
367    //r->type = n_AE;
368    r->ch = c;
369    r->has_simple_Alloc=TRUE;
370    r->has_simple_Inverse=TRUE;
371    return FALSE;
372}
373#endif
Note: See TracBrowser for help on using the repository browser.