My Project  debian-1:4.1.2-p1+ds-2
FLINTconvert.cc
Go to the documentation of this file.
1 /*****************************************************************************\
2  * Computer Algebra System SINGULAR
3 \*****************************************************************************/
4 /** @file FLINTconvert.cc
5  *
6  * This file implements functions for conversion to FLINT (www.flintlib.org)
7  * and back.
8  *
9  * @author Martin Lee
10  *
11  **/
12 /*****************************************************************************/
13 
14 
15 
16 #include <config.h>
17 
18 
19 #include "canonicalform.h"
20 #include "fac_util.h"
21 #include "cf_iter.h"
22 #include "cf_factory.h"
23 #include "gmpext.h"
24 #include "singext.h"
25 #include "cf_algorithm.h"
26 
27 #ifdef HAVE_FLINT
28 #ifdef HAVE_CSTDIO
29 #include <cstdio>
30 #else
31 #include <stdio.h>
32 #endif
33 #ifdef __cplusplus
34 extern "C"
35 {
36 #endif
37 #ifndef __GMP_BITS_PER_MP_LIMB
38 #define __GMP_BITS_PER_MP_LIMB GMP_LIMB_BITS
39 #endif
40 #include <flint/fmpz.h>
41 #include <flint/fmpq.h>
42 #include <flint/fmpz_poly.h>
43 #include <flint/fmpz_mod_poly.h>
44 #include <flint/nmod_poly.h>
45 #include <flint/fmpq_poly.h>
46 #include <flint/nmod_mat.h>
47 #include <flint/fmpz_mat.h>
48 #if ( __FLINT_RELEASE >= 20400)
49 #include <flint/fq.h>
50 #include <flint/fq_poly.h>
51 #include <flint/fq_nmod.h>
52 #include <flint/fq_nmod_poly.h>
53 #include <flint/fq_nmod_mat.h>
54 #endif
55 #ifdef __cplusplus
56 }
57 #endif
58 
59 #include "FLINTconvert.h"
60 
61 void convertCF2Fmpz (fmpz_t result, const CanonicalForm& f)
62 {
63  if (f.isImm())
64  fmpz_set_si (result, f.intval());
65  else
66  {
67  mpz_t gmp_val;
68  f.mpzval(gmp_val);
69  fmpz_set_mpz (result, gmp_val);
70  mpz_clear (gmp_val);
71  }
72 }
73 
74 void convertFacCF2Fmpz_poly_t (fmpz_poly_t result, const CanonicalForm& f)
75 {
76  fmpz_poly_init2 (result, degree (f)+1);
77  _fmpz_poly_set_length(result, degree(f)+1);
78  for (CFIterator i= f; i.hasTerms(); i++)
79  convertCF2Fmpz (fmpz_poly_get_coeff_ptr(result, i.exp()), i.coeff());
80 }
81 
82 CanonicalForm convertFmpz2CF (const fmpz_t coefficient)
83 {
84  if (fmpz_cmp_si (coefficient, MINIMMEDIATE) >= 0 &&
85  fmpz_cmp_si (coefficient, MAXIMMEDIATE) <= 0)
86  {
87  long coeff= fmpz_get_si (coefficient);
88  return CanonicalForm (coeff);
89  }
90  else
91  {
92  mpz_t gmp_val;
93  mpz_init (gmp_val);
94  fmpz_get_mpz (gmp_val, coefficient);
96  return result;
97  }
98 }
99 
101 convertFmpz_poly_t2FacCF (const fmpz_poly_t poly, const Variable& x)
102 {
104  fmpz* coeff;
105  for (int i= 0; i < fmpz_poly_length (poly); i++)
106  {
107  coeff= fmpz_poly_get_coeff_ptr (poly, i);
108  if (!fmpz_is_zero (coeff))
109  result += convertFmpz2CF (coeff)*power (x,i);
110  }
111  return result;
112 }
113 
114 void
116 {
117  bool save_sym_ff= isOn (SW_SYMMETRIC_FF);
118  if (save_sym_ff) Off (SW_SYMMETRIC_FF);
119  nmod_poly_init2 (result, getCharacteristic(), degree (f)+1);
120  for (CFIterator i= f; i.hasTerms(); i++)
121  {
122  CanonicalForm c= i.coeff();
123  if (!c.isImm()) c=c.mapinto(); //c%= getCharacteristic();
124  if (!c.isImm())
125  { //This case will never happen if the characteristic is in fact a prime
126  // number, since all coefficients are represented as immediates
127  printf("convertCF2nmod_poly_t: coefficient not immediate!, char=%d\n",
129  }
130  else
131  nmod_poly_set_coeff_ui (result, i.exp(), c.intval());
132  }
133  if (save_sym_ff) On (SW_SYMMETRIC_FF);
134 }
135 
137 convertnmod_poly_t2FacCF (const nmod_poly_t poly, const Variable& x)
138 {
140  for (int i= 0; i < nmod_poly_length (poly); i++)
141  {
142  ulong coeff= nmod_poly_get_coeff_ui (poly, i);
143  if (coeff != 0)
144  result += CanonicalForm ((long)coeff)*power (x,i);
145  }
146  return result;
147 }
148 
149 void convertCF2Fmpq (fmpq_t result, const CanonicalForm& f)
150 {
151  //ASSERT (isOn (SW_RATIONAL), "expected rational");
152  if (f.isImm ())
153  {
154  fmpz_set_si (fmpq_numref (result), f.num().intval());
155  fmpz_set_si (fmpq_denref (result), f.den().intval());
156  }
157  else
158  {
159  mpz_t gmp_val;
160  gmp_numerator (f, gmp_val);
161  fmpz_set_mpz (fmpq_numref (result), gmp_val);
162  mpz_clear (gmp_val);
163  gmp_denominator (f, gmp_val);
164  fmpz_set_mpz (fmpq_denref (result), gmp_val);
165  mpz_clear (gmp_val);
166  }
167 }
168 
170 {
171  bool isRat= isOn (SW_RATIONAL);
172  if (!isRat)
173  On (SW_RATIONAL);
174 
176  mpz_t nnum, nden;
177  mpz_init (nnum);
178  mpz_init (nden);
179  fmpz_get_mpz (nnum, fmpq_numref (q));
180  fmpz_get_mpz (nden, fmpq_denref (q));
181 
183  if (mpz_is_imm (nnum) && mpz_is_imm (nden))
184  {
185  num= CanonicalForm (mpz_get_si(nnum));
186  den= CanonicalForm (mpz_get_si(nden));
187  mpz_clear (nnum);
188  mpz_clear (nden);
189  result= num/den;
190  if (!isRat)
191  Off (SW_RATIONAL);
192  return result;
193  }
194  else
195  {
196  result= make_cf (nnum, nden, false);
197  if (!isRat)
198  Off (SW_RATIONAL);
199  return result;
200  }
201 }
202 
204 convertFmpq_poly_t2FacCF (const fmpq_poly_t p, const Variable& x)
205 {
207  fmpq_t coeff;
208  long n= p->length;
209  for (long i= 0; i < n; i++)
210  {
211  fmpq_init (coeff);
212  fmpq_poly_get_coeff_fmpq (coeff, p, i);
213  if (fmpq_is_zero (coeff))
214  {
215  fmpq_clear (coeff);
216  continue;
217  }
218  result += convertFmpq_t2CF (coeff)*power (x, i);
219  fmpq_clear (coeff);
220  }
221  return result;
222 }
223 
225 {
226  for (CFIterator i= f; i.hasTerms(); i++)
227  convertCF2Fmpz (&result[i.exp()], i.coeff());
228 }
229 
230 void convertFacCF2Fmpq_poly_t (fmpq_poly_t result, const CanonicalForm& f)
231 {
232  bool isRat= isOn (SW_RATIONAL);
233  if (!isRat)
234  On (SW_RATIONAL);
235 
236  fmpq_poly_init2 (result, degree (f)+1);
237  _fmpq_poly_set_length (result, degree (f) + 1);
239  convertFacCF2Fmpz_array (fmpq_poly_numref (result), f*den);
240  convertCF2Fmpz (fmpq_poly_denref (result), den);
241 
242  if (!isRat)
243  Off (SW_RATIONAL);
244 }
245 
246 CFFList
247 convertFLINTnmod_poly_factor2FacCFFList (const nmod_poly_factor_t fac,
248  const mp_limb_t leadingCoeff,
249  const Variable& x
250  )
251 {
252  CFFList result;
253  if (leadingCoeff != 1)
254  result.insert (CFFactor (CanonicalForm ((long) leadingCoeff), 1));
255 
256  long i;
257 
258  for (i = 0; i < fac->num; i++)
260  (nmod_poly_t &)fac->p[i],x),
261  fac->exp[i]));
262  return result;
263 }
264 
265 #if __FLINT_RELEASE >= 20400
266 CFFList
267 convertFLINTFq_nmod_poly_factor2FacCFFList (const fq_nmod_poly_factor_t fac,
268  const Variable& x, const Variable& alpha,
269  const fq_nmod_ctx_t fq_con
270  )
271 {
272  CFFList result;
273 
274  long i;
275 
276  for (i = 0; i < fac->num; i++)
278  (fq_nmod_poly_t &)fac->poly[i], x, alpha, fq_con),
279  fac->exp[i]));
280  return result;
281 }
282 #endif
283 
284 void
286  const fmpz_t p)
287 {
288  fmpz_mod_poly_init2 (result, p, degree (f) + 1);
289  fmpz_poly_t buf;
291  fmpz_mod_poly_set_fmpz_poly (result, buf);
292  fmpz_poly_clear (buf);
293 }
294 
296 convertFmpz_mod_poly_t2FacCF (const fmpz_mod_poly_t poly, const Variable& x,
297  const modpk& b)
298 {
299  fmpz_poly_t buf;
300  fmpz_poly_init (buf);
301  fmpz_mod_poly_get_fmpz_poly (buf, poly);
303  fmpz_poly_clear (buf);
304  return b (result);
305 }
306 
307 #if __FLINT_RELEASE >= 20400
308 void
310  const fq_nmod_ctx_t ctx)
311 {
312  bool save_sym_ff= isOn (SW_SYMMETRIC_FF);
313  if (save_sym_ff) Off (SW_SYMMETRIC_FF);
314  for (CFIterator i= f; i.hasTerms(); i++)
315  {
316  CanonicalForm c= i.coeff();
317  if (!c.isImm()) c=c.mapinto(); //c%= getCharacteristic();
318  if (!c.isImm())
319  { //This case will never happen if the characteristic is in fact a prime
320  // number, since all coefficients are represented as immediates
321  printf("convertFacCF2Fq_nmod_t: coefficient not immediate!, char=%d\n",
323  }
324  else
325  {
326  STICKYASSERT (i.exp() <= fq_nmod_ctx_degree(ctx), "convertFacCF2Fq_nmod_t: element is not reduced");
327  nmod_poly_set_coeff_ui (result, i.exp(), c.intval());
328  }
329  }
330  if (save_sym_ff) On (SW_SYMMETRIC_FF);
331 }
332 
334 convertFq_nmod_t2FacCF (const fq_nmod_t poly, const Variable& alpha)
335 {
336  return convertnmod_poly_t2FacCF (poly, alpha);
337 }
338 
339 void
340 convertFacCF2Fq_t (fq_t result, const CanonicalForm& f, const fq_ctx_t ctx)
341 {
342  fmpz_poly_init2 (result, fq_ctx_degree(ctx));
343  ASSERT (degree (f) < fq_ctx_degree (ctx), "input is not reduced");
344  _fmpz_poly_set_length(result, degree(f)+1);
345  for (CFIterator i= f; i.hasTerms(); i++)
346  convertCF2Fmpz (fmpz_poly_get_coeff_ptr(result, i.exp()), i.coeff());
347  _fmpz_vec_scalar_mod_fmpz (result->coeffs, result->coeffs, degree (f) + 1,
348  &ctx->p);
349  _fmpz_poly_normalise (result);
350 }
351 
353 convertFq_t2FacCF (const fq_t poly, const Variable& alpha)
354 {
355  return convertFmpz_poly_t2FacCF (poly, alpha);
356 }
357 
358 void
360  const fq_ctx_t ctx)
361 {
362  fq_poly_init2 (result, degree (f)+1, ctx);
363  _fq_poly_set_length (result, degree (f) + 1, ctx);
364  fmpz_poly_t buf;
365  for (CFIterator i= f; i.hasTerms(); i++)
366  {
367  convertFacCF2Fmpz_poly_t (buf, i.coeff());
368  _fmpz_vec_scalar_mod_fmpz (buf->coeffs, buf->coeffs, degree (i.coeff()) + 1,
369  &ctx->p);
370  _fmpz_poly_normalise (buf);
371  fq_poly_set_coeff (result, i.exp(), buf, ctx);
372  fmpz_poly_clear (buf);
373  }
374 }
375 
376 void
378  const fq_nmod_ctx_t ctx)
379 {
380  fq_nmod_poly_init2 (result, degree (f)+1, ctx);
381  _fq_nmod_poly_set_length (result, degree (f) + 1, ctx);
382  fq_nmod_t buf;
383  fq_nmod_init2 (buf, ctx);
384  for (CFIterator i= f; i.hasTerms(); i++)
385  {
386  convertFacCF2Fq_nmod_t (buf, i.coeff(), ctx);
387  fq_nmod_poly_set_coeff (result, i.exp(), buf, ctx);
388  fq_nmod_zero (buf, ctx);
389  }
390  fq_nmod_clear (buf, ctx);
391 }
392 
394 convertFq_poly_t2FacCF (const fq_poly_t p, const Variable& x,
395  const Variable& alpha, const fq_ctx_t ctx)
396 {
398  fq_t coeff;
399  long n= fq_poly_length (p, ctx);
400  fq_init2 (coeff, ctx);
401  for (long i= 0; i < n; i++)
402  {
403  fq_poly_get_coeff (coeff, p, i, ctx);
404  if (fq_is_zero (coeff, ctx))
405  continue;
406  result += convertFq_t2FacCF (coeff, alpha)*power (x, i);
407  fq_zero (coeff, ctx);
408  }
409  fq_clear (coeff, ctx);
410 
411  return result;
412 }
413 
415 convertFq_nmod_poly_t2FacCF (const fq_nmod_poly_t p, const Variable& x,
416  const Variable& alpha, const fq_nmod_ctx_t ctx)
417 {
419  fq_nmod_t coeff;
420  long n= fq_nmod_poly_length (p, ctx);
421  fq_nmod_init2 (coeff, ctx);
422  for (long i= 0; i < n; i++)
423  {
424  fq_nmod_poly_get_coeff (coeff, p, i, ctx);
425  if (fq_nmod_is_zero (coeff, ctx))
426  continue;
427  result += convertFq_nmod_t2FacCF (coeff, alpha)*power (x, i);
428  fq_nmod_zero (coeff, ctx);
429  }
430  fq_nmod_clear (coeff, ctx);
431 
432  return result;
433 }
434 #endif
435 
436 void convertFacCFMatrix2Fmpz_mat_t (fmpz_mat_t M, const CFMatrix &m)
437 {
438  fmpz_mat_init (M, (long) m.rows(), (long) m.columns());
439 
440  int i,j;
441  for(i=m.rows();i>0;i--)
442  {
443  for(j=m.columns();j>0;j--)
444  {
445  convertCF2Fmpz (fmpz_mat_entry (M,i-1,j-1), m(i,j));
446  }
447  }
448 }
450 {
451  CFMatrix *res=new CFMatrix(fmpz_mat_nrows (m),fmpz_mat_ncols (m));
452  int i,j;
453  for(i=res->rows();i>0;i--)
454  {
455  for(j=res->columns();j>0;j--)
456  {
457  (*res)(i,j)=convertFmpz2CF(fmpz_mat_entry (m,i-1,j-1));
458  }
459  }
460  return res;
461 }
462 
463 void convertFacCFMatrix2nmod_mat_t (nmod_mat_t M, const CFMatrix &m)
464 {
465  nmod_mat_init (M, (long) m.rows(), (long) m.columns(), getCharacteristic());
466 
467  bool save_sym_ff= isOn (SW_SYMMETRIC_FF);
468  if (save_sym_ff) Off (SW_SYMMETRIC_FF);
469  int i,j;
470  for(i=m.rows();i>0;i--)
471  {
472  for(j=m.columns();j>0;j--)
473  {
474  if(!(m(i,j)).isImm()) printf("convertFacCFMatrix2FLINTmat_zz_p: not imm.\n");
475  nmod_mat_entry (M,i-1,j-1)= (m(i,j)).intval();
476  }
477  }
478  if (save_sym_ff) On (SW_SYMMETRIC_FF);
479 }
480 
482 {
483  CFMatrix *res=new CFMatrix(nmod_mat_nrows (m), nmod_mat_ncols (m));
484  int i,j;
485  for(i=res->rows();i>0;i--)
486  {
487  for(j=res->columns();j>0;j--)
488  {
489  (*res)(i,j)=CanonicalForm((long) nmod_mat_entry (m, i-1, j-1));
490  }
491  }
492  return res;
493 }
494 
495 #if __FLINT_RELEASE >= 20400
496 void
498  const fq_nmod_ctx_t fq_con, const CFMatrix &m)
499 {
500  fq_nmod_mat_init (M, (long) m.rows(), (long) m.columns(), fq_con);
501  int i,j;
502  for(i=m.rows();i>0;i--)
503  {
504  for(j=m.columns();j>0;j--)
505  {
506  convertFacCF2nmod_poly_t (M->rows[i-1]+j-1, m (i,j));
507  }
508  }
509 }
510 
511 CFMatrix*
513  const fq_nmod_ctx_t& fq_con,
514  const Variable& alpha)
515 {
516  CFMatrix *res=new CFMatrix(fq_nmod_mat_nrows (m, fq_con),
517  fq_nmod_mat_ncols (m, fq_con));
518  int i,j;
519  for(i=res->rows();i>0;i--)
520  {
521  for(j=res->columns();j>0;j--)
522  {
523  (*res)(i,j)=convertFq_nmod_t2FacCF (fq_nmod_mat_entry (m, i-1, j-1),
524  alpha);
525  }
526  }
527  return res;
528 }
529 #endif
530 
531 #endif
532 
533 
Matrix
Definition: ftmpl_matrix.h:20
convertCF2Fmpq
void convertCF2Fmpq(fmpq_t result, const CanonicalForm &f)
conversion of a factory rationals to fmpq_t
Definition: FLINTconvert.cc:149
MINIMMEDIATE
const long MINIMMEDIATE
Definition: imm.h:54
convertnmod_poly_t2FacCF
CanonicalForm convertnmod_poly_t2FacCF(const nmod_poly_t poly, const Variable &x)
conversion of a FLINT poly over Z/p to CanonicalForm
Definition: FLINTconvert.cc:137
SW_RATIONAL
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:29
isOn
bool isOn(int sw)
switches
Definition: canonicalform.cc:1912
j
int j
Definition: facHensel.cc:105
f
FILE * f
Definition: checklibs.c:9
canonicalform.h
CFIterator
class to iterate through CanonicalForm's
Definition: cf_iter.h:44
x
Variable x
Definition: cfModGcd.cc:4023
convertFacCF2Fmpz_array
void convertFacCF2Fmpz_array(fmpz *result, const CanonicalForm &f)
Definition: FLINTconvert.cc:224
result
return result
Definition: facAbsBiFact.cc:76
convertCF2Fmpz
void convertCF2Fmpz(fmpz_t result, const CanonicalForm &f)
conversion of a factory integer to fmpz_t
Definition: FLINTconvert.cc:61
singext.h
fq_con
fq_nmod_ctx_t fq_con
Definition: facHensel.cc:94
num
CanonicalForm num(const CanonicalForm &f)
Definition: canonicalform.h:330
convertFacCF2Fq_t
void convertFacCF2Fq_t(fq_t result, const CanonicalForm &f, const fq_ctx_t ctx)
conversion of a factory element of F_q (for non-word size p) to a FLINT fq_t
Definition: FLINTconvert.cc:340
convertFq_nmod_t2FacCF
CanonicalForm convertFq_nmod_t2FacCF(const fq_nmod_t poly, const Variable &alpha)
conversion of a FLINT element of F_q to a CanonicalForm with alg. variable alpha
Definition: FLINTconvert.cc:334
power
CanonicalForm power(const CanonicalForm &f, int n)
exponentiation
Definition: canonicalform.cc:1837
MAXIMMEDIATE
const long MAXIMMEDIATE
Definition: imm.h:55
convertFmpz_mat_t2FacCFMatrix
CFMatrix * convertFmpz_mat_t2FacCFMatrix(const fmpz_mat_t m)
conversion of a FLINT matrix over Z to a factory matrix
Definition: FLINTconvert.cc:449
make_cf
CanonicalForm make_cf(const mpz_ptr n)
Definition: singext.cc:66
CFMatrix
Matrix< CanonicalForm > CFMatrix
Definition: canonicalform.h:391
CanonicalForm::isImm
bool isImm() const
Definition: canonicalform.h:107
getCharacteristic
int getCharacteristic()
Definition: cf_char.cc:51
b
CanonicalForm b
Definition: cfModGcd.cc:4044
CanonicalForm
factory's main class
Definition: canonicalform.h:77
CanonicalForm::intval
long intval() const
conversion functions
Definition: canonicalform.cc:197
convertFacCF2nmod_poly_t
void convertFacCF2nmod_poly_t(nmod_poly_t result, const CanonicalForm &f)
conversion of a factory univariate polynomials over Z/p (for word size p) to nmod_poly_t
Definition: FLINTconvert.cc:115
convertFacCF2Fq_nmod_poly_t
void convertFacCF2Fq_nmod_poly_t(fq_nmod_poly_t result, const CanonicalForm &f, const fq_nmod_ctx_t ctx)
conversion of a factory univariate poly over F_q to a FLINT fq_nmod_poly_t
Definition: FLINTconvert.cc:377
fac_util.h
convertFq_nmod_poly_t2FacCF
CanonicalForm convertFq_nmod_poly_t2FacCF(const fq_nmod_poly_t p, const Variable &x, const Variable &alpha, const fq_nmod_ctx_t ctx)
conversion of a FLINT poly over Fq to a CanonicalForm with alg. variable alpha and polynomial variabl...
Definition: FLINTconvert.cc:415
i
int i
Definition: cfEzgcd.cc:125
res
CanonicalForm res
Definition: facAbsFact.cc:64
ASSERT
#define ASSERT(expression, message)
Definition: cf_assert.h:99
convertFmpz2CF
CanonicalForm convertFmpz2CF(const fmpz_t coefficient)
conversion of a FLINT integer to CanonicalForm
Definition: FLINTconvert.cc:82
M
#define M
Definition: sirandom.c:25
buf
int status int void * buf
Definition: si_signals.h:58
convertFLINTFq_nmod_poly_factor2FacCFFList
CFFList convertFLINTFq_nmod_poly_factor2FacCFFList(const fq_nmod_poly_factor_t fac, const Variable &x, const Variable &alpha, const fq_nmod_ctx_t fq_con)
conversion of a FLINT factorization over Fq (for word size p) to a CFFList
Definition: FLINTconvert.cc:267
alpha
Variable alpha
Definition: facAbsBiFact.cc:52
gmpext.h
cf_iter.h
CFFactory::basic
static InternalCF * basic(long value)
Definition: cf_factory.cc:30
cf_algorithm.h
convertFacCFMatrix2Fq_nmod_mat_t
void convertFacCFMatrix2Fq_nmod_mat_t(fq_nmod_mat_t M, const fq_nmod_ctx_t fq_con, const CFMatrix &m)
conversion of a factory matrix over F_q to a fq_nmod_mat_t
Definition: FLINTconvert.cc:497
convertFacCF2Fq_nmod_t
void convertFacCF2Fq_nmod_t(fq_nmod_t result, const CanonicalForm &f, const fq_nmod_ctx_t ctx)
conversion of a factory element of F_q to a FLINT fq_nmod_t, does not do any memory allocation for po...
Definition: FLINTconvert.cc:309
FLINTconvert.h
den
CanonicalForm den(const CanonicalForm &f)
Definition: canonicalform.h:333
convertFLINTnmod_poly_factor2FacCFFList
CFFList convertFLINTnmod_poly_factor2FacCFFList(const nmod_poly_factor_t fac, const mp_limb_t leadingCoeff, const Variable &x)
conversion of a FLINT factorization over Z/p (for word size p) to a CFFList
Definition: FLINTconvert.cc:247
Off
void Off(int sw)
switches
Definition: canonicalform.cc:1905
modpk
class to do operations mod p^k for int's p and k
Definition: fac_util.h:22
Factor
Definition: ftmpl_factor.h:18
convertFacCF2Fmpq_poly_t
void convertFacCF2Fmpq_poly_t(fmpq_poly_t result, const CanonicalForm &f)
conversion of a factory univariate polynomials over Q to fmpq_poly_t
Definition: FLINTconvert.cc:230
STICKYASSERT
#define STICKYASSERT(expression, message)
Definition: cf_assert.h:64
convertFmpz_poly_t2FacCF
CanonicalForm convertFmpz_poly_t2FacCF(const fmpz_poly_t poly, const Variable &x)
conversion of a FLINT poly over Z to CanonicalForm
Definition: FLINTconvert.cc:101
convertFacCF2Fmpz_mod_poly_t
void convertFacCF2Fmpz_mod_poly_t(fmpz_mod_poly_t result, const CanonicalForm &f, const fmpz_t p)
conversion of a factory univariate poly over Z to a FLINT poly over Z/p (for non word size p)
Definition: FLINTconvert.cc:285
bCommonDen
CanonicalForm bCommonDen(const CanonicalForm &f)
CanonicalForm bCommonDen ( const CanonicalForm & f )
Definition: cf_algorithm.cc:293
cf_factory.h
convertFq_nmod_mat_t2FacCFMatrix
CFMatrix * convertFq_nmod_mat_t2FacCFMatrix(const fq_nmod_mat_t m, const fq_nmod_ctx_t &fq_con, const Variable &alpha)
conversion of a FLINT matrix over F_q to a factory matrix
Definition: FLINTconvert.cc:512
convertFmpq_t2CF
CanonicalForm convertFmpq_t2CF(const fmpq_t q)
Definition: FLINTconvert.cc:169
Variable
factory's class for variables
Definition: factory.h:117
convertFmpq_poly_t2FacCF
CanonicalForm convertFmpq_poly_t2FacCF(const fmpq_poly_t p, const Variable &x)
conversion of a FLINT poly over Q to CanonicalForm
Definition: FLINTconvert.cc:204
m
int m
Definition: cfEzgcd.cc:121
SW_SYMMETRIC_FF
static const int SW_SYMMETRIC_FF
set to 1 for symmetric representation over F_q
Definition: cf_defs.h:31
convertFq_poly_t2FacCF
CanonicalForm convertFq_poly_t2FacCF(const fq_poly_t p, const Variable &x, const Variable &alpha, const fq_ctx_t ctx)
conversion of a FLINT poly over Fq (for non-word size p) to a CanonicalForm with alg....
Definition: FLINTconvert.cc:394
gmp_denominator
void gmp_denominator(const CanonicalForm &f, mpz_ptr result)
Definition: singext.cc:40
gmp_numerator
void gmp_numerator(const CanonicalForm &f, mpz_ptr result)
Definition: singext.cc:20
p
int p
Definition: cfModGcd.cc:4019
List
Definition: ftmpl_list.h:20
convertNmod_mat_t2FacCFMatrix
CFMatrix * convertNmod_mat_t2FacCFMatrix(const nmod_mat_t m)
conversion of a FLINT matrix over Z/p to a factory matrix
Definition: FLINTconvert.cc:481
CanonicalForm::mapinto
CanonicalForm mapinto() const
Definition: canonicalform.cc:206
convertFq_t2FacCF
CanonicalForm convertFq_t2FacCF(const fq_t poly, const Variable &alpha)
conversion of a FLINT element of F_q with non-word size p to a CanonicalForm with alg....
Definition: FLINTconvert.cc:353
convertFacCF2Fq_poly_t
void convertFacCF2Fq_poly_t(fq_poly_t result, const CanonicalForm &f, const fq_ctx_t ctx)
conversion of a factory univariate poly over F_q (for non-word size p) to a FLINT fq_poly_t
Definition: FLINTconvert.cc:359
convertFacCF2Fmpz_poly_t
void convertFacCF2Fmpz_poly_t(fmpz_poly_t result, const CanonicalForm &f)
conversion of a factory univariate polynomial over Z to a fmpz_poly_t
Definition: FLINTconvert.cc:74
convertFacCFMatrix2nmod_mat_t
void convertFacCFMatrix2nmod_mat_t(nmod_mat_t M, const CFMatrix &m)
conversion of a factory matrix over Z/p to a nmod_mat_t
Definition: FLINTconvert.cc:463
mpz_is_imm
bool mpz_is_imm(const mpz_t mpi)
Definition: gmpext.h:19
degree
int degree(const CanonicalForm &f)
Definition: canonicalform.h:309
On
void On(int sw)
switches
Definition: canonicalform.cc:1898
convertFacCFMatrix2Fmpz_mat_t
void convertFacCFMatrix2Fmpz_mat_t(fmpz_mat_t M, const CFMatrix &m)
conversion of a factory matrix over Z to a fmpz_mat_t
Definition: FLINTconvert.cc:436
convertFmpz_mod_poly_t2FacCF
CanonicalForm convertFmpz_mod_poly_t2FacCF(const fmpz_mod_poly_t poly, const Variable &x, const modpk &b)
conversion of a FLINT poly over Z/p (for non word size p) to a CanonicalForm over Z
Definition: FLINTconvert.cc:296