1 | #ifndef LONGTRANS_H |
---|
2 | #define LONGTRANS_H |
---|
3 | /**************************************** |
---|
4 | * Computer Algebra System SINGULAR * |
---|
5 | ****************************************/ |
---|
6 | /* $Id: longtrans.h 12469 2011-02-25 13:38:49Z seelisch $ */ |
---|
7 | /* |
---|
8 | * ABSTRACT: numbers in transcendental field extensions, |
---|
9 | i.e., in rational function fields |
---|
10 | */ |
---|
11 | #include <kernel/structs.h> |
---|
12 | #include <kernel/longrat.h> |
---|
13 | #include <kernel/polys-impl.h> |
---|
14 | |
---|
15 | /* |
---|
16 | IMPORTANT INFORMATION: |
---|
17 | Instantiation of an algebraic field extension in SINGULAR |
---|
18 | works by first creating a transcendental field extension |
---|
19 | and then providing a minimal polynomial / minimal ideal. |
---|
20 | Consequently, first the code for transcendental field |
---|
21 | extensions will be activated; see longtrans.*. |
---|
22 | When providing a minimal polynomial / minimal ideal, all |
---|
23 | function pointers will be re-defined, using the below method |
---|
24 | redefineFunctionPointers(). After that, the code for algebraic |
---|
25 | field extensions is active; see longalg.*. |
---|
26 | |
---|
27 | NOTE: |
---|
28 | Elements of algebraic and transcendental field extensions |
---|
29 | are polynomials or quotients of two polynomials, respectively. |
---|
30 | All these polynomials, as well as the minimal polynomial (in |
---|
31 | the case of an algebraic extension) live in the globally |
---|
32 | accessible ring 'nacRing', defined in longtrans.*. |
---|
33 | |
---|
34 | METHOD NAMING CONVENTIONS |
---|
35 | (not true for types / structs / global variables): |
---|
36 | nap* macros and methods operating on polynomials living in |
---|
37 | nacRing (defined in longtrans.*), |
---|
38 | na* (but not nap*) methods and macros for algebraic field |
---|
39 | extensions (defined in longalg.*), |
---|
40 | nt* methods and macros for transcendental field extensions, |
---|
41 | (defined in longtrans.*) |
---|
42 | nac* function pointers for computing with the coefficients of |
---|
43 | polynomials living in nacRing (defined in longtrans.*) |
---|
44 | */ |
---|
45 | |
---|
46 | typedef polyrec * napoly; |
---|
47 | struct slnumber; |
---|
48 | typedef struct slnumber * lnumber; |
---|
49 | struct slnumber |
---|
50 | { |
---|
51 | napoly z; |
---|
52 | napoly n; |
---|
53 | BOOLEAN s; |
---|
54 | }; |
---|
55 | |
---|
56 | extern int ntNumbOfPar; |
---|
57 | #define ntParNames (currRing->parameter) |
---|
58 | extern int ntIsChar0; /* == 1 iff char = 0, |
---|
59 | == 0 otherwise */ |
---|
60 | extern ring ntMapRing; |
---|
61 | extern int ntParsToCopy; |
---|
62 | |
---|
63 | /* specific methods / macros for transcendental field extensions */ |
---|
64 | void ntSetChar(int p, ring r); |
---|
65 | void ntDelete (number *p, const ring r); |
---|
66 | number ntInit(int i, const ring r); /* z := i */ |
---|
67 | number ntPar(int i); /* z := par(i) */ |
---|
68 | int ntParDeg(number n); /* i := deg(n) */ |
---|
69 | int ntSize(number n); /* size desc. */ |
---|
70 | int ntInt(number &n, const ring r); |
---|
71 | BOOLEAN ntIsZero(number za); /* za = 0 ? */ |
---|
72 | BOOLEAN ntIsOne(number za); /* za = 1 ? */ |
---|
73 | BOOLEAN ntIsMOne(number za); /* za = -1 ? */ |
---|
74 | BOOLEAN ntEqual(number a, number b); /* a = b ? */ |
---|
75 | BOOLEAN ntGreater(number a, number b); /* dummy */ |
---|
76 | number ntNeg(number za); /* za := - za */ |
---|
77 | number ntInvers(number a); |
---|
78 | void ntPower(number x, int exp, number *lo); |
---|
79 | BOOLEAN ntGreaterZero(number a); |
---|
80 | number ntCopy(number p); /* erg:= p */ |
---|
81 | number nt_Copy(number p, const ring r); /* erg:= p */ |
---|
82 | number ntAdd(number la, number li); /* lu := la+li */ |
---|
83 | number ntMult(number la, number li); /* lo := la*li */ |
---|
84 | number ntDiv(number la, number li); /* lo := la/li */ |
---|
85 | number ntIntDiv(number la, number li); /* lo := la/li */ |
---|
86 | //number ntIntMod(number la, number li); /* lo := la/li */ |
---|
87 | number ntSub(number la, number li); /* lu := la-li */ |
---|
88 | void ntNormalize(number &p); |
---|
89 | number ntGcd(number a, number b, const ring r); |
---|
90 | number ntLcm(number a, number b, const ring r); |
---|
91 | const char* ntRead(const char * s, number * p); |
---|
92 | void ntWrite(number &p, const ring r); |
---|
93 | char* ntName(number n); |
---|
94 | nMapFunc ntSetMap(const ring src, const ring dst); |
---|
95 | number ntMap0P(number c); |
---|
96 | number ntMap00(number c); |
---|
97 | #ifdef LDEBUG |
---|
98 | BOOLEAN ntDBTest(number a, const char *f,const int l); |
---|
99 | #endif |
---|
100 | napoly ntRemainder(napoly f, const napoly g); |
---|
101 | void ntSetIdeal(ideal I); |
---|
102 | void ntCoefNormalize(number pp); |
---|
103 | extern number (*ntMap)(number from); |
---|
104 | |
---|
105 | /* procedure variables for computing with the coefficients of |
---|
106 | polynomials living in nacRing */ |
---|
107 | extern ring nacRing; |
---|
108 | extern numberfunc nacMult, nacSub, nacAdd, nacDiv, nacIntDiv; |
---|
109 | extern number (*nacGcd)(number a, number b, const ring r); |
---|
110 | extern number (*nacLcm)(number a, number b, const ring r); |
---|
111 | extern number (*nacInit)(int i, const ring r); |
---|
112 | extern int (*nacInt)(number &n, const ring r); |
---|
113 | extern void (*nacNormalize)(number &a); |
---|
114 | extern number (*nacNeg)(number a); |
---|
115 | extern number (*nacCopy)(number a); |
---|
116 | extern number (*nacInvers)(number a); |
---|
117 | extern BOOLEAN (*nacIsZero)(number a); |
---|
118 | extern BOOLEAN (*nacIsOne)(number a); |
---|
119 | extern BOOLEAN (*nacGreaterZero)(number a); |
---|
120 | extern number (*nacMap)(number); |
---|
121 | |
---|
122 | /* for computing with polynomials living in nacRing */ |
---|
123 | poly napPermNumber(number z, int * par_perm, int P, ring r); |
---|
124 | #define napAddExp(p,i,e) (p_AddExp(p,i,e,currRing->algring)) |
---|
125 | #define napLength(p) pLength(p) |
---|
126 | #define napNeg(p) (p_Neg(p,currRing->algring)) |
---|
127 | #define napVariables naNumbOfPar |
---|
128 | #define napGetCoeff(p) pGetCoeff(p) |
---|
129 | #define napGetExpFrom(p,i,r) (p_GetExp(p,i,r->algring)) |
---|
130 | #define napSetExp(p,i,e) (p_SetExp(p,i,e,currRing->algring)) |
---|
131 | #define napNew() (p_Init(currRing->algring)) |
---|
132 | #define napAdd(p1,p2) (p_Add_q(p1,p2,currRing->algring)) |
---|
133 | #define napSetm(p) p_Setm(p,currRing->algring) |
---|
134 | #define napCopy(p) p_Copy(p,nacRing) |
---|
135 | #define napSetCoeff(p,n) {n_Delete(&pGetCoeff(p),nacRing);pGetCoeff(p)=n;} |
---|
136 | #define napComp(p,q) p_LmCmp((poly)p,(poly)q, nacRing) |
---|
137 | #define napMultT(A,E) A=(napoly)p_Mult_mm((poly)A,(poly)E,nacRing) |
---|
138 | #define napDeg(p) (int)p_Totaldegree(p, nacRing) |
---|
139 | number napGetDenom(number &n, const ring r); |
---|
140 | number napGetNumerator(number &n, const ring r); |
---|
141 | void napTest(napoly p); |
---|
142 | napoly napInitz(number z); |
---|
143 | napoly napCopyNeg(const napoly p); |
---|
144 | void napMultN(napoly p, const number z); |
---|
145 | void napDivMod(napoly f, const napoly g, napoly *q, napoly *r); |
---|
146 | napoly napRemainder(napoly f, const napoly g); |
---|
147 | napoly napInvers(napoly x, const napoly c); |
---|
148 | int napMaxDeg(napoly p); |
---|
149 | int napMaxDegLen(napoly p, int &l); |
---|
150 | void napWrite(napoly p,const BOOLEAN has_denom, const ring r); |
---|
151 | int napExp(napoly a, napoly b); |
---|
152 | int napExpi(int i, napoly a, napoly b); |
---|
153 | void napContent(napoly ph); |
---|
154 | void napCleardenom(napoly ph); |
---|
155 | napoly napGcd0(napoly a, napoly b); |
---|
156 | napoly napGcd(napoly a, napoly b); |
---|
157 | number napLcm(napoly a); |
---|
158 | BOOLEAN napDivPoly (napoly p, napoly q); |
---|
159 | napoly napRedp (napoly q); |
---|
160 | napoly napTailred (napoly q); |
---|
161 | napoly napMap(napoly p); |
---|
162 | napoly napPerm(napoly p, const int *par_perm, const ring src_ring, |
---|
163 | const nMapFunc nMap); |
---|
164 | const char* napHandleMons(const char *s, int i, napoly ex); |
---|
165 | const char* napHandlePars(const char *s, int i, napoly ex); |
---|
166 | const char* napRead(const char *s, napoly *b); |
---|
167 | |
---|
168 | #endif |
---|
169 | |
---|