source: git/libpolys/polys/polys.h @ 7e53d9

spielwiese
Last change on this file since 7e53d9 was 2a38d90, checked in by Oleksandr Motsak <motsak@…>, 13 years ago
CHG: minor fixes + idPrint/idShow
  • Property mode set to 100644
File size: 14.3 KB
Line 
1#ifndef POLYS_H
2#define POLYS_H
3/****************************************
4*  Computer Algebra System SINGULAR     *
5****************************************/
6/* $Id$ */
7/*
8* ABSTRACT - compatiblity layer for all operations with polys
9*/
10
11#include <polys/monomials/p_polys.h>
12
13extern ring currRing;
14extern void rChangeCurrRing(ring r);
15
16#include <coeffs/numbers.h>
17inline number nGcd(number a, number b, const ring r = currRing) { return n_Gcd(a, b, r->cf); }
18
19/***************************************************************
20 *
21 * Primitives for accessing and setting fields of a poly
22 * poly must be != NULL
23 *
24 ***************************************************************/
25
26// deletes old coeff before setting the new one
27#define pSetCoeff(p,n)      p_SetCoeff(p,n,currRing)
28
29// Order
30#define pGetOrder(p)        p_GetOrder(p, currRing)
31
32// Component
33#define pGetComp(p)         __p_GetComp(p, currRing)
34#define pSetComp(p,v)       p_SetComp(p,v, currRing)
35
36// Exponent
37#define pGetExp(p,i)        p_GetExp(p, i, currRing)
38#define pSetExp(p,i,v)      p_SetExp(p, i, v, currRing)
39#define pIncrExp(p,i)       p_IncrExp(p,i, currRing)
40#define pDecrExp(p,i)       p_DecrExp(p,i, currRing)
41#define pAddExp(p,i,v)      p_AddExp(p,i,v, currRing)
42#define pSubExp(p,i,v)      p_SubExp(p,i,v, currRing)
43#define pMultExp(p,i,v)     p_MultExp(p,i,v, currRing)
44#define pGetExpSum(p1, p2, i)    p_GetExpSum(p1, p2, i, currRing)
45#define pGetExpDiff(p1, p2, i)   p_GetExpDiff(p1, p2, i, currRing)
46
47
48/***************************************************************
49 *
50 * Allocation/Initalization/Deletion
51 * except for pHead, all polys must be != NULL
52 *
53 ***************************************************************/
54// allocates the space for a new monomial -- no initialization !!!
55#define pNew()          p_New(currRing)
56// allocates a new monomial and initializes everything to 0
57#define pInit()         p_Init(currRing)
58// like pInit, except that expvector is initialized to that of p,
59// p must be != NULL
60#define pLmInit(p)  p_LmInit(p, currRing)
61// returns newly allocated copy of Lm(p), coef is copied, next=NULL,
62// p might be NULL
63#define pHead(p)        p_Head(p, currRing)
64// frees the space of the monomial m, assumes m != NULL
65// coef is not freed, m is not advanced
66static inline void pLmFree(poly p)    {p_LmFree(p, currRing);}
67// like pLmFree, but advances p
68static inline void pLmFree(poly *p)   {p_LmFree(p, currRing);}
69// assumes p != NULL, deletes p, returns pNext(p)
70#define pLmFreeAndNext(p) p_LmFreeAndNext(p, currRing)
71// assume p != NULL, deletes Lm(p)->coef and Lm(p)
72#define pLmDelete(p)    p_LmDelete(p, currRing)
73// like pLmDelete, returns pNext(p)
74#define pLmDeleteAndNext(p) p_LmDeleteAndNext(p, currRing)
75
76/***************************************************************
77 *
78 * Operation on ExpVectors: assumes polys != NULL
79 *
80 ***************************************************************/
81
82#define pExpVectorCopy(d_p, s_p)    p_ExpVectorCopy(d_p, s_p, currRing)
83#define pExpVectorAdd(p1, p2)       p_ExpVectorAdd(p1, p2, currRing)
84#define pExpVectorSub(p1, p2)       p_ExpVectorSub(p1, p2, currRing)
85#define pExpVectorAddSub(p1, p2, p3)p_ExpVectorAddSub(p1, p2, p3, currRing)
86#define pExpVectorSum(pr, p1, p2)   p_ExpVectorSum(pr, p1, p2, currRing)
87#define pExpVectorDiff(pr, p1, p2)  p_ExpVectorDiff(pr, p1, p2, currRing)
88
89// Gets a copy of (resp. set) the exponent vector, where e is assumed
90// to point to (r->N +1)*sizeof(long) memory. Exponents are
91// filled in as follows: comp, e_1, .., e_n
92#define pGetExpV(p, e)      p_GetExpV(p, e, currRing)
93#define pSetExpV(p, e)      p_SetExpV(p, e, currRing)
94
95/***************************************************************
96 *
97 * Comparisons: they are all done without regarding coeffs
98 *
99 ***************************************************************/
100// returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
101#define pLmCmp(p,q)         p_LmCmp(p,q,currRing)
102// executes axtionE|actionG|actionS if p=q|p>q|p<q w.r.t monomial ordering
103// action should be a "goto ..."
104#define pLmCmpAction(p,q, actionE, actionG, actionS)  \
105  _p_LmCmpAction(p,q,currRing, actionE, actionG,actionS)
106
107#define pLmEqual(p1, p2)     p_ExpVectorEqual(p1, p2, currRing)
108
109// pCmp: args may be NULL
110// returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
111#define pCmp(p1, p2)    p_Cmp(p1, p2, currRing)
112
113
114/***************************************************************
115 *
116 * Divisiblity tests, args must be != NULL, except for
117 * pDivisbleBy
118 *
119 ***************************************************************/
120// returns TRUE, if leading monom of a divides leading monom of b
121// i.e., if there exists a expvector c > 0, s.t. b = a + c;
122#define pDivisibleBy(a, b)  p_DivisibleBy(a,b,currRing)
123// like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
124#define pLmDivisibleBy(a,b)  p_LmDivisibleBy(a,b,currRing)
125// like pLmDivisibleBy, does not check components
126#define pLmDivisibleByNoComp(a, b) p_LmDivisibleByNoComp(a,b,currRing)
127// Divisibility tests based on Short Exponent vectors
128// sev_a     == pGetShortExpVector(a)
129// not_sev_b == ~ pGetShortExpVector(b)
130#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b) \
131  p_LmShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)
132#define pLmRingShortDivisibleBy(a, sev_a, b, not_sev_b) \
133  p_LmRingShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)
134// returns the "Short Exponent Vector" -- used to speed up divisibility
135// tests (see polys-impl.cc )
136#define pGetShortExpVector(a)   p_GetShortExpVector(a, currRing)
137#ifdef HAVE_RINGS
138/* divisibility check over ground ring (which may contain zero divisors);
139   TRUE iff LT(f) divides LT(g), i.e., LT(f)*c*m = LT(g), for some
140   coefficient c and some monomial m;
141   does not take components into account */
142#define  pDivisibleByRingCase(f,g) p_DivisibleByRingCase(f,g,currRing)
143#endif
144
145/***************************************************************
146 *
147 * Copying/Deleteion of polys: args may be NULL
148 *
149 ***************************************************************/
150// return a copy of the poly
151#define pCopy(p) p_Copy(p, currRing)
152#define pDelete(p_ptr)  p_Delete(p_ptr, currRing)
153
154/***************************************************************
155 *
156 * Copying/Deletion of polys: args may be NULL
157 *  - p/q as arg mean a poly
158 *  - m a monomial
159 *  - n a number
160 *  - pp (resp. qq, mm, nn) means arg is constant
161 *  - p (resp, q, m, n)     means arg is destroyed
162 *
163 ***************************************************************/
164#define pNeg(p)                     p_Neg(p, currRing)
165#define ppMult_nn(p, n)             pp_Mult_nn(p, n, currRing)
166#define pMult_nn(p, n)              p_Mult_nn(p, n, currRing)
167#define ppMult_mm(p, m)             pp_Mult_mm(p, m, currRing)
168#define pMult_mm(p, m)              p_Mult_mm(p, m, currRing)
169#define pAdd(p, q)                  p_Add_q(p, q, currRing)
170#define pPower(p, q)                p_Power(p, q, currRing)
171#define pMinus_mm_Mult_qq(p, m, q)  p_Minus_mm_Mult_qq(p, m, q, currRing)
172#define pPlus_mm_Mult_qq(p, m, q)   p_Plus_mm_Mult_qq(p, m, q, currRing)
173#define pMult(p, q)                 p_Mult_q(p, q, currRing)
174#define ppMult_qq(p, q)             pp_Mult_qq(p, q, currRing)
175// p*Coeff(m) for such monomials pm of p, for which m is divisble by pm
176#define ppMult_Coeff_mm_DivSelect(p, m)   pp_Mult_Coeff_mm_DivSelect(p, m, currRing)
177/*************************************************************************
178 *
179 * Sort routines
180 *
181 *************************************************************************/
182// sorts p, assumes all monomials in p are different
183#define pSortMerger(p)          p_SortMerge(p, currRing)
184#define pSort(p)                p_SortMerge(p, currRing)
185
186// sorts p, p may have equal monomials
187#define pSortAdd(p)             p_SortAdd(p, currRing)
188
189
190// Assume: If considerd only as poly in any component of p
191// (say, monomials of other components of p are set to 0),
192// then p is already sorted correctly
193#define pSortCompCorrect(p) pSort(p)
194
195/***************************************************************
196 *
197 * Predicates on polys/Lm's
198 *
199 ***************************************************************/
200// return true if all p is eihter NULL, or if all exponents
201// of p are 0 and Comp of p is zero
202#define   pIsConstantComp(p)        p_IsConstantComp(p, currRing)
203// like above, except that Comp might be != 0
204#define   pIsConstant(p)            p_IsConstant(p,currRing)
205// return true if the Lm is a constant <>0
206#define   pIsUnit(p)            p_IsUnit(p,currRing)
207// like above, except that p must be != NULL
208#define   pLmIsConstantComp(p)      p_LmIsConstantComp(p, currRing)
209#define   pLmIsConstant(p)          p_LmIsConstant(p,currRing)
210
211// return TRUE if all monomials of p are constant
212#define   pIsConstantPoly(p)        p_IsConstantPoly(p, currRing)
213
214#define   pIsPurePower(p)   p_IsPurePower(p, currRing)
215#define   pIsUnivariate(p)  p_IsUnivariate(p, currRing)
216#define   pIsVector(p)      (pGetComp(p)>0)
217#define   pGetVariables(p,e)  p_GetVariables(p, e, currRing)
218
219/***************************************************************
220 *
221 * Old stuff
222 *
223 ***************************************************************/
224
225typedef poly*   polyset;
226extern int      pOrdSgn;
227extern BOOLEAN  pLexOrder;
228extern poly     ppNoether;
229extern BOOLEAN  pVectorOut;
230
231/*-------------predicate on polys ----------------------*/
232#define  pHasNotCF(p1,p2)   p_HasNotCF(p1,p2,currRing)
233                                /*has no common factor ?*/
234#define  pSplit(p,r)        p_Split(p,r)
235                                /*p => IN(p), r => REST(p) */
236
237
238
239/*-----------the ordering of monomials:-------------*/
240#define pSetm(p)    p_Setm(p, currRing)
241// TODO:
242#define pSetmComp(p)   p_Setm(p, currRing)
243
244/***************************************************************
245 *
246 * Degree stuff -- see p_polys.cc for explainations
247 *
248 ***************************************************************/
249inline int pWeight(int i, const ring R = currRing){ return p_Weight(i, R); }
250inline long pDeg(poly p, const ring R = currRing) { return p_Deg(p, R); }
251 
252
253static inline long pTotaldegree(poly p) { return p_Totaldegree(p,currRing); }
254#define pWTotaldegree(p) p_WTotaldegree(p,currRing)
255#define pWDegree(p) p_WDegree(p,currRing)
256
257/*-------------operations on polynomials:------------*/
258#define   pSub(a,b) p_Sub(a,b,currRing)
259
260#define pmInit(a,b) p_mInit(a,b,currRing)
261
262// ----------------- define to enable new p_procs -----*/
263
264#define pDivide(a,b) p_Divide(a,b,currRing)
265#define pDivideM(a,b) p_DivideM(a,b,currRing)
266#define pLcm(a,b,m) p_Lcm(a,b,m,currRing)
267#define pDiff(a,b)  p_Diff(a,b,currRing)
268#define pDiffOp(a,b,m) p_DiffOp(a,b,m,currRing)
269
270#define   pMaxComp(p)   p_MaxComp(p, currRing)
271#define   pMinComp(p)   p_MinComp(p, currRing)
272
273#define   pOneComp(p)       p_OneComp(p, currRing)
274#define   pSetCompP(a,i)    p_SetCompP(a, i, currRing)
275
276// let's inline those, so that we can call them from the debugger
277inline char*   pString(poly p)    {return p_String(p, currRing, currRing);}
278inline char*   pString0(poly p)   {return p_String0(p, currRing, currRing);}
279inline void    pWrite(poly p)     {p_Write(p, currRing, currRing);}
280inline void    pWrite0(poly p)    {p_Write0(p, currRing, currRing);}
281inline void    wrp(poly p)        {p_wrp(p, currRing, currRing);}
282
283#define   pISet(i) p_ISet(i,currRing)
284#define   pNSet(n) p_NSet(n,currRing)
285
286#define   pOne()   p_One(currRing)
287
288#define   pNormalize(p) p_Normalize(p,currRing)
289#define   pSize(p)      p_Size(p,currRing)
290
291
292// homogenizes p by multiplying certain powers of the varnum-th variable
293#define  pHomogen(p,varnum) p_Homogen(p,varnum,currRing)
294
295BOOLEAN   pIsHomogeneous (poly p);
296// // replaces the maximal powers of the leading monomial of p2 in p1 by
297// // the same powers of n, utility for dehomogenization
298// #define   pDehomogen(p1,p2,n) p_Dehomgen(p1,p2,n,currRing)
299// #define   pIsHomogen(p)       p_IsHomggen(p,currRing)
300#define   pIsHomogen(p)       p_IsHomogen(p,currRing)
301
302/*BOOLEAN   pVectorHasUnitM(poly p, int * k);*/
303#define   pVectorHasUnitB(p,k) p_VectorHasUnitB(p,k,currRing)
304#define   pVectorHasUnit(p,k,l) p_VectorHasUnit(p,k,l,currRing)
305#define   pTakeOutComp1(p,k)    p_TakeOutComp1(p,k,currRing)
306
307// Splits *p into two polys: *q which consists of all monoms with
308// component == comp and *p of all other monoms *lq == pLength(*q)
309// On return all components pf *q == 0
310void pTakeOutComp(poly *p, long comp, poly *q, int *lq);
311
312// This is something weird -- Don't use it, unless you know what you are doing
313poly      pTakeOutComp(poly * p, int k);
314/* old spielwiese
315#define   pTakeOutComp(p,k,q,lq)    p_TakeOutComp(p,k,q,lq,currRing)
316
317// Similar to pTakeOutComp, except that only those components are
318// taken out whose Order == order
319// ASSUME: monomial ordering is Order compatible, i.e., if m1, m2 Monoms then
320//         m1 >= m2 ==> pGetOrder(m1) >= pGetOrder(m2)
321#define   pDecrOrdTakeOutComp(p,c,o,q,lq) p_DecrOrdTakeOutComp(p,c,o,q,lq,currRing)
322*/
323void      pSetPolyComp(poly p, int comp);
324#define   pDeleteComp(p,k) p_DeleteComp(p,k,currRing)
325
326inline void pNorm(poly p, const ring R = currRing){ p_Norm(p, R); }
327
328
329#define   pSubst(p,n,e) p_Subst(p,n.e,currRing)
330#define   ppJet(p,m) pp_Jet(p,m,currRing)
331#define   pJet(p,m)  p_Jet(p,m,currRing)
332#define   ppJetW(p,m,iv) pp_JetW(p,m,iv,currRing)
333#define   pJetW(p,m,iv) p_JetW(p,m,iv,currRing)
334#define   pMinDeg(p,w) p_MinDeg(p,w,currRing)
335#define   pSeries(n,p,u,w) p_Series(n,p,u,w,currRing)
336#define   pInvers(n,p,w) p_Invers(n,p,w,currRing)
337// maximum weigthed degree of all monomials of p, w is indexed from
338// 1..pVariables
339#define    pDegW(p,w) p_DegW(p,w,currRing)
340
341/*-----------type conversions ----------------------------*/
342void  pVec2Polys(poly v, polyset *p, int *len);
343#define   pVar(m) p_Var(m,currRing)
344
345/*-----------specials for spoly-computations--------------*/
346BOOLEAN pCompareChain (poly p,poly p1,poly p2,poly lcm);
347BOOLEAN pCompareChainPart (poly p,poly p1,poly p2,poly lcm);
348#define  pEqualPolys(p1,p2) p_EqualPolys(p1,p2,currRing)
349
350
351// returns the length of a polynomial (numbers of monomials)
352// respect syzComp
353static inline poly pLast(poly a, int &length) { return p_Last (a, length, currRing); }
354static inline poly pLast(poly a) { int l; return pLast(a, l); }
355
356/***************************************************************
357 *
358 * PDEBUG stuff
359 *
360 ***************************************************************/
361#ifdef PDEBUG
362#define pTest(p)        _p_Test(p, currRing, PDEBUG)
363#define pLmTest(p)      _p_LmTest(p, currRing, PDEBUG)
364
365#else // ! PDEBUG
366
367#define pTest(p)        ((void)0)
368#define pLmTest(p)      ((void)0)
369#endif
370
371#endif // POLYS_H
Note: See TracBrowser for help on using the repository browser.