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  number n=r->cf->convFactoryNSingN(f, r->cf);
71  if ( n_IsZero(n, r->cf) )
72  {
73  n_Delete(&n,r->cf);
74  }
75  else
76  {
77  poly term = p_Init(r);
78  //pNext( term ) = NULL; // done by p_Init
79  pGetCoeff(term)=n;
80  p_SetExpV(term,exp,r);
81  sBucket_Merge_m(result,term);
82  }
83  }
84 }
85 
86 CanonicalForm convSingPFactoryP( poly p, const ring r )
87 {
89  int e, n = rVar(r);
90  BOOLEAN setChar=TRUE;
91 
92  p=pReverse(p);
93  poly op=p;
94  while ( p!=NULL )
95  {
97  term=r->cf->convSingNFactoryN(pGetCoeff( p ),setChar, r->cf);
98  if (errorreported) break;
99  setChar=FALSE;
100  for ( int i = n; i >0; i-- )
101  {
102  if ( (e = p_GetExp( p, i, r)) != 0 )
103  term *= power( Variable( i ), e );
104  }
105  result += term;
106  pIter( p );
107  }
108  op=pReverse(op);
109  return result;
110 }
111 
113 {
114  if (!f.isImm()) WerrorS("int overflow in det");
115  return f.intval();
116 }
117 
118 CanonicalForm convSingAPFactoryAP ( poly p , const Variable & a, const ring r)
119 {
120  CanonicalForm result = 0;
121  int e, n = r-> N;
122  int off=rPar(r);
123 
124  if (!rField_is_Zp_a(r))
125  On(SW_RATIONAL);
126  while ( p!=NULL)
127  {
128  CanonicalForm term=convSingAFactoryA(((poly)p_GetCoeff(p, r->cf->extRing)),a, r);
129  for ( int i = 1; i <= n; i++ )
130  {
131  if ( (e = p_GetExp( p, i, r )) != 0 )
132  term *= power( Variable( i + off), e );
133  }
134  result += term;
135  pIter( p );
136  }
137  return result;
138 }
139 
140 static void
141 convRecAP_R ( const CanonicalForm & f, int * exp, poly & result, int par_start, int var_start, const ring r) ;
142 
143 poly convFactoryAPSingAP_R ( const CanonicalForm & f, int par_start, int var_start, const ring r )
144 {
145  int n = rVar(r)+rPar(r)+1;
146  int * exp = (int *)omAlloc0(n*sizeof(int));
147  poly result = NULL;
148  convRecAP_R( f, exp, result,par_start, var_start, r );
149  omFreeSize((ADDRESS)exp,n*sizeof(int));
150  return result;
151 }
152 
153 poly convFactoryAPSingAP ( const CanonicalForm & f, const ring r )
154 {
155  return convFactoryAPSingAP_R(f,0,rPar(r),r);
156 }
157 
158 static void convRecAP_R ( const CanonicalForm & f, int * exp, poly & result, int par_start, int var_start, const ring r )
159 {
160  if (f.isZero())
161  return;
162  if ( ! f.inCoeffDomain() )
163  {
164  int l = f.level();
165  for ( CFIterator i = f; i.hasTerms(); i++ )
166  {
167  exp[l] = i.exp();
168  convRecAP_R( i.coeff(), exp, result, par_start, var_start, r);
169  }
170  exp[l] = 0;
171  }
172  else
173  {
174  poly z=(poly)convFactoryASingA( f,r );
175  if (z!=NULL)
176  {
177  poly term = p_Init(r);
178  //pNext( term ) = NULL; // done by p_Init
179  int i;
180  for ( i = rVar(r); i>0 ; i-- )
181  p_SetExp( term, i , exp[i+var_start],r);
182  //if (rRing_has_Comp(currRing->extRing)) p_SetComp(term, 0, currRing->extRing); // done by pInit
183  if (par_start==0)
184  {
185  for ( i = 1; i <= var_start; i++ )
186  //z->e[i-1]+=exp[i];
187  p_AddExp(z,i,exp[i],r->cf->extRing);
188  }
189  else
190  {
191  for ( i = par_start+1; i <= var_start+rPar(r); i++ )
192  //z->e[i-1]+=exp[i];
193  p_AddExp(z,i,exp[i-par_start],r->cf->extRing);
194  }
195  p_GetCoeff(term, r->cf->extRing)=(number) z;
196  p_Setm( term,r );
197  result = p_Add_q( result, term, r );
198  }
199  }
200 }
201 
202 CanonicalForm convSingAFactoryA ( poly p , const Variable & a, const ring r )
203 {
204  CanonicalForm result = 0;
205  int e;
206 
207  while ( p!=NULL )
208  {
210  if ( rField_is_Zp_a(r) )
211  {
212  term = n_Int( p_GetCoeff( p, r->cf->extRing ), r->cf->extRing->cf );
213  }
214  else
215  {
216  if ( SR_HDL(p_GetCoeff( p, r->cf->extRing )) & SR_INT )
217  term = SR_TO_INT(p_GetCoeff( p, r->cf->extRing )) ;
218  else
219  {
220  if ( p_GetCoeff( p, r->cf->extRing )->s == 3 )
221  {
222  mpz_t dummy;
223  mpz_init_set( dummy, (p_GetCoeff( p,r->cf->extRing )->z) );
224  term = make_cf( dummy );
225  }
226  else
227  {
228  // assume s==0 or s==1
229  mpz_t num, den;
230  On(SW_RATIONAL);
231  mpz_init_set( num, (p_GetCoeff( p, r->cf->extRing )->z) );
232  mpz_init_set( den, (p_GetCoeff( p, r->cf->extRing )->n) );
233  term = make_cf( num, den, ( p_GetCoeff( p, r->cf->extRing )->s != 1 ));
234  }
235  }
236  }
237  if ( (e = p_GetExp( p, 1, r->cf->extRing )) != 0 )
238  term *= power( a , e );
239  result += term;
240  p = pNext( p );
241  }
242  return result;
243 }
244 
245 static number convFactoryNSingAN( const CanonicalForm &f, const ring r)
246 {
247  assume (r != NULL);
248  assume (r->cf != NULL);
249  assume (r->cf->extRing != NULL);
250  // r->cf->extRing->cf has to be Q or Z/p (the supported types of factory)
251  return n_convFactoryNSingN( f, r->cf->extRing->cf );
252 }
253 
254 poly convFactoryASingA ( const CanonicalForm & f, const ring r )
255 {
256  poly a=NULL;
257  for( CFIterator i=f; i.hasTerms(); i++)
258  {
259  number n= convFactoryNSingAN( i.coeff(), r );
260  if (n_IsZero(n,r->cf->extRing->cf))
261  {
262  n_Delete(&n,r->cf->extRing->cf);
263  }
264  else
265  {
266  poly t= p_Init (r->cf->extRing);
267  pGetCoeff(t)=n;
268  p_SetExp(t,1,i.exp(),r->cf->extRing);
269  //p_Setm(t,r->cf->extRing);// not needed for rings with 1 variable
270  a=p_Add_q(a,t,r->cf->extRing);
271  }
272  }
273  if (a!=NULL)
274  {
275  if( r->cf->extRing != NULL )
276  if (r->cf->extRing->qideal->m[0]!=NULL)
277  {
278  poly l=r->cf->extRing->qideal->m[0];
279  if (p_GetExp(a,1,r->cf->extRing) >= p_GetExp(l,1,r->cf->extRing))
280  a = p_PolyDiv (a, l, FALSE, r->cf->extRing); // ???
281  }
282  }
283  return a;
284 }
285 
286 CanonicalForm convSingTrPFactoryP ( poly p, const ring r )
287 {
288  CanonicalForm result = 0;
289  int e, n = rVar(r);
290  int offs = rPar(r);
291 
292  while ( p!=NULL )
293  {
294  n_Normalize(p_GetCoeff(p, r), r->cf);
295 
296  // test if denominator is constant
297  if (!p_IsConstantPoly(DEN ((fraction)p_GetCoeff (p,r)),r->cf->extRing) && !errorreported)
298  WerrorS("conversion error: denominator!= 1");
299 
300  CanonicalForm term=convSingPFactoryP(NUM ((fraction)p_GetCoeff(p, r)),r->cf->extRing);
301 
302  // if denominator is not NULL it should be a constant at this point
303  if (DEN ((fraction)p_GetCoeff(p,r)) != NULL)
304  {
305  CanonicalForm den= convSingPFactoryP(DEN ((fraction)p_GetCoeff(p, r)),r->cf->extRing);
306  if (rChar (r) == 0)
307  On (SW_RATIONAL);
308  term /= den;
309  }
310 
311  for ( int i = n; i > 0; i-- )
312  {
313  if ( (e = p_GetExp( p, i,r )) != 0 )
314  term = term * power( Variable( i + offs ), e );
315  }
316  result += term;
317  p = pNext( p );
318  }
319  return result;
320 }
321 
322 poly convFactoryPSingTrP ( const CanonicalForm & f, const ring r )
323 {
324  int n = rVar(r)+1;
325  int * exp = (int*)omAlloc0(n*sizeof(int));
326  poly result = NULL;
327  convRecTrP( f, exp, result , rPar(r), r );
328  omFreeSize((ADDRESS)exp,n*sizeof(int));
329  return result;
330 }
331 
332 static void
333 convRecTrP ( const CanonicalForm & f, int * exp, poly & result , int offs, const ring r)
334 {
335  if (f.isZero())
336  return;
337  if ( f.level() > offs )
338  {
339  int l = f.level();
340  for ( CFIterator i = f; i.hasTerms(); i++ )
341  {
342  exp[l-offs] = i.exp();
343  convRecTrP( i.coeff(), exp, result, offs, r );
344  }
345  exp[l-offs] = 0;
346  }
347  else
348  {
349  poly term = p_Init(r);
350  //pNext( term ) = NULL; // done by p_Init
351  for ( int i = rVar(r); i>0; i-- )
352  p_SetExp( term, i ,exp[i], r);
353  //if (rRing_has_Comp(currRing)) p_SetComp(term, 0, currRing); // done by pInit
354  pGetCoeff(term)=ntInit(convFactoryPSingP( f, r->cf->extRing ), r->cf);
355  p_Setm( term,r );
356  result = p_Add_q( result, term,r );
357  }
358 }
359 
360 #if 0
362 convSingGFFactoryGF( poly p )
363 {
365  int e, n = pVariables;
366 
367  while ( p != NULL )
368  {
370  term = make_cf_from_gf( (int)(long)pGetCoeff( p ) );
371  //int * A=(int *)&term;
372  //Print("term=%x, == 0 ?: %d\n",*A, term.isZero());
373  for ( int i = 1; i <= n; i++ )
374  {
375  if ( (e = pGetExp( p, i )) != 0 )
376  term *= power( Variable( i ), e );
377  }
378  result += term;
379  p = pNext( p );
380  }
381  return result;
382 }
383 
384 poly
385 convFactoryGFSingGF ( const CanonicalForm & f )
386 {
387 // cerr << " f = " << f << endl;
388  int n = pVariables+1;
389  /* ASSERT( level( f ) <= pVariables, "illegal number of variables" ); */
390  int * exp = (int*)omAlloc0(n*sizeof(int));
391  poly result = NULL;
392  convRecGFGF( f, exp, result );
393  omFreeSize((ADDRESS)exp,n*sizeof(int));
394  return result;
395 }
396 
397 static void
398 convRecGFGF ( const CanonicalForm & f, int * exp, poly & result )
399 {
400  if (f.isZero())
401  return;
402  if ( ! f.inCoeffDomain() )
403  {
404  int l = f.level();
405  for ( CFIterator i = f; i.hasTerms(); i++ )
406  {
407  exp[l] = i.exp();
408  convRecGFGF( i.coeff(), exp, result );
409  }
410  exp[l] = 0;
411  }
412  else
413  {
414  poly term = pInit();
415  pNext( term ) = NULL;
416  for ( int i = 1; i <= pVariables; i++ )
417  pSetExp( term, i, exp[i]);
418  //if (rRing_has_Comp(currRing)) p_SetComp(term, 0, currRing); // done by pInit
419  pGetCoeff( term ) = (number) gf_value (f);
420  pSetm( term );
421  result = pAdd( result, term );
422  }
423 }
424 
425 #endif
CanonicalForm power(const CanonicalForm &f, int n)
exponentiation
long intval() const
conversion functions
int gf_value(const CanonicalForm &f)
Definition: singext.cc:60
#define pSetm(p)
Definition: polys.h:257
#define pAdd(p, q)
Definition: polys.h:190
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:118
static BOOLEAN rField_is_Zp_a(const ring r)
Definition: ring.h:521
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:358
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
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:592
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:590
factory&#39;s class for variables
Definition: factory.h:117
void sBucketDestroyMerge(sBucket_pt bucket, poly *p, int *length)
Definition: sbuckets.h:61
bool isImm() const
CF_NO_INLINE bool isZero() const
Definition: cf_inline.cc:372
#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:286
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:322
factory&#39;s main class
Definition: canonicalform.h:77
#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:579
void * ADDRESS
Definition: auxiliary.h:133
void WerrorS(const char *s)
Definition: feFopen.cc:24
CanonicalForm convSingAFactoryA(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:202
CanonicalForm make_cf(const mpz_ptr n)
Definition: singext.cc:66
poly convFactoryASingA(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:254
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
static void p_SetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1481
#define pIter(p)
Definition: monomials.h:44
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
Coefficient rings, fields and other domains suitable for Singular polynomials.
CanonicalForm make_cf_from_gf(const int z)
Definition: singext.cc:76
int convFactoryISingI(const CanonicalForm &f)
Definition: clapconv.cc:112
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:548
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
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:469
number ntInit(long i, const coeffs cf)
Definition: transext.cc:692
#define assume(x)
Definition: mod2.h:390
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:99
static void convRecTrP(const CanonicalForm &f, int *exp, poly &result, int offs, const ring r)
Definition: clapconv.cc:333
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:125
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
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:1817
static poly pReverse(poly p)
Definition: p_polys.h:335
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
#define SR_TO_INT(SR)
Definition: longrat.h:70
static number convFactoryNSingAN(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:245
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:488
#define NULL
Definition: omList.c:10
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:86
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:1937
#define pNext(p)
Definition: monomials.h:43
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:233
static long p_AddExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:606
#define p_GetCoeff(p, r)
Definition: monomials.h:57
int level() const
level() returns the level of CO.
void sBucket_Merge_m(sBucket_pt bucket, poly p)
Definition: sbuckets.cc:130
#define SR_HDL(A)
Definition: tgb.cc:35
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:153
int p
Definition: cfModGcd.cc:4019
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:892
int BOOLEAN
Definition: auxiliary.h:85
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1266
static void convRecAP_R(const CanonicalForm &f, int *exp, poly &result, int par_start, int var_start, const ring r)
Definition: clapconv.cc:158
poly convFactoryAPSingAP_R(const CanonicalForm &f, int par_start, int var_start, const ring r)
Definition: clapconv.cc:143
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int l
Definition: cfEzgcd.cc:93
return result
Definition: facAbsBiFact.cc:76
bool inCoeffDomain() const