My Project  UNKNOWN_GIT_VERSION
Macros | Functions
clapconv.cc File Reference
#include "misc/auxiliary.h"
#include "omalloc/omalloc.h"
#include "factory/factory.h"
#include "coeffs/coeffs.h"
#include "coeffs/longrat.h"
#include "polys/monomials/p_polys.h"
#include "polys/sbuckets.h"
#include "polys/clapconv.h"
#include "simpleideals.h"
#include "polys/ext_fields/transext.h"

Go to the source code of this file.

Macros

#define TRANSEXT_PRIVATES
 

Functions

void out_cf (const char *s1, const CanonicalForm &f, const char *s2)
 
static void conv_RecPP (const CanonicalForm &f, int *exp, sBucket_pt result, ring r)
 
static void convRecTrP (const CanonicalForm &f, int *exp, poly &result, int offs, const ring r)
 
static number convFactoryNSingAN (const CanonicalForm &f, const ring r)
 
poly convFactoryPSingP (const CanonicalForm &f, const ring r)
 
CanonicalForm convSingPFactoryP (poly p, const ring r)
 
int convFactoryISingI (const CanonicalForm &f)
 
CanonicalForm convSingAPFactoryAP (poly p, const Variable &a, const ring r)
 
static void convRecAP_R (const CanonicalForm &f, int *exp, poly &result, int par_start, int var_start, const ring r)
 
poly convFactoryAPSingAP_R (const CanonicalForm &f, int par_start, int var_start, const ring r)
 
poly convFactoryAPSingAP (const CanonicalForm &f, const ring r)
 
CanonicalForm convSingAFactoryA (poly p, const Variable &a, const ring r)
 
poly convFactoryASingA (const CanonicalForm &f, const ring r)
 
CanonicalForm convSingTrPFactoryP (poly p, const ring r)
 
poly convFactoryPSingTrP (const CanonicalForm &f, const ring r)
 

Macro Definition Documentation

◆ TRANSEXT_PRIVATES

#define TRANSEXT_PRIVATES

Definition at line 29 of file clapconv.cc.

Function Documentation

◆ conv_RecPP()

static void conv_RecPP ( const CanonicalForm f,
int *  exp,
sBucket_pt  result,
ring  r 
)
static

Definition at line 54 of file clapconv.cc.

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);
82  }
83  }
84 }

◆ convFactoryAPSingAP()

poly convFactoryAPSingAP ( const CanonicalForm f,
const ring  r 
)

Definition at line 152 of file clapconv.cc.

153 {
154  return convFactoryAPSingAP_R(f,0,rPar(r),r);
155 }

◆ convFactoryAPSingAP_R()

poly convFactoryAPSingAP_R ( const CanonicalForm f,
int  par_start,
int  var_start,
const ring  r 
)

Definition at line 142 of file clapconv.cc.

143 {
144  int n = rVar(r)+rPar(r)+1;
145  int * exp = (int *)omAlloc0(n*sizeof(int));
146  poly result = NULL;
147  convRecAP_R( f, exp, result,par_start, var_start, r );
148  omFreeSize((ADDRESS)exp,n*sizeof(int));
149  return result;
150 }

◆ convFactoryASingA()

poly convFactoryASingA ( const CanonicalForm f,
const ring  r 
)

Definition at line 253 of file clapconv.cc.

254 {
255  poly a=NULL;
256  for( CFIterator i=f; i.hasTerms(); i++)
257  {
258  number n= convFactoryNSingAN( i.coeff(), r );
259  if (n_IsZero(n,r->cf->extRing->cf))
260  {
261  n_Delete(&n,r->cf->extRing->cf);
262  }
263  else
264  {
265  poly t= p_Init (r->cf->extRing);
266  pGetCoeff(t)=n;
267  p_SetExp(t,1,i.exp(),r->cf->extRing);
268  //p_Setm(t,r->cf->extRing);// not needed for rings with 1 variable
269  a=p_Add_q(a,t,r->cf->extRing);
270  }
271  }
272  if (a!=NULL)
273  {
274  if( r->cf->extRing != NULL )
275  if (r->cf->extRing->qideal->m[0]!=NULL)
276  {
277  poly l=r->cf->extRing->qideal->m[0];
278  if (p_GetExp(a,1,r->cf->extRing) >= p_GetExp(l,1,r->cf->extRing))
279  a = p_PolyDiv (a, l, FALSE, r->cf->extRing); // ???
280  }
281  }
282  return a;
283 }

◆ convFactoryISingI()

int convFactoryISingI ( const CanonicalForm f)

Definition at line 111 of file clapconv.cc.

112 {
113  if (!f.isImm()) WerrorS("int overflow in det");
114  return f.intval();
115 }

◆ convFactoryNSingAN()

static number convFactoryNSingAN ( const CanonicalForm f,
const ring  r 
)
static

Definition at line 244 of file clapconv.cc.

245 {
246  assume (r != NULL);
247  assume (r->cf != NULL);
248  assume (r->cf->extRing != NULL);
249  // r->cf->extRing->cf has to be Q or Z/p (the supported types of factory)
250  return n_convFactoryNSingN( f, r->cf->extRing->cf );
251 }

◆ convFactoryPSingP()

poly convFactoryPSingP ( const CanonicalForm f,
const ring  r 
)

Definition at line 41 of file clapconv.cc.

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 }

◆ convFactoryPSingTrP()

poly convFactoryPSingTrP ( const CanonicalForm f,
const ring  r 
)

Definition at line 321 of file clapconv.cc.

322 {
323  int n = rVar(r)+1;
324  int * exp = (int*)omAlloc0(n*sizeof(int));
325  poly result = NULL;
326  convRecTrP( f, exp, result , rPar(r), r );
327  omFreeSize((ADDRESS)exp,n*sizeof(int));
328  return result;
329 }

◆ convRecAP_R()

static void convRecAP_R ( const CanonicalForm f,
int *  exp,
poly &  result,
int  par_start,
int  var_start,
const ring  r 
)
static

Definition at line 157 of file clapconv.cc.

158 {
159  if (f.isZero())
160  return;
161  if ( ! f.inCoeffDomain() )
162  {
163  int l = f.level();
164  for ( CFIterator i = f; i.hasTerms(); i++ )
165  {
166  exp[l] = i.exp();
167  convRecAP_R( i.coeff(), exp, result, par_start, var_start, r);
168  }
169  exp[l] = 0;
170  }
171  else
172  {
173  poly z=(poly)convFactoryASingA( f,r );
174  if (z!=NULL)
175  {
176  poly term = p_Init(r);
177  //pNext( term ) = NULL; // done by p_Init
178  int i;
179  for ( i = rVar(r); i>0 ; i-- )
180  p_SetExp( term, i , exp[i+var_start],r);
181  //if (rRing_has_Comp(currRing->extRing)) p_SetComp(term, 0, currRing->extRing); // done by pInit
182  if (par_start==0)
183  {
184  for ( i = 1; i <= var_start; i++ )
185  //z->e[i-1]+=exp[i];
186  p_AddExp(z,i,exp[i],r->cf->extRing);
187  }
188  else
189  {
190  for ( i = par_start+1; i <= var_start+rPar(r); i++ )
191  //z->e[i-1]+=exp[i];
192  p_AddExp(z,i,exp[i-par_start],r->cf->extRing);
193  }
194  p_GetCoeff(term, r->cf->extRing)=(number) z;
195  p_Setm( term,r );
196  result = p_Add_q( result, term, r );
197  }
198  }
199 }

◆ convRecTrP()

static void convRecTrP ( const CanonicalForm f,
int *  exp,
poly &  result,
int  offs,
const ring  r 
)
static

Definition at line 332 of file clapconv.cc.

333 {
334  if (f.isZero())
335  return;
336  if ( f.level() > offs )
337  {
338  int l = f.level();
339  for ( CFIterator i = f; i.hasTerms(); i++ )
340  {
341  exp[l-offs] = i.exp();
342  convRecTrP( i.coeff(), exp, result, offs, r );
343  }
344  exp[l-offs] = 0;
345  }
346  else
347  {
348  poly term = p_Init(r);
349  //pNext( term ) = NULL; // done by p_Init
350  for ( int i = rVar(r); i>0; i-- )
351  p_SetExp( term, i ,exp[i], r);
352  //if (rRing_has_Comp(currRing)) p_SetComp(term, 0, currRing); // done by pInit
353  pGetCoeff(term)=ntInit(convFactoryPSingP( f, r->cf->extRing ), r->cf);
354  p_Setm( term,r );
355  result = p_Add_q( result, term,r );
356  }
357 }

◆ convSingAFactoryA()

CanonicalForm convSingAFactoryA ( poly  p,
const Variable a,
const ring  r 
)

Definition at line 201 of file clapconv.cc.

202 {
203  CanonicalForm result = 0;
204  int e;
205 
206  while ( p!=NULL )
207  {
209  if ( rField_is_Zp_a(r) )
210  {
211  term = n_Int( p_GetCoeff( p, r->cf->extRing ), r->cf->extRing->cf );
212  }
213  else
214  {
215  if ( SR_HDL(p_GetCoeff( p, r->cf->extRing )) & SR_INT )
216  term = SR_TO_INT(p_GetCoeff( p, r->cf->extRing )) ;
217  else
218  {
219  if ( p_GetCoeff( p, r->cf->extRing )->s == 3 )
220  {
221  mpz_t dummy;
222  mpz_init_set( dummy, (p_GetCoeff( p,r->cf->extRing )->z) );
223  term = make_cf( dummy );
224  }
225  else
226  {
227  // assume s==0 or s==1
228  mpz_t num, den;
229  On(SW_RATIONAL);
230  mpz_init_set( num, (p_GetCoeff( p, r->cf->extRing )->z) );
231  mpz_init_set( den, (p_GetCoeff( p, r->cf->extRing )->n) );
232  term = make_cf( num, den, ( p_GetCoeff( p, r->cf->extRing )->s != 1 ));
233  }
234  }
235  }
236  if ( (e = p_GetExp( p, 1, r->cf->extRing )) != 0 )
237  term *= power( a , e );
238  result += term;
239  p = pNext( p );
240  }
241  return result;
242 }

◆ convSingAPFactoryAP()

CanonicalForm convSingAPFactoryAP ( poly  p,
const Variable a,
const ring  r 
)

Definition at line 117 of file clapconv.cc.

118 {
119  CanonicalForm result = 0;
120  int e, n = r-> N;
121  int off=rPar(r);
122 
123  if (!rField_is_Zp_a(r))
124  On(SW_RATIONAL);
125  while ( p!=NULL)
126  {
127  CanonicalForm term=convSingAFactoryA(((poly)p_GetCoeff(p, r->cf->extRing)),a, r);
128  for ( int i = 1; i <= n; i++ )
129  {
130  if ( (e = p_GetExp( p, i, r )) != 0 )
131  term *= power( Variable( i + off), e );
132  }
133  result += term;
134  pIter( p );
135  }
136  return result;
137 }

◆ convSingPFactoryP()

CanonicalForm convSingPFactoryP ( poly  p,
const ring  r 
)

Definition at line 86 of file clapconv.cc.

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  {
96  CanonicalForm term=r->cf->convSingNFactoryN(pGetCoeff( p ),setChar, r->cf);
97  if (errorreported) break;
98  setChar=FALSE;
99  for ( int i = n; i >0; i-- )
100  {
101  if ( (e = p_GetExp( p, i, r)) != 0 )
102  term *= CanonicalForm( Variable( i ), e );
103  }
104  result += term;
105  pIter( p );
106  }
107  op=pReverse(op);
108  return result;
109 }

◆ convSingTrPFactoryP()

CanonicalForm convSingTrPFactoryP ( poly  p,
const ring  r 
)

Definition at line 285 of file clapconv.cc.

286 {
287  CanonicalForm result = 0;
288  int e, n = rVar(r);
289  int offs = rPar(r);
290 
291  while ( p!=NULL )
292  {
293  n_Normalize(p_GetCoeff(p, r), r->cf);
294 
295  // test if denominator is constant
296  if (!p_IsConstantPoly(DEN ((fraction)p_GetCoeff (p,r)),r->cf->extRing) && !errorreported)
297  WerrorS("conversion error: denominator!= 1");
298 
299  CanonicalForm term=convSingPFactoryP(NUM ((fraction)p_GetCoeff(p, r)),r->cf->extRing);
300 
301  // if denominator is not NULL it should be a constant at this point
302  if (DEN ((fraction)p_GetCoeff(p,r)) != NULL)
303  {
304  CanonicalForm den= convSingPFactoryP(DEN ((fraction)p_GetCoeff(p, r)),r->cf->extRing);
305  if (rChar (r) == 0)
306  On (SW_RATIONAL);
307  term /= den;
308  }
309 
310  for ( int i = n; i > 0; i-- )
311  {
312  if ( (e = p_GetExp( p, i,r )) != 0 )
313  term = term * power( Variable( i + offs ), e );
314  }
315  result += term;
316  p = pNext( p );
317  }
318  return result;
319 }

◆ out_cf()

void out_cf ( const char *  s1,
const CanonicalForm f,
const char *  s2 
)

Definition at line 90 of file cf_factor.cc.

91 {
92  printf("%s",s1);
93  if (f.isZero()) printf("+0");
94  //else if (! f.inCoeffDomain() )
95  else if (! f.inBaseDomain() )
96  {
97  int l = f.level();
98  for ( CFIterator i = f; i.hasTerms(); i++ )
99  {
100  int e=i.exp();
101  if (i.coeff().isOne())
102  {
103  printf("+");
104  if (e==0) printf("1");
105  else
106  {
107  printf("v(%d)",l);
108  if (e!=1) printf("^%d",e);
109  }
110  }
111  else
112  {
113  out_cf("+(",i.coeff(),")");
114  if (e!=0)
115  {
116  printf("*v(%d)",l);
117  if (e!=1) printf("^%d",e);
118  }
119  }
120  }
121  }
122  else
123  {
124  if ( f.isImm() )
125  {
127  {
128  long a= imm2int (f.getval());
129  if ( a == gf_q )
130  printf ("+%ld", a);
131  else if ( a == 0L )
132  printf ("+1");
133  else if ( a == 1L )
134  printf ("+%c",gf_name);
135  else
136  {
137  printf ("+%c",gf_name);
138  printf ("^%ld",a);
139  }
140  }
141  else
142  printf("+%ld",f.intval());
143  }
144  else
145  {
146  #ifdef NOSTREAMIO
147  if (f.inZ())
148  {
149  mpz_t m;
150  gmp_numerator(f,m);
151  char * str = new char[mpz_sizeinbase( m, 10 ) + 2];
152  str = mpz_get_str( str, 10, m );
153  puts(str);
154  delete[] str;
155  mpz_clear(m);
156  }
157  else if (f.inQ())
158  {
159  mpz_t m;
160  gmp_numerator(f,m);
161  char * str = new char[mpz_sizeinbase( m, 10 ) + 2];
162  str = mpz_get_str( str, 10, m );
163  puts(str);putchar('/');
164  delete[] str;
165  mpz_clear(m);
167  str = new char[mpz_sizeinbase( m, 10 ) + 2];
168  str = mpz_get_str( str, 10, m );
169  puts(str);
170  delete[] str;
171  mpz_clear(m);
172  }
173  #else
174  std::cout << f;
175  #endif
176  }
177  //if (f.inZ()) printf("(Z)");
178  //else if (f.inQ()) printf("(Q)");
179  //else if (f.inFF()) printf("(FF)");
180  //else if (f.inPP()) printf("(PP)");
181  //else if (f.inGF()) printf("(PP)");
182  //else
183  if (f.inExtension()) printf("E(%d)",f.level());
184  }
185  printf("%s",s2);
186 }
FALSE
#define FALSE
Definition: auxiliary.h:94
SW_RATIONAL
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
p_GetCoeff
#define p_GetCoeff(p, r)
Definition: monomials.h:51
p_GetExp
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:470
f
FILE * f
Definition: checklibs.c:9
errorreported
short errorreported
Definition: feFopen.cc:23
CFIterator
class to iterate through CanonicalForm's
Definition: cf_iter.h:44
result
return result
Definition: facAbsBiFact.cc:76
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
num
CanonicalForm num(const CanonicalForm &f)
Definition: canonicalform.h:330
CFFactory::gettype
static int gettype()
Definition: cf_factory.h:28
power
CanonicalForm power(const CanonicalForm &f, int n)
exponentiation
Definition: canonicalform.cc:1837
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
make_cf
CanonicalForm make_cf(const mpz_ptr n)
Definition: singext.cc:66
convSingAFactoryA
CanonicalForm convSingAFactoryA(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:201
N
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
rField_is_Zp_a
static BOOLEAN rField_is_Zp_a(const ring r)
Definition: ring.h:520
n_IsZero
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:464
gf_name
char gf_name
Definition: gfops.cc:52
n_Normalize
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
CanonicalForm
factory's main class
Definition: canonicalform.h:83
term
Definition: int_poly.h:33
p_SetExp
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:489
p_SetExpV
static void p_SetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1472
convRecTrP
static void convRecTrP(const CanonicalForm &f, int *exp, poly &result, int offs, const ring r)
Definition: clapconv.cc:332
GaloisFieldDomain
#define GaloisFieldDomain
Definition: cf_defs.h:22
rVar
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:582
conv_RecPP
static void conv_RecPP(const CanonicalForm &f, int *exp, sBucket_pt result, ring r)
Definition: clapconv.cc:54
TRUE
#define TRUE
Definition: auxiliary.h:98
i
int i
Definition: cfEzgcd.cc:125
rChar
int rChar(ring r)
Definition: ring.cc:686
out_cf
void out_cf(const char *s1, const CanonicalForm &f, const char *s2)
cf_algorithm.cc - simple mathematical algorithms.
Definition: cf_factor.cc:90
n_convFactoryNSingN
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:622
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
convFactoryNSingAN
static number convFactoryNSingAN(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:244
sBucketCreate
sBucket_pt sBucketCreate(const ring r)
Definition: sbuckets.cc:98
pIter
#define pIter(p)
Definition: monomials.h:38
rPar
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:589
gf_q
int gf_q
Definition: gfops.cc:47
p_Init
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1257
p_PolyDiv
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
den
CanonicalForm den(const CanonicalForm &f)
Definition: canonicalform.h:333
sBucket
Definition: sbuckets.cc:32
SR_INT
#define SR_INT
Definition: longrat.h:66
convSingPFactoryP
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:86
exp
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:358
SR_TO_INT
#define SR_TO_INT(SR)
Definition: longrat.h:68
ntInit
number ntInit(long i, const coeffs cf)
Definition: transext.cc:705
p_Add_q
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:893
imm2int
static long imm2int(const InternalCF *const imm)
Definition: imm.h:70
Variable
factory's class for variables
Definition: factory.h:118
sBucket_Merge_m
void sBucket_Merge_m(sBucket_pt bucket, poly p)
Definition: sbuckets.cc:129
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
SR_HDL
#define SR_HDL(A)
Definition: tgb.cc:35
m
int m
Definition: cfEzgcd.cc:121
p_AddExp
static long p_AddExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:607
assume
#define assume(x)
Definition: mod2.h:390
NULL
#define NULL
Definition: omList.c:10
l
int l
Definition: cfEzgcd.cc:93
n_Int
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
gmp_denominator
void gmp_denominator(const CanonicalForm &f, mpz_ptr result)
Definition: singext.cc:40
p_Setm
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:234
gmp_numerator
void gmp_numerator(const CanonicalForm &f, mpz_ptr result)
Definition: singext.cc:20
p
int p
Definition: cfModGcd.cc:4019
p_IsConstantPoly
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
Definition: p_polys.h:1943
NUM
@ NUM
Definition: readcf.cc:173
convFactoryASingA
poly convFactoryASingA(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:253
pGetCoeff
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:45
convRecAP_R
static void convRecAP_R(const CanonicalForm &f, int *exp, poly &result, int par_start, int var_start, const ring r)
Definition: clapconv.cc:157
convFactoryAPSingAP_R
poly convFactoryAPSingAP_R(const CanonicalForm &f, int par_start, int var_start, const ring r)
Definition: clapconv.cc:142
pNext
#define pNext(p)
Definition: monomials.h:37
pReverse
static poly pReverse(poly p)
Definition: p_polys.h:336
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:211
convFactoryPSingP
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
On
void On(int sw)
switches
Definition: canonicalform.cc:1898
sBucketDestroyMerge
void sBucketDestroyMerge(sBucket_pt bucket, poly *p, int *length)
Definition: sbuckets.h:61