clapconv.cc
Go to the documentation of this file.
1 // emacs edit mode for this file is -*- C++ -*-
2 /****************************************
3 * Computer Algebra System SINGULAR *
4 ****************************************/
5 /*
6 * ABSTRACT: convert data between Singular and factory
7 */
8 
9 
10 
11 
12 
13 #include <misc/auxiliary.h>
14 #include <omalloc/omalloc.h>
15 
16 #include <factory/factory.h>
17 
18 #include <coeffs/coeffs.h>
19 
20 #include <coeffs/longrat.h> // snumber is necessary
21 
23 #include <polys/sbuckets.h>
24 #include <polys/clapconv.h>
25 
26 #include "simpleideals.h"
27 
28 #define TRANSEXT_PRIVATES
30 
31 void out_cf(const char *s1,const CanonicalForm &f,const char *s2);
32 
33 static void conv_RecPP ( const CanonicalForm & f, int * exp, sBucket_pt result, ring r );
34 
35 static void convRecTrP ( const CanonicalForm & f, int * exp, poly & result, int offs, const ring r );
36 
37 //static void convRecGFGF ( const CanonicalForm & f, int * exp, poly & result );
38 
39 static number convFactoryNSingAN( const CanonicalForm &f, const ring r);
40 
41 poly convFactoryPSingP ( const CanonicalForm & f, const ring r )
42 {
43  int n = rVar(r)+1;
44  /* ASSERT( level( f ) <= pVariables, "illegal number of variables" ); */
45  int * exp = (int*)omAlloc0(n*sizeof(int));
46  sBucket_pt result_bucket=sBucketCreate(r);
47  conv_RecPP( f, exp, result_bucket, r );
48  poly result; int dummy;
49  sBucketDestroyMerge(result_bucket,&result,&dummy);
50  omFreeSize((ADDRESS)exp,n*sizeof(int));
51  return result;
52 }
53 
54 static void conv_RecPP ( const CanonicalForm & f, int * exp, sBucket_pt result, ring r )
55 {
56  if (f.isZero())
57  return;
58  if ( ! f.inCoeffDomain() )
59  {
60  int l = f.level();
61  for ( CFIterator i = f; i.hasTerms(); i++ )
62  {
63  exp[l] = i.exp();
64  conv_RecPP( i.coeff(), exp, result, r );
65  }
66  exp[l] = 0;
67  }
68  else
69  {
70  poly term = p_Init(r);
71  pNext( term ) = NULL;
72  for ( int i = 1; i <= r->N; i++ )
73  p_SetExp( term, i, exp[i], r);
74  pGetCoeff( term )=r->cf->convFactoryNSingN(f, r->cf);
75  p_Setm( term, r );
76  if ( n_IsZero(pGetCoeff(term), r->cf) )
77  {
78  p_Delete(&term,r);
79  }
80  else
81  {
83  }
84  }
85 }
86 
87 
89 {
91  int e, n = rVar(r);
92  BOOLEAN setChar=TRUE;
93 
94  p=pReverse(p);
95  poly op=p;
96  while ( p!=NULL )
97  {
99  term=r->cf->convSingNFactoryN(pGetCoeff( p ),setChar, r->cf);
100  if (errorreported) break;
101  setChar=FALSE;
102  for ( int i = n; i >0; i-- )
103  {
104  if ( (e = p_GetExp( p, i, r)) != 0 )
105  term *= power( Variable( i ), e );
106  }
107  result += term;
108  pIter( p );
109  }
110  op=pReverse(op);
111  return result;
112 }
113 
115 {
116  if (!f.isImm()) WerrorS("int overflow in det");
117  return f.intval();
118 }
119 
121 {
122  CanonicalForm result = 0;
123  int e, n = r-> N;
124  int off=rPar(r);
125 
126  if (!rField_is_Zp_a(r))
127  On(SW_RATIONAL);
128  while ( p!=NULL)
129  {
130  CanonicalForm term=convSingAFactoryA(((poly)p_GetCoeff(p, r->cf->extRing)),a, r);
131  for ( int i = 1; i <= n; i++ )
132  {
133  if ( (e = p_GetExp( p, i, r )) != 0 )
134  term *= power( Variable( i + off), e );
135  }
136  result += term;
137  pIter( p );
138  }
139  return result;
140 }
141 
142 static void
143 convRecAP_R ( const CanonicalForm & f, int * exp, poly & result, int par_start, int var_start, const ring r) ;
144 
145 poly convFactoryAPSingAP_R ( const CanonicalForm & f, int par_start, int var_start, const ring r )
146 {
147  int n = rVar(r)+rPar(r)+1;
148  int * exp = (int *)omAlloc0(n*sizeof(int));
149  poly result = NULL;
150  convRecAP_R( f, exp, result,par_start, var_start, r );
151  omFreeSize((ADDRESS)exp,n*sizeof(int));
152  return result;
153 }
154 
155 poly convFactoryAPSingAP ( const CanonicalForm & f, const ring r )
156 {
157  return convFactoryAPSingAP_R(f,0,rPar(r),r);
158 }
159 
160 static void convRecAP_R ( const CanonicalForm & f, int * exp, poly & result, int par_start, int var_start, const ring r )
161 {
162  if (f.isZero())
163  return;
164  if ( ! f.inCoeffDomain() )
165  {
166  int l = f.level();
167  for ( CFIterator i = f; i.hasTerms(); i++ )
168  {
169  exp[l] = i.exp();
170  convRecAP_R( i.coeff(), exp, result, par_start, var_start, r);
171  }
172  exp[l] = 0;
173  }
174  else
175  {
176  poly z=(poly)convFactoryASingA( f,r );
177  if (z!=NULL)
178  {
179  poly term = p_Init(r);
180  pNext( term ) = NULL;
181  int i;
182  for ( i = rVar(r); i>0 ; i-- )
183  p_SetExp( term, i , exp[i+var_start],r);
184  //if (rRing_has_Comp(currRing->extRing)) p_SetComp(term, 0, currRing->extRing); // done by pInit
185  if (par_start==0)
186  {
187  for ( i = 1; i <= var_start; i++ )
188  //z->e[i-1]+=exp[i];
189  p_AddExp(z,i,exp[i],r->cf->extRing);
190  }
191  else
192  {
193  for ( i = par_start+1; i <= var_start+rPar(r); i++ )
194  //z->e[i-1]+=exp[i];
195  p_AddExp(z,i,exp[i-par_start],r->cf->extRing);
196  }
197  pGetCoeff(term)=(number)ALLOC0_RNUMBER();
198  p_GetCoeff(term, r->cf->extRing)=(number) z;
199  p_Setm( term,r );
200  result = p_Add_q( result, term, r );
201  }
202  }
203 }
204 
205 CanonicalForm convSingAFactoryA ( poly p , const Variable & a, const ring r )
206 {
207  CanonicalForm result = 0;
208  int e;
209 
210  while ( p!=NULL )
211  {
213  if ( rField_is_Zp_a(r) )
214  {
215  term = n_Int( p_GetCoeff( p, r->cf->extRing ), r->cf->extRing->cf );
216  }
217  else
218  {
219  if ( SR_HDL(p_GetCoeff( p, r->cf->extRing )) & SR_INT )
220  term = SR_TO_INT(p_GetCoeff( p, r->cf->extRing )) ;
221  else
222  {
223  if ( p_GetCoeff( p, r->cf->extRing )->s == 3 )
224  {
225  mpz_t dummy;
226  mpz_init_set( dummy, (p_GetCoeff( p,r->cf->extRing )->z) );
227  term = make_cf( dummy );
228  }
229  else
230  {
231  // assume s==0 or s==1
232  mpz_t num, den;
233  On(SW_RATIONAL);
234  mpz_init_set( num, (p_GetCoeff( p, r->cf->extRing )->z) );
235  mpz_init_set( den, (p_GetCoeff( p, r->cf->extRing )->n) );
236  term = make_cf( num, den, ( p_GetCoeff( p, r->cf->extRing )->s != 1 ));
237  }
238  }
239  }
240  if ( (e = p_GetExp( p, 1, r->cf->extRing )) != 0 )
241  term *= power( a , e );
242  result += term;
243  p = pNext( p );
244  }
245  return result;
246 }
247 
248 static number convFactoryNSingAN( const CanonicalForm &f, const ring r)
249 {
250  assume (r != NULL);
251  assume (r->cf != NULL);
252  assume (r->cf->extRing != NULL);
253  // r->cf->extRing->cf has to be Q or Z/p (the supported types of factory)
254  return n_convFactoryNSingN( f, r->cf->extRing->cf );
255 }
256 
257 poly convFactoryASingA ( const CanonicalForm & f, const ring r )
258 {
259  poly a=NULL;
260  poly t;
261  for( CFIterator i=f; i.hasTerms(); i++)
262  {
263  t= p_Init (r->cf->extRing);
264  p_GetCoeff(t, r->cf->extRing)= convFactoryNSingAN( i.coeff(), r );
265  if (n_IsZero(p_GetCoeff(t,r->cf->extRing),r->cf->extRing->cf))
266  {
267  p_Delete(&t,r->cf->extRing);
268  }
269  else
270  {
271  p_SetExp(t,1,i.exp(),r->cf->extRing);
272  a=p_Add_q(a,t,r->cf->extRing);
273  }
274  }
275  if (a!=NULL)
276  {
277  if( r->cf->extRing != NULL )
278  if (r->cf->extRing->qideal->m[0]!=NULL)
279  {
280  poly l=r->cf->extRing->qideal->m[0];
281  if (p_GetExp(a,1,r->cf->extRing) >= p_GetExp(l,1,r->cf->extRing))
282  a = p_PolyDiv (a, l, FALSE, r->cf->extRing); // ???
283  }
284  }
285  return a;
286 }
287 
289 {
290  CanonicalForm result = 0;
291  int e, n = rVar(r);
292  int offs = rPar(r);
293 
294  while ( p!=NULL )
295  {
296  n_Normalize(p_GetCoeff(p, r), r->cf);
297 
298  // test if denominator is constant
299  if (!p_IsConstantPoly(DEN ((fraction)p_GetCoeff (p,r)),r->cf->extRing) && !errorreported)
300  WerrorS("conversion error: denominator!= 1");
301 
302  CanonicalForm term=convSingPFactoryP(NUM ((fraction)p_GetCoeff(p, r)),r->cf->extRing);
303 
304  // if denominator is not NULL it should be a constant at this point
305  if (DEN ((fraction)p_GetCoeff(p,r)) != NULL)
306  {
307  CanonicalForm den= convSingPFactoryP(DEN ((fraction)p_GetCoeff(p, r)),r->cf->extRing);
308  if (rChar (r) == 0)
309  On (SW_RATIONAL);
310  term /= den;
311  }
312 
313  for ( int i = n; i > 0; i-- )
314  {
315  if ( (e = p_GetExp( p, i,r )) != 0 )
316  term = term * power( Variable( i + offs ), e );
317  }
318  result += term;
319  p = pNext( p );
320  }
321  return result;
322 }
323 
324 poly convFactoryPSingTrP ( const CanonicalForm & f, const ring r )
325 {
326  int n = rVar(r)+1;
327  int * exp = (int*)omAlloc0(n*sizeof(int));
328  poly result = NULL;
329  convRecTrP( f, exp, result , rPar(r), r );
330  omFreeSize((ADDRESS)exp,n*sizeof(int));
331  return result;
332 }
333 
334 static void
335 convRecTrP ( const CanonicalForm & f, int * exp, poly & result , int offs, const ring r)
336 {
337  if (f.isZero())
338  return;
339  if ( f.level() > offs )
340  {
341  int l = f.level();
342  for ( CFIterator i = f; i.hasTerms(); i++ )
343  {
344  exp[l-offs] = i.exp();
345  convRecTrP( i.coeff(), exp, result, offs, r );
346  }
347  exp[l-offs] = 0;
348  }
349  else
350  {
351  poly term = p_Init(r);
352  pNext( term ) = NULL;
353  for ( int i = rVar(r); i>0; i-- )
354  p_SetExp( term, i ,exp[i], r);
355  //if (rRing_has_Comp(currRing)) p_SetComp(term, 0, currRing); // done by pInit
356  pGetCoeff(term)=ntInit(convFactoryPSingP( f, r->cf->extRing ), r->cf);
357  p_Setm( term,r );
358  result = p_Add_q( result, term,r );
359  }
360 }
361 
362 #if 0
364 convSingGFFactoryGF( poly p )
365 {
367  int e, n = pVariables;
368 
369  while ( p != NULL )
370  {
372  term = make_cf_from_gf( (int)(long)pGetCoeff( p ) );
373  //int * A=(int *)&term;
374  //Print("term=%x, == 0 ?: %d\n",*A, term.isZero());
375  for ( int i = 1; i <= n; i++ )
376  {
377  if ( (e = pGetExp( p, i )) != 0 )
378  term *= power( Variable( i ), e );
379  }
380  result += term;
381  p = pNext( p );
382  }
383  return result;
384 }
385 
386 poly
387 convFactoryGFSingGF ( const CanonicalForm & f )
388 {
389 // cerr << " f = " << f << endl;
390  int n = pVariables+1;
391  /* ASSERT( level( f ) <= pVariables, "illegal number of variables" ); */
392  int * exp = (int*)omAlloc0(n*sizeof(int));
393  poly result = NULL;
394  convRecGFGF( f, exp, result );
395  omFreeSize((ADDRESS)exp,n*sizeof(int));
396  return result;
397 }
398 
399 static void
400 convRecGFGF ( const CanonicalForm & f, int * exp, poly & result )
401 {
402  if (f.isZero())
403  return;
404  if ( ! f.inCoeffDomain() )
405  {
406  int l = f.level();
407  for ( CFIterator i = f; i.hasTerms(); i++ )
408  {
409  exp[l] = i.exp();
410  convRecGFGF( i.coeff(), exp, result );
411  }
412  exp[l] = 0;
413  }
414  else
415  {
416  poly term = pInit();
417  pNext( term ) = NULL;
418  for ( int i = 1; i <= pVariables; i++ )
419  pSetExp( term, i, exp[i]);
420  //if (rRing_has_Comp(currRing)) p_SetComp(term, 0, currRing); // done by pInit
421  pGetCoeff( term ) = (number) gf_value (f);
422  pSetm( term );
423  result = pAdd( result, term );
424  }
425 }
426 
427 #endif
CanonicalForm power(const CanonicalForm &f, int n)
exponentiation
int gf_value(const CanonicalForm &f)
Definition: singext.cc:60
#define pSetm(p)
Definition: polys.h:253
const poly a
Definition: syzextra.cc:212
#define pAdd(p, q)
Definition: polys.h:186
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:120
static BOOLEAN rField_is_Zp_a(const ring r)
Definition: ring.h:521
CanonicalForm num(const CanonicalForm &f)
Definition: int_poly.h:33
#define pSetExp(p, i, v)
Definition: polys.h:42
#define FALSE
Definition: auxiliary.h:94
return P p
Definition: myNF.cc:203
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:587
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:590
factory&#39;s class for variables
Definition: factory.h:115
void sBucketDestroyMerge(sBucket_pt bucket, poly *p, int *length)
Definition: sbuckets.h:65
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
int rChar(ring r)
Definition: ring.cc:688
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:288
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:324
factory&#39;s main class
Definition: canonicalform.h:75
#define TRUE
Definition: auxiliary.h:98
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:582
void * ADDRESS
Definition: auxiliary.h:115
void WerrorS(const char *s)
Definition: feFopen.cc:24
CanonicalForm convSingAFactoryA(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:205
CanonicalForm make_cf(const mpz_ptr n)
Definition: singext.cc:70
poly convFactoryASingA(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:257
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
#define pIter(p)
Definition: monomials.h:44
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
const ring r
Definition: syzextra.cc:208
Coefficient rings, fields and other domains suitable for Singular polynomials.
CanonicalForm make_cf_from_gf(const int z)
Definition: singext.cc:86
int convFactoryISingI(const CanonicalForm &f)
Definition: clapconv.cc:114
static FORCE_INLINE long n_Int(number &n, const coeffs r)
conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 ...
Definition: coeffs.h:551
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:464
void sBucket_Merge_p(sBucket_pt bucket, poly p, int length)
Merges p into Spoly: assumes Bpoly and p have no common monoms destroys p!
Definition: sbuckets.cc:176
number ntInit(long i, const coeffs cf)
Definition: transext.cc:692
#define assume(x)
Definition: mod2.h:394
static void conv_RecPP(const CanonicalForm &f, int *exp, sBucket_pt result, ring r)
Definition: clapconv.cc:54
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
sBucket_pt sBucketCreate(const ring r)
Definition: sbuckets.cc:120
static void convRecTrP(const CanonicalForm &f, int *exp, poly &result, int offs, const ring r)
Definition: clapconv.cc:335
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
All the auxiliary stuff.
void On(int sw)
switches
FILE * f
Definition: checklibs.c:9
int i
Definition: cfEzgcd.cc:123
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:468
poly p_PolyDiv(poly &p, const poly divisor, const BOOLEAN needResult, const ring r)
assumes that p and divisor are univariate polynomials in r, mentioning the same variable; assumes div...
Definition: p_polys.cc:1831
static poly pReverse(poly p)
Definition: p_polys.h:330
void out_cf(const char *s1, const CanonicalForm &f, const char *s2)
Definition: cf_factor.cc:90
short errorreported
Definition: feFopen.cc:23
class to iterate through CanonicalForm&#39;s
Definition: cf_iter.h:44
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:843
#define SR_TO_INT(SR)
Definition: longrat.h:70
static number convFactoryNSingAN(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:248
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
#define NULL
Definition: omList.c:10
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
Definition: readcf.cc:156
CanonicalForm den(const CanonicalForm &f)
#define pInit()
allocates a new monomial and initializes everything to 0
Definition: polys.h:61
#define SR_INT
Definition: longrat.h:68
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
Definition: p_polys.h:1890
#define pNext(p)
Definition: monomials.h:43
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
static long p_AddExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:601
#define p_GetCoeff(p, r)
Definition: monomials.h:57
p exp[i]
Definition: DebugPrint.cc:39
#define SR_HDL(A)
Definition: tgb.cc:35
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:155
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:877
int BOOLEAN
Definition: auxiliary.h:85
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1243
static void convRecAP_R(const CanonicalForm &f, int *exp, poly &result, int par_start, int var_start, const ring r)
Definition: clapconv.cc:160
poly convFactoryAPSingAP_R(const CanonicalForm &f, int par_start, int var_start, const ring r)
Definition: clapconv.cc:145
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int l
Definition: cfEzgcd.cc:94
return result
Definition: facAbsBiFact.cc:76
#define ALLOC0_RNUMBER()
Definition: coeffs.h:88