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