source: git/Singular/polys.h @ 5038cd

spielwiese
Last change on this file since 5038cd was 5038cd, checked in by Olaf Bachmann <obachman@…>, 23 years ago
* buckets in local case git-svn-id: file:///usr/local/Singular/svn/trunk@4763 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 15.3 KB
Line 
1#ifndef POLYS_H
2#define POLYS_H
3/****************************************
4*  Computer Algebra System SINGULAR     *
5****************************************/
6/* $Id: polys.h,v 1.46 2000-11-23 17:34:12 obachman Exp $ */
7/*
8* ABSTRACT - all basic methods to manipulate polynomials of the
9             currRing
10*/
11
12#include "p_polys.h"
13/*
14 Some general remarks:
15 We divide poly operations into roughly 4 categories:
16 Level 2: operations on monomials/polynomials with constant time,
17          or operations which are just dispatchers to other
18          poly routines
19          - implemented in: pInline2.h
20          - debugging only if PDEBUG >= 2
21          - normally inlined, unless PDEBUG >= 2 || NO_INLINE2
22 Level 1: operations on monomials with time proportional to length
23          - implemented in: pInline1.h
24          - debugging only if PDEBUG >= 1
25          - normally inlined, unless PDEBUG >= 1 || NO_INLINE1
26 Level 0: short operations on polynomials with time proportional to
27          length of poly
28          - implemented in pInline0.cc
29          - debugging if PDEBUG
30          - normally _not_ inlined: can be forced with
31            #define DO_PINLINE0
32            #include "pInline0.h"
33 Misc   : operations on polynomials which do not fit in any of the
34          above categories
35          - implemented in: polys*.cc
36          - never inlined
37          - debugging if PDEBUG >= 0
38
39 You can set PDEBUG on a per-file basis, before including "mod2.h" like
40   #define PDEBUG 2
41   #include "mod2.h"
42 However, PDEBUG will only be in effect, if !NDEBUG.
43
44 All p_* operations take as last argument a ring
45 and are ring independent. Their corresponding p* operations are usually
46 just macros to the respective p_*(..,currRing).
47
48*/
49
50/***************************************************************
51 *
52 * Primitives for accessing and setting fields of a poly
53 * poly must be != NULL
54 *
55 ***************************************************************/
56// deletes old coeff before setting the new one
57#define pSetCoeff(p,n)      p_SetCoeff(p,n,currRing)
58
59// Order
60#define pGetOrder(p)        p_GetOrder(p, currRing)
61// don't use this
62#define pSetOrder(p, o)     p_SetOrder(p, o, currRing)
63
64// Component
65#define pGetComp(p)         _p_GetComp(p, currRing)
66#define pSetComp(p,v)       p_SetComp(p,v, currRing)
67#define pIncrComp(p)        p_IncrComp(p,currRing)
68#define pDecrComp(p)        p_DecrComp(p,currRing)
69#define pAddComp(p,v)       p_AddComp(p,v,currRing)
70#define pSubComp(p,v)       p_SubComp(p,v,currRing)
71
72// Exponent
73#define pGetExp(p,i)        p_GetExp(p, i, currRing)
74#define pSetExp(p,i,v)      p_SetExp(p, i, v, currRing)
75#define pIncrExp(p,i)       p_IncrExp(p,i, currRing)
76#define pDecrExp(p,i)       p_DecrExp(p,i, currRing)
77#define pAddExp(p,i,v)      p_AddExp(p,i,v, currRing)
78#define pSubExp(p,i,v)      p_SubExp(p,i,v, currRing)
79#define pMultExp(p,i,v)     p_MultExp(p,i,v, currRing)
80#define pGetExpSum(p1, p2, i)    p_GetExpSum(p1, p2, i, currRing)
81#define pGetExpDiff(p1, p2, i)   p_GetExpDiff(p1, p2, i, currRing)
82
83/***************************************************************
84 *
85 * Allocation/Initalization/Deletion
86 * except for pDeleteLm and pHead, all polys must be != NULL
87 *
88 ***************************************************************/
89// allocates the space for a new monomial -- no initialization !!!
90#define pNew()          p_New(currRing)
91// allocates a new monomial and initializes everything to 0
92#define pInit()         p_Init(currRing)
93// like pInit, except that expvector is initialized to that of p,
94// p must be != NULL
95#define pLmInit(p)  p_LmInit(p, currRing)
96// returns newly allocated copy of Lm(p), coef is copied, next=NULL,
97// p might be NULL
98#define pHead(p)        p_Head(p, currRing)
99// if *p_ptr != NULL, delete p_ptr->coef, *p_ptr, and set *p_ptr to
100// pNext(*p_ptr)
101static inline void pDeleteLm(poly *p) {p_DeleteLm(p, currRing);}
102// if (p!=NULL) delete p-coef and p
103static inline void pDeleteLm(poly p)  {p_DeleteLm(p, currRing);}
104// frees the space of the monomial m, assumes m != NULL
105// coef is not freed, m is not advanced
106static inline void pLmFree(poly p)    {p_LmFree(p, currRing);}
107// like pLmFree, but advances p
108static inline void pLmFree(poly *p)   {p_LmFree(p, currRing);}
109// assumes p != NULL, deletes p, returns pNext(p)
110#define pLmFreeAndNext(p) p_LmFreeAndNext(p, currRing)
111// assume p != NULL, deletes Lm(p)->coef and Lm(p)
112#define pLmDelete(p)    p_LmDelete(p, currRing)
113// like pLmDelete, returns pNext(p)
114#define pLmDeleteAndNext(p) p_LmDeleteAndNext(p, currRing)
115// used by iparith.cc
116extern poly pHeadProc(poly p);
117
118/***************************************************************
119 *
120 * Operation on ExpVectors: assumes polys != NULL
121 *
122 ***************************************************************/
123
124#define pExpVectorCopy(d_p, s_p)    p_ExpVectorCopy(d_p, s_p, currRing)
125#define pExpVectorAdd(p1, p2)       p_ExpVectorAdd(p1, p2, currRing)
126#define pExpVectorSub(p1, p2)       p_ExpVectorSub(p1, p2, currRing)
127#define pExpVectorAddSub(p1, p2, p3)p_ExpVectorAddSub(p1, p2, p3, currRing)
128#define pExpVectorSum(pr, p1, p2)   p_ExpVectorSum(pr, p1, p2, currRing)
129#define pExpVectorDiff(pr, p1, p2)  p_ExpVectorDiff(pr, p1, p2, currRing)
130#define pExpVectorEqual(p1, p2)     p_ExpVectorEqual(p1, p2, currRing)
131#define pExpVectorQuerSum(p)        p_ExpVectorQuerSum(p, currRing)
132
133// Gets a copy of (resp. set) the exponent vector, where e is assumed
134// to point to (r->N +1)*sizeof(Exponent_t) memory. Exponents are
135// filled in as follows: comp, e_1, .., e_n
136#define pGetExpV(p, e)      p_GetExpV(p, e, currRing)
137#define pSetExpV(p, e)      p_SetExpV(p, e, currRing)
138
139/***************************************************************
140 *
141 * Comparisons: they are all done without regarding coeffs
142 *
143 ***************************************************************/
144// returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
145#define pLmCmp(p,q)         p_LmCmp(p,q,currRing)
146// executes axtionE|actionG|actionS if p=q|p>q|p<q w.r.t monomial ordering
147// action should be a "goto ..."
148#define pLmCmpAction(p,q, actionE, actionG, actionS)  \
149  _p_LmCmpAction(p,q,currRing, actionE, actionG,actionS)
150
151#define pLmEqual(p1, p2)     pExpVectorEqual(p1, p2)
152
153// pCmp: args may be NULL
154// returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
155#define pCmp(p1, p2)    p_Cmp(p1, p2, currRing)
156
157 
158/***************************************************************
159 *
160 * Divisiblity tests, args must be != NULL, except for
161 * pDivisbleBy
162 *
163 ***************************************************************/
164// returns TRUE, if leading monom of a divides leading monom of b
165// i.e., if there exists a expvector c > 0, s.t. b = a + c;
166#define pDivisibleBy(a, b)  p_DivisibleBy(a,b,currRing)
167// like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
168#define pLmDivisibleBy(a,b)  p_LmDivisibleBy(a,b,currRing)
169// like pLmDivisibleBy, does not check components
170#define pLmDivisibleByNoComp(a, b) p_LmDivisibleByNoComp(a,b,currRing)
171// Divisibility tests based on Short Exponent vectors
172// sev_a     == pGetShortExpVector(a)
173// not_sev_b == ~ pGetShortExpVector(b)
174#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b) \
175  p_LmShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)
176// returns the "Short Exponent Vector" -- used to speed up divisibility
177// tests (see polys-impl.cc )
178#define pGetShortExpVector(a)   p_GetShortExpVector(a, currRing)
179
180/***************************************************************
181 *
182 * Copying/Deleteion of polys: args may be NULL
183 *
184 ***************************************************************/
185// return a copy of the poly
186#define pCopy(p) p_Copy(p, currRing)
187#define pDelete(p_ptr)  p_Delete(p_ptr, currRing)
188
189/***************************************************************
190 *
191 * Copying/Deleteion of polys: args may be NULL
192 *  - p/q as arg mean a poly
193 *  - m a monomial
194 *  - n a number
195 *  - pp (resp. qq, mm, nn) means arg is constant
196 *  - p (resp, q, m, n)     means arg is destroyed
197 *
198 ***************************************************************/
199#define pNeg(p)                     p_Neg(p, currRing)
200#define ppMult_nn(p, n)             pp_Mult_nn(p, n, currRing)
201#define pMult_nn(p, n)              p_Mult_nn(p, n, currRing)
202#define ppMult_mm(p, m)             pp_Mult_mm(p, m, currRing)
203#define pMult_mm(p, m)              p_Mult_mm(p, m, currRing)
204#define pAdd(p, q)                  p_Add_q(p, q, currRing)
205#define pMinus_mm_Mult_qq(p, m, q)  p_Minus_mm_Mult_qq(p, m, q, currRing)
206#define pPlus_mm_Mult_qq(p, m, q)   p_Plus_mm_Mult_qq(p, m, q, currRing)
207#define pMult(p, q)                 p_Mult_q(p, q, currRing)
208#define ppMult_qq(p, q)             pp_Mult_qq(p, q, currRing)
209// p*Coeff(m) for such monomials pm of p, for which m is divisble by pm
210#define ppMult_Coeff_mm_DivSelect(p, m)   pp_Mult_Coeff_mm_DivSelect(p, m, currRing)
211/***************************************************************
212 *
213 * Predicates on polys/Lm's
214 *
215 ***************************************************************/
216#define pLmIsConstantComp(p)        p_LmIsConstantComp(p, currRing)
217
218
219/***************************************************************
220 *
221 * Old stuff
222 *
223 ***************************************************************/
224
225#define pFetchCopy(r,p)     _pFetchCopy(r,p)
226// Similar to pFetchCopy, except that poly p is deleted
227#define pFetchCopyDelete(r, p) _pFetchCopyDelete(r, p)
228
229typedef poly*   polyset;
230extern int      pVariables;
231extern int      pOrdSgn;
232extern BOOLEAN  pLexOrder;
233extern poly     ppNoether;
234extern BOOLEAN  pVectorOut;
235
236/*-------------predicate on polys ----------------------*/
237BOOLEAN   pIsConstant(const poly p);
238BOOLEAN   pIsConstantPoly(poly p);
239#define   pIsPurePower(p)   p_IsPurePower(p, currRing)
240#define   pIsVector(p)     (pGetComp(p)!=0)
241BOOLEAN   pHasNotCF(poly p1, poly p2);   /*has no common factor ?*/
242void      pSplit(poly p, poly * r);   /*p => IN(p), r => REST(p) */
243
244
245
246/*-------------ring management:----------------------*/
247//extern void pChangeRing(ring newRing);
248extern void pSetGlobals(ring r, BOOLEAN complete = TRUE);
249
250/*-----------the ordering of monomials:-------------*/
251#define pSetm(p)    p_Setm(p, currRing)
252// TODO:
253#define pSetmComp   pSetm
254
255/***************************************************************
256 *
257 * Degree stuff -- see p_polys.cc for explainations
258 *
259 ***************************************************************/
260extern pLDegProc pLDeg;
261extern pFDegProc pFDeg;
262int  pWeight(int c, ring r = currRing);
263long pDeg(poly p, ring r = currRing);
264long pTotaldegree(poly p, ring r = currRing);
265long pWTotaldegree(poly p, ring r = currRing);
266long pWDegree(poly p, ring r = currRing);
267long pLDeg0(poly p,int *l, ring r = currRing);
268long pLDeg0c(poly p,int *l, ring r = currRing);
269long pLDegb(poly p,int *l, ring r = currRing);
270long pLDeg1(poly p,int *l, ring r = currRing);
271long pLDeg1c(poly p,int *l, ring r = currRing);
272long pLDeg1_Deg(poly p,int *l, ring r = currRing);
273long pLDeg1c_Deg(poly p,int *l, ring r = currRing);
274long pLDeg1_Totaldegree(poly p,int *l, ring r = currRing);
275long pLDeg1c_Totaldegree(poly p,int *l, ring r = currRing);
276
277/*-------------pComp for syzygies:-------------------*/
278
279void pSetModDeg(intvec *w);
280
281
282
283
284poly      pmInit(char *s, BOOLEAN &ok);   /* monom -> poly */
285void      ppDelete(poly * a, ring r);
286
287/*-------------operations on polynomials:------------*/
288poly      pSub(poly a, poly b);
289poly      pPower(poly p, int i);
290
291// ----------------- define to enable new p_procs -----*/
292
293poly      pDivide(poly a, poly b);
294poly      pDivideM(poly a, poly b);
295void      pLcm(poly a, poly b, poly m);
296poly      pDiff(poly a, int k);
297poly      pDiffOp(poly a, poly b,BOOLEAN multiply);
298
299#define   pMaxComp(p)   p_MaxComp(p, currRing)
300#define   pMinComp(p)   p_MinComp(p, currRing)
301int pMaxCompProc(poly p);
302
303#define   pOneComp(p)       p_OneComp(p, currRing)
304#define   pSetCompP(a,i)    p_SetCompP(a, i, currRing)
305
306// let's inline those, so that we can call them from the debugger
307inline char*   pString(poly p)    {return p_String(p, currRing, currRing);}
308inline char*   pString0(poly p)   {return p_String0(p, currRing, currRing);}
309inline void    pWrite(poly p)     {p_Write(p, currRing, currRing);}
310inline void    pWrite0(poly p)    {p_Write0(p, currRing, currRing);}
311inline void    wrp(poly p)        {p_wrp(p, currRing, currRing);}
312
313void      pEnlargeSet(polyset *p, int length, int increment);
314poly      pISet(int i);
315#define   pOne()   pISet(1)
316
317void      pContent(poly p);
318void      pCleardenom(poly p);
319void      pNormalize(poly p);
320
321// homogenizes p by multiplying certain powers of the varnum-th variable
322poly      pHomogen (poly p, int varnum);
323
324// replaces the maximal powers of the leading monomial of p2 in p1 by
325// the same powers of n, utility for dehomogenization
326poly      pDehomogen (poly p1,poly p2,number n);
327BOOLEAN   pIsHomogeneous (poly p);
328
329// returns the leading monomial of p1 divided by the maximal power of
330// that of p2
331poly      pDivByMonom (poly p1,poly p2);
332
333// Returns as i-th entry of P the coefficient of the (i-1) power of
334// the leading monomial of p2 in p1
335void      pCancelPolyByMonom (poly p1,poly p2,polyset * P,int * SizeOfSet);
336
337// orders monoms of poly using insertion sort, performs pSetm on each
338// monom (i.e. sets Order field)
339poly      pOrdPolyInsertSetm(poly p);
340
341// orders monoms of poly using merge sort (ususally faster than
342// insertion sort). ASSUMES that pSetm was performed on monoms
343// (i.e. that Order field is set correctly)
344poly      pOrdPolyMerge(poly p);
345
346poly      pPermPoly (poly p, int * perm, ring OldRing,
347                     int *par_perm=NULL, int OldPar=0);
348
349/*BOOLEAN   pVectorHasUnitM(poly p, int * k);*/
350BOOLEAN   pVectorHasUnitB(poly p, int * k);
351void      pVectorHasUnit(poly p, int * k, int * len);
352poly      pTakeOutComp1(poly * p, int k);
353// Splits *p into two polys: *q which consists of all monoms with
354// component == comp and *p of all other monoms *lq == pLength(*q)
355// On return all components pf *q == 0
356void pTakeOutComp(poly *p, Exponent_t comp, poly *q, int *lq);
357// Similar to pTakeOutComp, except that only those components are
358// taken out whose Order == order
359// ASSUME: monomial ordering is Order compatible, i.e., if m1, m2 Monoms then
360//         m1 >= m2 ==> pGetOrder(m1) >= pGetOrder(m2)
361void pDecrOrdTakeOutComp(poly *p, Exponent_t comp, Order_t order,
362                         poly *q, int *lq);
363// This is something weird -- Don't use it, unless you know what you are doing
364poly      pTakeOutComp(poly * p, int k);
365void      pSetPolyComp(poly p, int comp);
366void      pDeleteComp(poly * p,int k);
367void      pNorm(poly p);
368poly      pSubst(poly p, int n, poly e);
369poly      pJet(poly p, int m);
370poly      pJetW(poly p, int m, short * iv);
371// maximum weigthed degree of all monomials of p, w is indexed from
372// 1..pVariables
373int       pDegW(poly p, short *w);
374
375/*-----------type conversions ----------------------------*/
376poly  pPolys2Vec(polyset p, int len);
377void  pVec2Polys(poly v, polyset *p, int *len);
378int   pVar(poly m);
379
380/*-----------specials for spoly-computations--------------*/
381BOOLEAN pCompareChain (poly p,poly p1,poly p2,poly lcm);
382BOOLEAN pEqualPolys(poly p1,poly p2);
383BOOLEAN pComparePolys(poly p1,poly p2);
384
385
386
387/***************************************************************
388 *
389 * PDEBUG stuff
390 *
391 ***************************************************************/
392#ifdef PDEBUG
393#define pTest(p)        _p_Test(p, currRing, PDEBUG)
394#define pLmTest(p)      _p_LmTest(p, currRing, PDEBUG)
395
396#else // ! PDEBUG
397
398#define pTest(p)        ((void)0)
399#define pLmTest(p)      ((void)0)
400#endif
401
402#endif // POLYS_H
403
Note: See TracBrowser for help on using the repository browser.