Macros | Functions | Variables
clapsing.cc File Reference
#include "misc/auxiliary.h"
#include "clapsing.h"
#include "factory/factory.h"
#include "coeffs/numbers.h"
#include "coeffs/coeffs.h"
#include "coeffs/bigintmat.h"
#include "monomials/ring.h"
#include "simpleideals.h"
#include "ext_fields/transext.h"
#include "clapconv.h"
#include "polys/monomials/p_polys.h"
#include "misc/intvec.h"
#include "polys/matpol.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)
 
poly singclap_gcd_r (poly f, poly g, const ring r)
 
poly singclap_gcd_and_divide (poly &f, poly &g, const ring r)
 clears denominators of f and g, divides by gcd(f,g) More...
 
int pGetExp_Var (poly p, int i, const ring r)
 
poly singclap_resultant (poly f, poly g, poly x, const ring r)
 
BOOLEAN singclap_extgcd (poly f, poly g, poly &res, poly &pa, poly &pb, const ring r)
 
poly singclap_pmult (poly f, poly g, const ring r)
 
poly singclap_pdivide (poly f, poly g, const ring r)
 
poly singclap_pmod (poly f, poly g, const ring r)
 
BOOLEAN count_Factors (ideal I, intvec *v, int j, poly &f, poly fac, const ring r)
 
ideal singclap_factorize (poly f, intvec **v, int with_exps, const ring r)
 
ideal singclap_sqrfree (poly f, intvec **v, int with_exps, const ring r)
 
matrix singclap_irrCharSeries (ideal I, const ring r)
 
char * singclap_neworder (ideal I, const ring r)
 
poly singclap_det (const matrix m, const ring s)
 
int singclap_det_i (intvec *m, const ring)
 
number singclap_det_bi (bigintmat *m, const coeffs cf)
 
matrix singntl_HNF (matrix m, const ring s)
 
intvecsingntl_HNF (intvec *m)
 
bigintmatsingntl_HNF (bigintmat *b)
 
matrix singntl_LLL (matrix m, const ring s)
 
intvecsingntl_LLL (intvec *m)
 
ideal singclap_absFactorize (poly f, ideal &mipos, intvec **exps, int &numFactors, const ring r)
 

Variables

int singclap_factorize_retry
 

Macro Definition Documentation

◆ TRANSEXT_PRIVATES

#define TRANSEXT_PRIVATES

Definition at line 25 of file clapsing.cc.

Function Documentation

◆ count_Factors()

BOOLEAN count_Factors ( ideal  I,
intvec v,
int  j,
poly &  f,
poly  fac,
const ring  r 
)

Definition at line 750 of file clapsing.cc.

751 {
752  p_Test(f,r);
753  p_Test(fac,r);
754  int e=0;
755  if (!p_IsConstantPoly(fac,r))
756  {
757 #ifdef FACTORIZE2_DEBUG
758  printf("start count_Factors(%d), Fdeg=%d, factor deg=%d\n",j,p_Totaldegree(f,r),p_Totaldegree(fac,r));
759  p_wrp(fac,r);PrintLn();
760 #endif
761  On(SW_RATIONAL);
762  CanonicalForm F, FAC,Q,R;
763  Variable a;
764  if (rField_is_Zp(r) || rField_is_Q(r)
765  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
766  {
767  F=convSingPFactoryP( f,r );
768  FAC=convSingPFactoryP( fac,r );
769  }
770  else if (r->cf->extRing!=NULL)
771  {
772  if (r->cf->extRing->qideal!=NULL)
773  {
774  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
775  r->cf->extRing);
776  a=rootOf(mipo);
777  F=convSingAPFactoryAP( f,a,r );
778  FAC=convSingAPFactoryAP( fac,a,r );
779  }
780  else
781  {
782  F=convSingTrPFactoryP( f,r );
783  FAC=convSingTrPFactoryP( fac,r );
784  }
785  }
786  else
788 
789  poly q;
790  loop
791  {
792  Q=F;
793  Q/=FAC;
794  R=Q;
795  R*=FAC;
796  R-=F;
797  if (R.isZero())
798  {
799  if (rField_is_Zp(r) || rField_is_Q(r)
800  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
801  {
802  q = convFactoryPSingP( Q,r );
803  }
804  else if (r->cf->extRing!=NULL)
805  {
806  if (r->cf->extRing->qideal!=NULL)
807  {
808  q= convFactoryAPSingAP( Q,r );
809  }
810  else
811  {
812  q= convFactoryPSingTrP( Q,r );
813  }
814  }
815  e++; p_Delete(&f,r); f=q; q=NULL; F=Q;
816  }
817  else
818  {
819  break;
820  }
821  }
822  if (r->cf->extRing!=NULL)
823  if (r->cf->extRing->qideal!=NULL)
824  prune (a);
825  if (e==0)
826  {
827  Off(SW_RATIONAL);
828  return FALSE;
829  }
830  }
831  else e=1;
832  I->m[j]=fac;
833  if (v!=NULL) (*v)[j]=e;
834  Off(SW_RATIONAL);
835  return TRUE;
836 }
int j
Definition: facHensel.cc:105
void PrintLn()
Definition: reporter.cc:310
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:116
void Off(int sw)
switches
#define FALSE
Definition: auxiliary.h:94
factory's class for variables
Definition: factory.h:117
CF_NO_INLINE bool isZero() const
Definition: cf_inline.cc:372
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:320
factory's main class
Definition: canonicalform.h:77
#define TRUE
Definition: auxiliary.h:98
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1442
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:507
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define Q
Definition: sirandom.c:25
#define loop
Definition: structs.h:80
void prune(Variable &alpha)
Definition: variable.cc:261
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
Variable rootOf(const CanonicalForm &, char name='@')
returns a symbolic root of polynomial with name name Use it to define algebraic variables ...
Definition: variable.cc:162
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
const char feNotImplemented[]
Definition: reporter.cc:54
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
void On(int sw)
switches
FILE * f
Definition: checklibs.c:9
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
#define p_Test(p, r)
Definition: p_polys.h:162
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:856
#define NULL
Definition: omList.c:12
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
CanonicalForm mipo
Definition: facAlgExt.cc:57
#define R
Definition: sirandom.c:26
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
Definition: p_polys.h:1941
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:280
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:151

◆ 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);
166  gmp_denominator(f,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 }
long intval() const
conversion functions
bool isImm() const
CF_NO_INLINE bool isZero() const
Definition: cf_inline.cc:372
char gf_name
Definition: gfops.cc:52
int gf_q
Definition: gfops.cc:47
bool inBaseDomain() const
int m
Definition: cfEzgcd.cc:121
FILE * f
Definition: checklibs.c:9
int i
Definition: cfEzgcd.cc:125
bool inExtension() const
void out_cf(const char *s1, const CanonicalForm &f, const char *s2)
cf_algorithm.cc - simple mathematical algorithms.
Definition: cf_factor.cc:90
class to iterate through CanonicalForm&#39;s
Definition: cf_iter.h:44
static long imm2int(const InternalCF *const imm)
Definition: imm.h:70
void gmp_numerator(const CanonicalForm &f, mpz_ptr result)
Definition: singext.cc:20
static int gettype()
Definition: cf_factory.h:28
bool inQ() const
bool inZ() const
predicates
#define GaloisFieldDomain
Definition: cf_defs.h:22
int level() const
level() returns the level of CO.
InternalCF * getval() const
int l
Definition: cfEzgcd.cc:93
void gmp_denominator(const CanonicalForm &f, mpz_ptr result)
Definition: singext.cc:40

◆ pGetExp_Var()

int pGetExp_Var ( poly  p,
int  i,
const ring  r 
)

Definition at line 263 of file clapsing.cc.

264 {
265  int m=0;
266  int mm;
267  while (p!=NULL)
268  {
269  mm=p_GetExp(p,i,r);
270  if (mm>m) m=mm;
271  pIter(p);
272  }
273  return m;
274 }
#define pIter(p)
Definition: monomials.h:37
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:468
int m
Definition: cfEzgcd.cc:121
int i
Definition: cfEzgcd.cc:125
#define NULL
Definition: omList.c:12
int p
Definition: cfModGcd.cc:4019

◆ singclap_absFactorize()

ideal singclap_absFactorize ( poly  f,
ideal &  mipos,
intvec **  exps,
int &  numFactors,
const ring  r 
)

Definition at line 1851 of file clapsing.cc.

1852 {
1853  p_Test(f, r);
1854 
1855  ideal res=NULL;
1856 
1857  int offs = rPar(r);
1858  if (f==NULL)
1859  {
1860  res= idInit (1, 1);
1861  mipos= idInit (1, 1);
1862  mipos->m[0]= convFactoryPSingTrP (Variable (offs), r); //overkill
1863  (*exps)=new intvec (1);
1864  (**exps)[0]= 1;
1865  numFactors= 0;
1866  return res;
1867  }
1869 
1870  bool isRat= isOn (SW_RATIONAL);
1871  if (!isRat)
1872  On (SW_RATIONAL);
1873 
1874  CFAFList absFactors= absFactorize (F);
1875 
1876  int n= absFactors.length();
1877  *exps=new intvec (n);
1878 
1879  res= idInit (n, 1);
1880 
1881  mipos= idInit (n, 1);
1882 
1883  Variable x= Variable (offs);
1884  Variable alpha;
1885  int i= 0;
1886  numFactors= 0;
1887  int count;
1888  CFAFListIterator iter= absFactors;
1889  CanonicalForm lead= iter.getItem().factor();
1890  if (iter.getItem().factor().inCoeffDomain())
1891  {
1892  i++;
1893  iter++;
1894  }
1895  for (; iter.hasItem(); iter++, i++)
1896  {
1897  (**exps)[i]= iter.getItem().exp();
1898  alpha= iter.getItem().minpoly().mvar();
1899  if (iter.getItem().minpoly().isOne())
1900  lead /= power (bCommonDen (iter.getItem().factor()), iter.getItem().exp());
1901  else
1902  lead /= power (power (bCommonDen (iter.getItem().factor()), degree (iter.getItem().minpoly())), iter.getItem().exp());
1903  res->m[i]= convFactoryPSingTrP (replacevar (iter.getItem().factor()*bCommonDen (iter.getItem().factor()), alpha, x), r);
1904  if (iter.getItem().minpoly().isOne())
1905  {
1906  count= iter.getItem().exp();
1907  mipos->m[i]= convFactoryPSingTrP (x,r);
1908  }
1909  else
1910  {
1911  count= iter.getItem().exp()*degree (iter.getItem().minpoly());
1912  mipos->m[i]= convFactoryPSingTrP (replacevar (iter.getItem().minpoly(), alpha, x), r);
1913  }
1914  if (!iter.getItem().minpoly().isOne())
1915  prune (alpha);
1916  numFactors += count;
1917  }
1918  if (!isRat)
1919  Off (SW_RATIONAL);
1920 
1921  (**exps)[0]= 1;
1922  res->m[0]= convFactoryPSingTrP (lead, r);
1923  mipos->m[0]= convFactoryPSingTrP (x, r);
1924  return res;
1925 }
int status int void size_t count
Definition: si_signals.h:59
CanonicalForm power(const CanonicalForm &f, int n)
exponentiation
void Off(int sw)
switches
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:593
factory&#39;s class for variables
Definition: factory.h:117
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
CFFListIterator iter
Definition: facAbsBiFact.cc:54
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:320
factory&#39;s main class
Definition: canonicalform.h:77
Variable alpha
Definition: facAbsBiFact.cc:52
void prune(Variable &alpha)
Definition: variable.cc:261
Definition: intvec.h:19
CanonicalForm res
Definition: facAbsFact.cc:64
T & getItem() const
Definition: ftmpl_list.cc:431
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
bool isOn(int sw)
switches
void On(int sw)
switches
FILE * f
Definition: checklibs.c:9
int i
Definition: cfEzgcd.cc:125
CanonicalForm bCommonDen(const CanonicalForm &f)
CanonicalForm bCommonDen ( const CanonicalForm & f )
#define p_Test(p, r)
Definition: p_polys.h:162
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define NULL
Definition: omList.c:12
int length() const
Definition: ftmpl_list.cc:273
Variable x
Definition: cfModGcd.cc:4023
int degree(const CanonicalForm &f)
CFAFList absFactorize(const CanonicalForm &G)
absolute factorization of a multivariate poly over Q
Definition: facAbsFact.cc:267
CanonicalForm replacevar(const CanonicalForm &, const Variable &, const Variable &)
CanonicalForm replacevar ( const CanonicalForm & f, const Variable & x1, const Variable & x2 ) ...
Definition: cf_ops.cc:271

◆ singclap_det()

poly singclap_det ( const matrix  m,
const ring  s 
)

Definition at line 1637 of file clapsing.cc.

1638 {
1639  int r=m->rows();
1640  if (r!=m->cols())
1641  {
1642  Werror("det of %d x %d matrix",r,m->cols());
1643  return NULL;
1644  }
1645  poly res=NULL;
1646  CFMatrix M(r,r);
1647  int i,j;
1648  for(i=r;i>0;i--)
1649  {
1650  for(j=r;j>0;j--)
1651  {
1652  M(i,j)=convSingPFactoryP(MATELEM(m,i,j),s);
1653  }
1654  }
1655  res= convFactoryPSingP( determinant(M,r),s ) ;
1656  Off(SW_RATIONAL);
1657  return res;
1658 }
int & rows()
Definition: matpol.h:23
const CanonicalForm int s
Definition: facAbsFact.cc:55
int j
Definition: facHensel.cc:105
void Off(int sw)
switches
#define M
Definition: sirandom.c:24
CanonicalForm res
Definition: facAbsFact.cc:64
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
int i
Definition: cfEzgcd.cc:125
int & cols()
Definition: matpol.h:24
#define NULL
Definition: omList.c:12
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
CanonicalForm determinant(const CFMatrix &M, int n)
Definition: cf_linsys.cc:222
void Werror(const char *fmt,...)
Definition: reporter.cc:189
#define MATELEM(mat, i, j)
1-based access to matrix
Definition: matpol.h:29

◆ singclap_det_bi()

number singclap_det_bi ( bigintmat m,
const coeffs  cf 
)

Definition at line 1678 of file clapsing.cc.

1679 {
1680  assume(m->basecoeffs()==cf);
1681  CFMatrix M(m->rows(),m->cols());
1682  int i,j;
1683  BOOLEAN setchar=TRUE;
1684  for(i=m->rows();i>0;i--)
1685  {
1686  for(j=m->cols();j>0;j--)
1687  {
1688  M(i,j)=n_convSingNFactoryN(BIMATELEM(*m,i,j),setchar,cf);
1689  setchar=FALSE;
1690  }
1691  }
1692  number res=n_convFactoryNSingN( determinant(M,m->rows()),cf ) ;
1693  return res;
1694 }
int j
Definition: facHensel.cc:105
#define FALSE
Definition: auxiliary.h:94
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:621
int rows() const
Definition: bigintmat.h:145
#define TRUE
Definition: auxiliary.h:98
CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: numbers.cc:626
#define M
Definition: sirandom.c:24
CanonicalForm res
Definition: facAbsFact.cc:64
#define assume(x)
Definition: mod2.h:390
int cols() const
Definition: bigintmat.h:144
int i
Definition: cfEzgcd.cc:125
#define BIMATELEM(M, I, J)
Definition: bigintmat.h:133
CanonicalForm cf
Definition: cfModGcd.cc:4024
coeffs basecoeffs() const
Definition: bigintmat.h:146
CanonicalForm determinant(const CFMatrix &M, int n)
Definition: cf_linsys.cc:222
int BOOLEAN
Definition: auxiliary.h:85

◆ singclap_det_i()

int singclap_det_i ( intvec m,
const ring   
)

Definition at line 1660 of file clapsing.cc.

1661 {
1662 // assume( r == currRing ); // Anything else is not guaranted to work!
1663 
1664  setCharacteristic( 0 ); // ?
1665  CFMatrix M(m->rows(),m->cols());
1666  int i,j;
1667  for(i=m->rows();i>0;i--)
1668  {
1669  for(j=m->cols();j>0;j--)
1670  {
1671  M(i,j)=IMATELEM(*m,i,j);
1672  }
1673  }
1674  int res= convFactoryISingI( determinant(M,m->rows()) ) ;
1675  return res;
1676 }
int j
Definition: facHensel.cc:105
int rows() const
Definition: intvec.h:96
void setCharacteristic(int c)
Definition: cf_char.cc:23
#define M
Definition: sirandom.c:24
int convFactoryISingI(const CanonicalForm &f)
Definition: clapconv.cc:110
CanonicalForm res
Definition: facAbsFact.cc:64
int i
Definition: cfEzgcd.cc:125
CanonicalForm determinant(const CFMatrix &M, int n)
Definition: cf_linsys.cc:222
int cols() const
Definition: intvec.h:95
#define IMATELEM(M, I, J)
Definition: intvec.h:85

◆ singclap_extgcd()

BOOLEAN singclap_extgcd ( poly  f,
poly  g,
poly &  res,
poly &  pa,
poly &  pb,
const ring  r 
)

Definition at line 421 of file clapsing.cc.

422 {
423  // for now there is only the possibility to handle univariate
424  // polynomials over
425  // Q and Fp ...
426  res=NULL;pa=NULL;pb=NULL;
428  if ( rField_is_Q(r) || rField_is_Zp(r)
429  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
430  {
431  setCharacteristic( rChar(r) );
433  CanonicalForm FpG=F+G;
434  if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
435  //if (!F.isUnivariate() || !G.isUnivariate() || F.mvar()!=G.mvar())
436  {
437  Off(SW_RATIONAL);
438  WerrorS("not univariate");
439  return TRUE;
440  }
441  CanonicalForm Fa,Gb;
442  On(SW_RATIONAL);
443  res=convFactoryPSingP( extgcd( F, G, Fa, Gb ),r );
444  pa=convFactoryPSingP(Fa,r);
445  pb=convFactoryPSingP(Gb,r);
446  Off(SW_RATIONAL);
447  }
448  // and over Q(a) / Fp(a)
449  else if ( r->cf->extRing!=NULL )
450  {
451  if (rField_is_Q_a(r)) setCharacteristic( 0 );
452  else setCharacteristic( rChar(r) );
453  CanonicalForm Fa,Gb;
454  if (r->cf->extRing->qideal!=NULL)
455  {
456  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
457  r->cf->extRing);
458  Variable a=rootOf(mipo);
459  CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
460  G( convSingAPFactoryAP( g,a,r ) );
461  CanonicalForm FpG=F+G;
462  if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
463  //if (!F.isUnivariate() || !G.isUnivariate() || F.mvar()!=G.mvar())
464  {
465  WerrorS("not univariate");
466  return TRUE;
467  }
468  res= convFactoryAPSingAP( extgcd( F, G, Fa, Gb ),r );
469  pa=convFactoryAPSingAP(Fa,r);
470  pb=convFactoryAPSingAP(Gb,r);
471  prune (a);
472  }
473  else
474  {
476  CanonicalForm FpG=F+G;
477  if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
478  //if (!F.isUnivariate() || !G.isUnivariate() || F.mvar()!=G.mvar())
479  {
480  Off(SW_RATIONAL);
481  WerrorS("not univariate");
482  return TRUE;
483  }
484  res= convFactoryPSingTrP( extgcd( F, G, Fa, Gb ), r );
485  pa=convFactoryPSingTrP(Fa, r);
486  pb=convFactoryPSingTrP(Gb, r);
487  }
488  Off(SW_RATIONAL);
489  }
490  else
491  {
493  return TRUE;
494  }
495 #ifndef SING_NDEBUG
496  // checking the result of extgcd:
497  poly dummy;
498  dummy=p_Sub(p_Add_q(pp_Mult_qq(f,pa,r),pp_Mult_qq(g,pb,r),r),p_Copy(res,r),r);
499  if (dummy!=NULL)
500  {
501  PrintS("extgcd( ");p_Write(f,r);p_Write0(g,r);PrintS(" )\n");
502  PrintS("extgcd( ");p_Write(f,r);p_Write0(g,r);PrintS(" )\n");
503  p_Delete(&dummy,r);
504  }
505 #endif
506  return FALSE;
507 }
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:116
void Off(int sw)
switches
CanonicalForm extgcd(const CanonicalForm &f, const CanonicalForm &g, CanonicalForm &a, CanonicalForm &b)
CanonicalForm extgcd ( const CanonicalForm & f, const CanonicalForm & g, CanonicalForm & a...
Definition: cfUnivarGcd.cc:173
#define FALSE
Definition: auxiliary.h:94
factory&#39;s class for variables
Definition: factory.h:117
int rChar(ring r)
Definition: ring.cc:713
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:320
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:534
factory&#39;s main class
Definition: canonicalform.h:77
#define TRUE
Definition: auxiliary.h:98
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:507
g
Definition: cfModGcd.cc:4031
void WerrorS(const char *s)
Definition: feFopen.cc:24
static TreeM * G
Definition: janet.cc:31
poly p_Sub(poly p1, poly p2, const ring r)
Definition: p_polys.cc:1965
void setCharacteristic(int c)
Definition: cf_char.cc:23
BOOLEAN pb(leftv res, leftv args)
Definition: cohomo.cc:4373
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:811
void prune(Variable &alpha)
Definition: variable.cc:261
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
Variable rootOf(const CanonicalForm &, char name='@')
returns a symbolic root of polynomial with name name Use it to define algebraic variables ...
Definition: variable.cc:162
CanonicalForm res
Definition: facAbsFact.cc:64
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition: p_polys.h:1086
bool isUnivariate() const
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
const char feNotImplemented[]
Definition: reporter.cc:54
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
void On(int sw)
switches
FILE * f
Definition: checklibs.c:9
void PrintS(const char *s)
Definition: reporter.cc:284
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:239
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:856
#define NULL
Definition: omList.c:12
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
CanonicalForm mipo
Definition: facAlgExt.cc:57
BOOLEAN pa(leftv res, leftv args)
Definition: cohomo.cc:4346
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:249
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:151
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:891
static const int SW_SYMMETRIC_FF
set to 1 for symmetric representation over F_q
Definition: cf_defs.h:30
bool inCoeffDomain() const

◆ singclap_factorize()

ideal singclap_factorize ( poly  f,
intvec **  v,
int  with_exps,
const ring  r 
)

Definition at line 840 of file clapsing.cc.

842 {
843  p_Test(f,r);
844 #ifdef FACTORIZE2_DEBUG
845  printf("singclap_factorize, degree %ld\n",p_Totaldegree(f,r));
846 #endif
847  // with_exps: 3,1 return only true factors, no exponents
848  // 2 return true factors and exponents
849  // 0 return coeff, factors and exponents
850  BOOLEAN save_errorreported=errorreported;
851 
852  ideal res=NULL;
853 
854  // handle factorize(0) =========================================
855  if (f==NULL)
856  {
857  res=idInit(1,1);
858  if (with_exps!=1)
859  {
860  (*v)=new intvec(1);
861  (**v)[0]=1;
862  }
863  return res;
864  }
865  // handle factorize(mon) =========================================
866  if (pNext(f)==NULL)
867  {
868  int i=0;
869  int n=0;
870  int e;
871  for(i=rVar(r);i>0;i--) if(p_GetExp(f,i,r)!=0) n++;
872  if (with_exps==0) n++; // with coeff
873  res=idInit(si_max(n,1),1);
874  switch(with_exps)
875  {
876  case 0: // with coef & exp.
877  res->m[0]=p_NSet(n_Copy(pGetCoeff(f),r->cf),r);
878  // no break
879  case 2: // with exp.
880  (*v)=new intvec(si_max(1,n));
881  (**v)[0]=1;
882  // no break
883  case 1: ;
884 #ifdef TEST
885  default: ;
886 #endif
887  }
888  if (n==0)
889  {
890  if (res->m[0]==NULL) res->m[0]=p_One(r);
891  // (**v)[0]=1; is already done
892  }
893  else
894  {
895  for(i=rVar(r);i>0;i--)
896  {
897  e=p_GetExp(f,i,r);
898  if(e!=0)
899  {
900  n--;
901  poly p=p_One(r);
902  p_SetExp(p,i,1,r);
903  p_Setm(p,r);
904  res->m[n]=p;
905  if (with_exps!=1) (**v)[n]=e;
906  }
907  }
908  }
909  p_Delete(&f,r);
910  return res;
911  }
912  //PrintS("S:");p_Write(f,r);PrintLn();
913  // use factory/libfac in general ==============================
914  Variable dummy(-1); prune(dummy); // remove all (tmp.) extensions
915  Off(SW_RATIONAL);
917  CFFList L;
918  number N=NULL;
919  number NN=NULL;
920  number old_lead_coeff=n_Copy(pGetCoeff(f), r->cf);
921 
922  Variable a;
923  if (!rField_is_Zp(r) && !rField_is_Zp_a(r) && !rField_is_Z(r)
924  && !(rField_is_Zn(r) && (r->cf->convSingNFactoryN!=ndConvSingNFactoryN))) /* Q, Q(a) */
925  {
926  //if (f!=NULL) // already tested at start of routine
927  {
928  number n0=n_Copy(pGetCoeff(f),r->cf);
929  if (with_exps==0)
930  N=n_Copy(n0,r->cf);
931  p_Cleardenom(f, r);
932  //after here f should not have a denominator!!
933  //PrintS("S:");p_Write(f,r);PrintLn();
934  NN=n_Div(n0,pGetCoeff(f),r->cf);
935  n_Delete(&n0,r->cf);
936  if (with_exps==0)
937  {
938  n_Delete(&N,r->cf);
939  N=n_Copy(NN,r->cf);
940  }
941  }
942  }
943  else if (rField_is_Zp_a(r))
944  {
945  //if (f!=NULL) // already tested at start of routine
947  {
948  number n0=n_Copy(pGetCoeff(f),r->cf);
949  if (with_exps==0)
950  N=n_Copy(n0,r->cf);
951  p_Norm(f,r);
952  p_Cleardenom(f, r);
953  NN=n_Div(n0,pGetCoeff(f),r->cf);
954  n_Delete(&n0,r->cf);
955  if (with_exps==0)
956  {
957  n_Delete(&N,r->cf);
958  N=n_Copy(NN,r->cf);
959  }
960  }
961  }
962  if ((rField_is_Q(r) || rField_is_Zp(r) || (rField_is_Z(r)))
963  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
964  {
965  setCharacteristic( rChar(r) );
967  L = factorize( F );
968  }
969  // and over Q(a) / Fp(a)
970  else if ((r->cf->extRing!=NULL)
971  &&(r->cf->extRing->cf->convSingNFactoryN!=ndConvSingNFactoryN))
972  {
973  if (rField_is_Q_a (r)) setCharacteristic (0);
974  else setCharacteristic( rChar(r) );
975  if (r->cf->extRing->qideal!=NULL)
976  {
977  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
978  r->cf->extRing);
979  a=rootOf(mipo);
980  CanonicalForm F( convSingAPFactoryAP( f, a, r ) );
981  if (rField_is_Zp_a(r))
982  {
983  L = factorize( F, a );
984  }
985  else
986  {
987  // over Q(a)
988  L= factorize (F, a);
989  }
990  prune(a);
991  }
992  else
993  {
995  L = factorize( F );
996  }
997  }
998  else
999  {
1000  goto notImpl;
1001  }
1002  {
1003  poly ff=p_Copy(f,r); // a copy for the retry stuff
1004  // the first factor should be a constant
1005  if ( ! L.getFirst().factor().inCoeffDomain() )
1006  L.insert(CFFactor(1,1));
1007  // convert into ideal
1008  int n = L.length();
1009  if (n==0) n=1;
1010  CFFListIterator J=L;
1011  int j=0;
1012  if (with_exps!=1)
1013  {
1014  if ((with_exps==2)&&(n>1))
1015  {
1016  n--;
1017  J++;
1018  }
1019  *v = new intvec( n );
1020  }
1021  res = idInit( n ,1);
1022  for ( ; J.hasItem(); J++, j++ )
1023  {
1024  if (with_exps!=1) (**v)[j] = J.getItem().exp();
1025  if (rField_is_Zp(r) || rField_is_Q(r)|| rField_is_Z(r)
1026  || (rField_is_Zn(r) && r->cf->convSingNFactoryN!=ndConvSingNFactoryN)) /* Q, Fp, Z */
1027  {
1028  //count_Factors(res,*v,f, j, convFactoryPSingP( J.getItem().factor() );
1029  res->m[j] = convFactoryPSingP( J.getItem().factor(),r );
1030  }
1031 #if 0
1032  else if (rField_is_GF())
1033  res->m[j] = convFactoryGFSingGF( J.getItem().factor() );
1034 #endif
1035  else if (r->cf->extRing!=NULL) /* Q(a), Fp(a) */
1036  {
1037 #ifndef SING_NDEBUG
1038  intvec *w=NULL;
1039  if (v!=NULL) w=*v;
1040 #endif
1041  if (r->cf->extRing->qideal==NULL)
1042  {
1043 #ifdef SING_NDEBUG
1044  res->m[j]= convFactoryPSingTrP( J.getItem().factor(),r );
1045 #else
1046  if(!count_Factors(res,w,j,ff,convFactoryPSingTrP( J.getItem().factor(),r ),r))
1047  {
1048  if (w!=NULL)
1049  (*w)[j]=1;
1050  res->m[j]=p_One(r);
1051  }
1052 #endif
1053  }
1054  else
1055  {
1056 #ifdef SING_NDEBUG
1057  res->m[j]= convFactoryAPSingAP( J.getItem().factor(),r );
1058 #else
1059  if (!count_Factors(res,w,j,ff,convFactoryAPSingAP( J.getItem().factor(),r ),r))
1060  {
1061  if (w!=NULL)
1062  (*w)[j]=1;
1063  res->m[j]=p_One(r);
1064  }
1065 #endif
1066  }
1067  }
1068  }
1069  if (r->cf->extRing!=NULL)
1070  if (r->cf->extRing->qideal!=NULL)
1071  prune (a);
1072 #ifndef SING_NDEBUG
1073  if ((r->cf->extRing!=NULL) && (!p_IsConstantPoly(ff,r)))
1074  {
1077  {
1078  int jj;
1079 #ifdef FACTORIZE2_DEBUG
1080  printf("factorize_retry\n");
1081 #endif
1082  intvec *ww=NULL;
1083  id_Test(res,r);
1084  ideal h=singclap_factorize ( ff, &ww , with_exps, r );
1085  id_Test(h,r);
1086  int l=(*v)->length();
1087  (*v)->resize(l+ww->length());
1088  for(jj=0;jj<ww->length();jj++)
1089  (**v)[jj+l]=(*ww)[jj];
1090  delete ww;
1091  ideal hh=idInit(IDELEMS(res)+IDELEMS(h),1);
1092  for(jj=IDELEMS(res)-1;jj>=0;jj--)
1093  {
1094  hh->m[jj]=res->m[jj];
1095  res->m[jj]=NULL;
1096  }
1097  for(jj=IDELEMS(h)-1;jj>=0;jj--)
1098  {
1099  hh->m[jj+IDELEMS(res)]=h->m[jj];
1100  h->m[jj]=NULL;
1101  }
1102  id_Delete(&res,r);
1103  id_Delete(&h,r);
1104  res=hh;
1105  id_Test(res,r);
1106  ff=NULL;
1107  }
1108  else
1109  {
1110  WarnS("problem with factorize");
1111 #if 0
1112  pWrite(ff);
1113  idShow(res);
1114 #endif
1115  id_Delete(&res,r);
1116  res=idInit(2,1);
1117  res->m[0]=p_One(r);
1118  res->m[1]=ff; ff=NULL;
1119  }
1120  }
1121 #endif
1122  p_Delete(&ff,r);
1123  if (N!=NULL)
1124  {
1125  __p_Mult_nn(res->m[0],N,r);
1126  n_Delete(&N,r->cf);
1127  N=NULL;
1128  }
1129  // delete constants
1130  if (res!=NULL)
1131  {
1132  int i=IDELEMS(res)-1;
1133  int j=0;
1134  for(;i>=0;i--)
1135  {
1136  if ((res->m[i]!=NULL)
1137  && (pNext(res->m[i])==NULL)
1138  && (p_IsConstant(res->m[i],r)))
1139  {
1140  if (with_exps!=0)
1141  {
1142  p_Delete(&(res->m[i]),r);
1143  if ((v!=NULL) && ((*v)!=NULL))
1144  (**v)[i]=0;
1145  j++;
1146  }
1147  else if (i!=0)
1148  {
1149  while ((v!=NULL) && ((*v)!=NULL) && ((**v)[i]>1))
1150  {
1151  res->m[0]=p_Mult_q(res->m[0],p_Copy(res->m[i],r),r);
1152  (**v)[i]--;
1153  }
1154  res->m[0]=p_Mult_q(res->m[0],res->m[i],r);
1155  res->m[i]=NULL;
1156  if ((v!=NULL) && ((*v)!=NULL))
1157  (**v)[i]=1;
1158  j++;
1159  }
1160  }
1161  }
1162  if (j>0)
1163  {
1164  idSkipZeroes(res);
1165  if ((v!=NULL) && ((*v)!=NULL))
1166  {
1167  intvec *w=*v;
1168  int len=IDELEMS(res);
1169  *v = new intvec( len );
1170  for (i=0,j=0;i<si_min(w->length(),len);i++)
1171  {
1172  if((*w)[i]!=0)
1173  {
1174  (**v)[j]=(*w)[i]; j++;
1175  }
1176  }
1177  delete w;
1178  }
1179  }
1180  if (res->m[0]==NULL)
1181  {
1182  res->m[0]=p_One(r);
1183  }
1184  }
1185  }
1186  if (rField_is_Q_a(r) && (r->cf->extRing->qideal!=NULL))
1187  {
1188  int i=IDELEMS(res)-1;
1189  int stop=1;
1190  if (with_exps!=0) stop=0;
1191  for(;i>=stop;i--)
1192  {
1193  p_Norm(res->m[i],r);
1194  }
1195  if (with_exps==0) p_SetCoeff(res->m[0],old_lead_coeff,r);
1196  else n_Delete(&old_lead_coeff,r->cf);
1197  }
1198  else
1199  n_Delete(&old_lead_coeff,r->cf);
1200  errorreported=save_errorreported;
1201 notImpl:
1202  prune(a);
1203  if (res==NULL)
1205  if (NN!=NULL)
1206  {
1207  n_Delete(&NN,r->cf);
1208  }
1209  if (N!=NULL)
1210  {
1211  n_Delete(&N,r->cf);
1212  }
1213  if (f!=NULL) p_Delete(&f,r);
1214  //PrintS("......S\n");
1215  return res;
1216 }
int j
Definition: facHensel.cc:105
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:116
void Off(int sw)
switches
static BOOLEAN rField_is_Zp_a(const ring r)
Definition: ring.h:524
static int si_min(const int a, const int b)
Definition: auxiliary.h:139
factory&#39;s class for variables
Definition: factory.h:117
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1455
#define id_Test(A, lR)
Definition: simpleideals.h:79
int rChar(ring r)
Definition: ring.cc:713
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:586
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:320
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:534
factory&#39;s main class
Definition: canonicalform.h:77
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1442
void pWrite(poly p)
Definition: polys.h:303
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:507
void WerrorS(const char *s)
Definition: feFopen.cc:24
static BOOLEAN rField_is_GF(const ring r)
Definition: ring.h:516
static BOOLEAN rField_is_Z(const ring r)
Definition: ring.h:504
void p_Norm(poly p1, const ring r)
Definition: p_polys.cc:3679
void insert(const T &)
Definition: ftmpl_list.cc:193
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 WarnS
Definition: emacs.cc:78
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:411
void setCharacteristic(int c)
Definition: cf_char.cc:23
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:811
void prune(Variable &alpha)
Definition: variable.cc:261
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)
Definition: simpleideals.cc:57
T getFirst() const
Definition: ftmpl_list.cc:279
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
Variable rootOf(const CanonicalForm &, char name='@')
returns a symbolic root of polynomial with name name Use it to define algebraic variables ...
Definition: variable.cc:162
BOOLEAN count_Factors(ideal I, intvec *v, int j, poly &f, poly fac, const ring r)
Definition: clapsing.cc:750
CFFList factorize(const CanonicalForm &f, bool issqrfree=false)
factorization over or
Definition: cf_factor.cc:390
Definition: intvec.h:19
CanonicalForm res
Definition: facAbsFact.cc:64
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
poly p_One(const ring r)
Definition: p_polys.cc:1303
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:468
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1927
T & getItem() const
Definition: ftmpl_list.cc:431
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
const char feNotImplemented[]
Definition: reporter.cc:54
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
void On(int sw)
switches
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
FILE * f
Definition: checklibs.c:9
int i
Definition: cfEzgcd.cc:125
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
#define IDELEMS(i)
Definition: simpleideals.h:23
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
#define p_Test(p, r)
Definition: p_polys.h:162
short errorreported
Definition: feFopen.cc:23
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:856
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
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:487
#define __p_Mult_nn(p, n, r)
Definition: p_polys.h:926
#define NULL
Definition: omList.c:12
int length() const
Definition: ftmpl_list.cc:273
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
int length() const
Definition: intvec.h:94
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:451
CanonicalForm mipo
Definition: facAlgExt.cc:57
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:615
const CanonicalForm & w
Definition: facAbsFact.cc:55
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
Definition: p_polys.h:1941
#define pNext(p)
Definition: monomials.h:36
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:232
int singclap_factorize_retry
Definition: clapsing.cc:838
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:455
ideal singclap_factorize(poly f, intvec **v, int with_exps, const ring r)
Definition: clapsing.cc:840
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:151
int p
Definition: cfModGcd.cc:4019
static const int SW_SYMMETRIC_FF
set to 1 for symmetric representation over F_q
Definition: cf_defs.h:30
static Poly * h
Definition: janet.cc:971
int BOOLEAN
Definition: auxiliary.h:85
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2791
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1049
int l
Definition: cfEzgcd.cc:93

◆ singclap_gcd_and_divide()

poly singclap_gcd_and_divide ( poly &  f,
poly &  g,
const ring  r 
)

clears denominators of f and g, divides by gcd(f,g)

Definition at line 102 of file clapsing.cc.

103 {
104  poly res=NULL;
105 
106  if (g == NULL)
107  {
108  res= f;
109  f=p_One (r);
110  return res;
111  }
112  if (f==NULL)
113  {
114  res= g;
115  g=p_One (r);
116  return res;
117  }
118  if (pNext(g)==NULL)
119  {
120  poly G=p_GcdMon(g,f,r);
121  if (!n_IsOne(pGetCoeff(G),r->cf)
122  || (!p_IsConstant(G,r)))
123  {
124  f=p_Div_mm(f,G,r);
125  g=p_Div_mm(g,G,r);
126  }
127  return G;
128  }
129  else if (pNext(f)==NULL)
130  {
131  poly G=p_GcdMon(f,g,r);
132  if (!n_IsOne(pGetCoeff(G),r->cf)
133  || (!p_IsConstant(G,r)))
134  {
135  f=p_Div_mm(f,G,r);
136  g=p_Div_mm(g,G,r);
137  }
138  return G;
139  }
140 
141  Off(SW_RATIONAL);
142  CanonicalForm F,G,GCD;
143  if (rField_is_Q(r) || (rField_is_Zp(r))
144  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
145  {
146  bool b1=isOn(SW_USE_EZGCD_P);
147  setCharacteristic( rChar(r) );
148  F=convSingPFactoryP( f,r );
149  G=convSingPFactoryP( g,r );
150  GCD=gcd(F,G);
151  if (!GCD.isOne())
152  {
153  p_Delete(&f,r);
154  p_Delete(&g,r);
155  if (getCharacteristic() == 0)
156  On (SW_RATIONAL);
157  F /= GCD;
158  G /= GCD;
159  if (getCharacteristic() == 0)
160  {
161  CanonicalForm denF= bCommonDen (F);
162  CanonicalForm denG= bCommonDen (G);
163  G *= denG;
164  F *= denF;
165  Off (SW_RATIONAL);
166  CanonicalForm gcddenFdenG= gcd (denG, denF);
167  denG /= gcddenFdenG;
168  denF /= gcddenFdenG;
169  On (SW_RATIONAL);
170  G *= denF;
171  F *= denG;
172  }
173  f=convFactoryPSingP( F, r);
174  g=convFactoryPSingP( G, r);
175  }
176  res=convFactoryPSingP( GCD , r);
177  if (!b1) Off (SW_USE_EZGCD_P);
178  }
179  // and over Q(a) / Fp(a)
180  else if ( r->cf->extRing )
181  {
182  if ( rField_is_Q_a(r)) setCharacteristic( 0 );
183  else setCharacteristic( rChar(r) );
184  if (r->cf->extRing->qideal!=NULL)
185  {
186  bool b1=isOn(SW_USE_QGCD);
187  if ( rField_is_Q_a(r) ) On(SW_USE_QGCD);
188  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
189  r->cf->extRing);
190  Variable a=rootOf(mipo);
191  F=( convSingAPFactoryAP( f,a,r ) );
192  G=( convSingAPFactoryAP( g,a,r ) );
193  GCD=gcd(F,G);
194  if (!GCD.isOne())
195  {
196  p_Delete(&f,r);
197  p_Delete(&g,r);
198  if (getCharacteristic() == 0)
199  On (SW_RATIONAL);
200  F /= GCD;
201  G /= GCD;
202  if (getCharacteristic() == 0)
203  {
204  CanonicalForm denF= bCommonDen (F);
205  CanonicalForm denG= bCommonDen (G);
206  G *= denG;
207  F *= denF;
208  Off (SW_RATIONAL);
209  CanonicalForm gcddenFdenG= gcd (denG, denF);
210  denG /= gcddenFdenG;
211  denF /= gcddenFdenG;
212  On (SW_RATIONAL);
213  G *= denF;
214  F *= denG;
215  }
216  f= convFactoryAPSingAP( F,r );
217  g= convFactoryAPSingAP( G,r );
218  }
219  res= convFactoryAPSingAP( GCD,r );
220  prune (a);
221  if (!b1) Off(SW_USE_QGCD);
222  }
223  else
224  {
225  F=( convSingTrPFactoryP( f,r ) );
226  G=( convSingTrPFactoryP( g,r ) );
227  GCD=gcd(F,G);
228  if (!GCD.isOne())
229  {
230  p_Delete(&f,r);
231  p_Delete(&g,r);
232  if (getCharacteristic() == 0)
233  On (SW_RATIONAL);
234  F /= GCD;
235  G /= GCD;
236  if (getCharacteristic() == 0)
237  {
238  CanonicalForm denF= bCommonDen (F);
239  CanonicalForm denG= bCommonDen (G);
240  G *= denG;
241  F *= denF;
242  Off (SW_RATIONAL);
243  CanonicalForm gcddenFdenG= gcd (denG, denF);
244  denG /= gcddenFdenG;
245  denF /= gcddenFdenG;
246  On (SW_RATIONAL);
247  G *= denF;
248  F *= denG;
249  }
250  f= convFactoryPSingTrP( F,r );
251  g= convFactoryPSingTrP( G,r );
252  }
253  res= convFactoryPSingTrP( GCD,r );
254  }
255  }
256  else
258  Off(SW_RATIONAL);
259  return res;
260 }
CF_NO_INLINE bool isOne() const
CF_INLINE bool CanonicalForm::isOne, isZero () const.
Definition: cf_inline.cc:354
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:116
void Off(int sw)
switches
poly p_Div_mm(poly p, const poly m, const ring r)
divide polynomial by monomial
Definition: p_polys.cc:1520
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:468
factory&#39;s class for variables
Definition: factory.h:117
poly p_GcdMon(poly f, poly g, const ring r)
polynomial gcd for f=mon
Definition: p_polys.cc:4846
static const int SW_USE_EZGCD_P
set to 1 to use EZGCD over F_q
Definition: cf_defs.h:34
int rChar(ring r)
Definition: ring.cc:713
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:320
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:534
factory&#39;s main class
Definition: canonicalform.h:77
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:507
g
Definition: cfModGcd.cc:4031
void WerrorS(const char *s)
Definition: feFopen.cc:24
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
static TreeM * G
Definition: janet.cc:31
void setCharacteristic(int c)
Definition: cf_char.cc:23
int getCharacteristic()
Definition: cf_char.cc:51
void prune(Variable &alpha)
Definition: variable.cc:261
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
Variable rootOf(const CanonicalForm &, char name='@')
returns a symbolic root of polynomial with name name Use it to define algebraic variables ...
Definition: variable.cc:162
CanonicalForm res
Definition: facAbsFact.cc:64
poly p_One(const ring r)
Definition: p_polys.cc:1303
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1927
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
const char feNotImplemented[]
Definition: reporter.cc:54
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
bool isOn(int sw)
switches
void On(int sw)
switches
FILE * f
Definition: checklibs.c:9
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
CanonicalForm bCommonDen(const CanonicalForm &f)
CanonicalForm bCommonDen ( const CanonicalForm & f )
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:856
#define NULL
Definition: omList.c:12
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
CanonicalForm mipo
Definition: facAlgExt.cc:57
int gcd(int a, int b)
Definition: walkSupport.cc:836
static const int SW_USE_QGCD
set to 1 to use Encarnacion GCD over Q(a)
Definition: cf_defs.h:40
#define pNext(p)
Definition: monomials.h:36
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:151

◆ singclap_gcd_r()

poly singclap_gcd_r ( poly  f,
poly  g,
const ring  r 
)

Definition at line 42 of file clapsing.cc.

43 {
44  poly res=NULL;
45 
46  assume(f!=NULL);
47  assume(g!=NULL);
48 
49  if(pNext(f)==NULL)
50  {
51  return p_GcdMon(f,g,r);
52  }
53  else if(pNext(g)==NULL)
54  {
55  return p_GcdMon(g,f,r);
56  }
57 
59  if (rField_is_Q(r) || rField_is_Zp(r) || rField_is_Z(r)
60  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
61  {
64  res=convFactoryPSingP( gcd( F, G ) , r);
65  }
66  // and over Q(a) / Fp(a)
67  else if ( r->cf->extRing!=NULL )
68  {
69  if ( rField_is_Q_a(r)) setCharacteristic( 0 );
70  else setCharacteristic( rChar(r) );
71  if (r->cf->extRing->qideal!=NULL)
72  {
73  bool b1=isOn(SW_USE_QGCD);
74  if ( rField_is_Q_a(r) ) On(SW_USE_QGCD);
75  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
76  r->cf->extRing);
77  Variable a=rootOf(mipo);
79  G( convSingAPFactoryAP( g,a,r ) );
80  res= convFactoryAPSingAP( gcd( F, G ),r );
81  prune (a);
82  if (!b1) Off(SW_USE_QGCD);
83  }
84  else
85  {
87  res= convFactoryPSingTrP( gcd( F, G ),r );
88  }
89  }
90  else if (r->cf->convSingNFactoryN==ndConvSingNFactoryN)
92  else
93  { // handle user type coeffs:
96  res=convFactoryPSingP( gcd( F, G ) , r);
97  }
99  return res;
100 }
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:116
void Off(int sw)
switches
factory&#39;s class for variables
Definition: factory.h:117
poly p_GcdMon(poly f, poly g, const ring r)
polynomial gcd for f=mon
Definition: p_polys.cc:4846
int rChar(ring r)
Definition: ring.cc:713
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:320
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:534
factory&#39;s main class
Definition: canonicalform.h:77
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:507
g
Definition: cfModGcd.cc:4031
void WerrorS(const char *s)
Definition: feFopen.cc:24
static BOOLEAN rField_is_Z(const ring r)
Definition: ring.h:504
static TreeM * G
Definition: janet.cc:31
void setCharacteristic(int c)
Definition: cf_char.cc:23
void prune(Variable &alpha)
Definition: variable.cc:261
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
Variable rootOf(const CanonicalForm &, char name='@')
returns a symbolic root of polynomial with name name Use it to define algebraic variables ...
Definition: variable.cc:162
CanonicalForm res
Definition: facAbsFact.cc:64
#define assume(x)
Definition: mod2.h:390
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
const char feNotImplemented[]
Definition: reporter.cc:54
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
bool isOn(int sw)
switches
void On(int sw)
switches
FILE * f
Definition: checklibs.c:9
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
#define NULL
Definition: omList.c:12
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
CanonicalForm mipo
Definition: facAlgExt.cc:57
int gcd(int a, int b)
Definition: walkSupport.cc:836
static const int SW_USE_QGCD
set to 1 to use Encarnacion GCD over Q(a)
Definition: cf_defs.h:40
#define pNext(p)
Definition: monomials.h:36
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:151

◆ singclap_irrCharSeries()

matrix singclap_irrCharSeries ( ideal  I,
const ring  r 
)

Definition at line 1451 of file clapsing.cc.

1452 {
1453  if (idIs0(I)) return mpNew(1,1);
1454 
1455  // for now there is only the possibility to handle polynomials over
1456  // Q and Fp ...
1457  matrix res=NULL;
1458  int i;
1459  Off(SW_RATIONAL);
1461  CFList L;
1462  ListCFList LL;
1463  if (rField_is_Q(r) || rField_is_Zp(r)
1464  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
1465  {
1466  setCharacteristic( rChar(r) );
1467  for(i=0;i<IDELEMS(I);i++)
1468  {
1469  poly p=I->m[i];
1470  if (p!=NULL)
1471  {
1472  p=p_Copy(p,r);
1473  p_Cleardenom(p, r);
1474  L.append(convSingPFactoryP(p,r));
1475  p_Delete(&p,r);
1476  }
1477  }
1478  }
1479  // and over Q(a) / Fp(a)
1480  else if (nCoeff_is_transExt (r->cf))
1481  {
1482  setCharacteristic( rChar(r) );
1483  for(i=0;i<IDELEMS(I);i++)
1484  {
1485  poly p=I->m[i];
1486  if (p!=NULL)
1487  {
1488  p=p_Copy(p,r);
1489  p_Cleardenom(p, r);
1490  L.append(convSingTrPFactoryP(p,r));
1491  p_Delete(&p,r);
1492  }
1493  }
1494  }
1495  else
1496  {
1498  return res;
1499  }
1500 
1501  // a very bad work-around --- FIX IT in libfac
1502  // should be fixed as of 2001/6/27
1503  int tries=0;
1504  int m,n;
1506  loop
1507  {
1508  LL=irrCharSeries(L);
1509  m= LL.length(); // Anzahl Zeilen
1510  n=0;
1511  for ( LLi = LL; LLi.hasItem(); LLi++ )
1512  {
1513  n = si_max(LLi.getItem().length(),n);
1514  }
1515  if ((m!=0) && (n!=0)) break;
1516  tries++;
1517  if (tries>=5) break;
1518  }
1519  if ((m==0) || (n==0))
1520  {
1521  Warn("char_series returns %d x %d matrix from %d input polys (%d)",
1522  m,n,IDELEMS(I)+1,LL.length());
1523  iiWriteMatrix((matrix)I,"I",2,r,0);
1524  m=si_max(m,1);
1525  n=si_max(n,1);
1526  }
1527  res=mpNew(m,n);
1528  CFListIterator Li;
1529  for ( m=1, LLi = LL; LLi.hasItem(); LLi++, m++ )
1530  {
1531  for (n=1, Li = LLi.getItem(); Li.hasItem(); Li++, n++)
1532  {
1533  if (rField_is_Q(r) || rField_is_Zp(r)
1534  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
1535  MATELEM(res,m,n)=convFactoryPSingP(Li.getItem(),r);
1536  else
1537  MATELEM(res,m,n)=convFactoryPSingTrP(Li.getItem(),r);
1538  }
1539  }
1540  Off(SW_RATIONAL);
1541  return res;
1542 }
void Off(int sw)
switches
int rChar(ring r)
Definition: ring.cc:713
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:320
ListCFList irrCharSeries(const CFList &PS)
irreducible characteristic series
Definition: cfCharSets.cc:568
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:507
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define loop
Definition: structs.h:80
void setCharacteristic(int c)
Definition: cf_char.cc:23
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:811
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
Definition: matpol.cc:834
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
CanonicalForm res
Definition: facAbsFact.cc:64
T & getItem() const
Definition: ftmpl_list.cc:431
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
const char feNotImplemented[]
Definition: reporter.cc:54
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
int m
Definition: cfEzgcd.cc:121
void On(int sw)
switches
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:940
int i
Definition: cfEzgcd.cc:125
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
#define IDELEMS(i)
Definition: simpleideals.h:23
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:856
#define NULL
Definition: omList.c:12
int length() const
Definition: ftmpl_list.cc:273
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
void append(const T &)
Definition: ftmpl_list.cc:256
int p
Definition: cfModGcd.cc:4019
static const int SW_SYMMETRIC_FF
set to 1 for symmetric representation over F_q
Definition: cf_defs.h:30
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2791
#define MATELEM(mat, i, j)
1-based access to matrix
Definition: matpol.h:29
#define Warn
Definition: emacs.cc:77

◆ singclap_neworder()

char* singclap_neworder ( ideal  I,
const ring  r 
)

Definition at line 1544 of file clapsing.cc.

1545 {
1546  int i;
1547  Off(SW_RATIONAL);
1549  CFList L;
1550  if (rField_is_Q(r) || rField_is_Zp(r)
1551  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
1552  {
1553  setCharacteristic( rChar(r) );
1554  for(i=0;i<IDELEMS(I);i++)
1555  {
1556  poly p=I->m[i];
1557  if (p!=NULL)
1558  {
1559  p=p_Copy(p,r);
1560  p_Cleardenom(p, r);
1561  L.append(convSingPFactoryP(p,r));
1562  }
1563  }
1564  }
1565  // and over Q(a) / Fp(a)
1566  else if (nCoeff_is_transExt (r->cf))
1567  {
1568  setCharacteristic( rChar(r) );
1569  for(i=0;i<IDELEMS(I);i++)
1570  {
1571  poly p=I->m[i];
1572  if (p!=NULL)
1573  {
1574  p=p_Copy(p,r);
1575  p_Cleardenom(p, r);
1576  L.append(convSingTrPFactoryP(p,r));
1577  }
1578  }
1579  }
1580  else
1581  {
1583  return NULL;
1584  }
1585 
1586  List<int> IL=neworderint(L);
1587  ListIterator<int> Li;
1588  StringSetS("");
1589  Li = IL;
1590  int offs=rPar(r);
1591  int* mark=(int*)omAlloc0((rVar(r)+offs)*sizeof(int));
1592  int cnt=rVar(r)+offs;
1593  loop
1594  {
1595  if(! Li.hasItem()) break;
1596  BOOLEAN done=TRUE;
1597  i=Li.getItem()-1;
1598  mark[i]=1;
1599  if (i<offs)
1600  {
1601  done=FALSE;
1602  //StringAppendS(r->parameter[i]);
1603  }
1604  else
1605  {
1606  StringAppendS(r->names[i-offs]);
1607  }
1608  Li++;
1609  cnt--;
1610  if(cnt==0) break;
1611  if (done) StringAppendS(",");
1612  }
1613  for(i=0;i<rVar(r)+offs;i++)
1614  {
1615  BOOLEAN done=TRUE;
1616  if(mark[i]==0)
1617  {
1618  if (i<offs)
1619  {
1620  done=FALSE;
1621  //StringAppendS(r->parameter[i]);
1622  }
1623  else
1624  {
1625  StringAppendS(r->names[i-offs]);
1626  }
1627  cnt--;
1628  if(cnt==0) break;
1629  if (done) StringAppendS(",");
1630  }
1631  }
1632  char * s=StringEndS();
1633  if (s[strlen(s)-1]==',') s[strlen(s)-1]='\0';
1634  return s;
1635 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
std::pair< int, int > mark
void Off(int sw)
switches
#define FALSE
Definition: auxiliary.h:94
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:593
int rChar(ring r)
Definition: ring.cc:713
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:586
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
#define TRUE
Definition: auxiliary.h:98
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:507
void WerrorS(const char *s)
Definition: feFopen.cc:24
char * StringEndS()
Definition: reporter.cc:151
#define loop
Definition: structs.h:80
void setCharacteristic(int c)
Definition: cf_char.cc:23
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:811
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
IntList neworderint(const CFList &PolyList)
Definition: cfCharSets.cc:88
void StringSetS(const char *st)
Definition: reporter.cc:128
void StringAppendS(const char *st)
Definition: reporter.cc:107
T & getItem() const
Definition: ftmpl_list.cc:431
const char feNotImplemented[]
Definition: reporter.cc:54
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
void On(int sw)
switches
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:940
int i
Definition: cfEzgcd.cc:125
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
#define IDELEMS(i)
Definition: simpleideals.h:23
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
#define NULL
Definition: omList.c:12
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
void append(const T &)
Definition: ftmpl_list.cc:256
int p
Definition: cfModGcd.cc:4019
static const int SW_SYMMETRIC_FF
set to 1 for symmetric representation over F_q
Definition: cf_defs.h:30
int BOOLEAN
Definition: auxiliary.h:85
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2791
#define omAlloc0(size)
Definition: omAllocDecl.h:211

◆ singclap_pdivide()

poly singclap_pdivide ( poly  f,
poly  g,
const ring  r 
)

Definition at line 556 of file clapsing.cc.

557 {
558  poly res=NULL;
559  On(SW_RATIONAL);
560  if (rField_is_Zp(r) || rField_is_Q(r)
561  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
562  {
563  setCharacteristic( rChar(r) );
565  res = convFactoryPSingP( F / G,r );
566  }
567  // div is not implemented for ZZ coeffs in factory
568  else if (r->cf->extRing!=NULL)
569  {
570  if (rField_is_Q_a(r)) setCharacteristic( 0 );
571  else setCharacteristic( rChar(r) );
572  if (r->cf->extRing->qideal!=NULL)
573  {
574  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
575  r->cf->extRing);
576  Variable a=rootOf(mipo);
577  CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
578  G( convSingAPFactoryAP( g,a,r ) );
579  res= convFactoryAPSingAP( F / G, r );
580  prune (a);
581  }
582  else
583  {
585  res= convFactoryPSingTrP( F / G,r );
586  }
587  }
588 #if 0 // not yet working
589  else if (rField_is_GF())
590  {
591  //Print("GF(%d^%d)\n",nfCharP,nfMinPoly[0]);
592  setCharacteristic( nfCharP,nfMinPoly[0], currRing->parameter[0][0] );
593  CanonicalForm F( convSingGFFactoryGF( f ) ), G( convSingGFFactoryGF( g ) );
594  res = convFactoryGFSingGF( F / G );
595  }
596 #endif
597  else
599  Off(SW_RATIONAL);
600  return res;
601 }
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:116
void Off(int sw)
switches
factory&#39;s class for variables
Definition: factory.h:117
int rChar(ring r)
Definition: ring.cc:713
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:320
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:534
factory&#39;s main class
Definition: canonicalform.h:77
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:507
g
Definition: cfModGcd.cc:4031
void WerrorS(const char *s)
Definition: feFopen.cc:24
static BOOLEAN rField_is_GF(const ring r)
Definition: ring.h:516
static TreeM * G
Definition: janet.cc:31
void setCharacteristic(int c)
Definition: cf_char.cc:23
void prune(Variable &alpha)
Definition: variable.cc:261
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
Variable rootOf(const CanonicalForm &, char name='@')
returns a symbolic root of polynomial with name name Use it to define algebraic variables ...
Definition: variable.cc:162
CanonicalForm res
Definition: facAbsFact.cc:64
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
const char feNotImplemented[]
Definition: reporter.cc:54
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
void On(int sw)
switches
FILE * f
Definition: checklibs.c:9
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
#define NULL
Definition: omList.c:12
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
CanonicalForm mipo
Definition: facAlgExt.cc:57
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:151
static int nfMinPoly[16]
Definition: ffields.cc:548

◆ singclap_pmod()

poly singclap_pmod ( poly  f,
poly  g,
const ring  r 
)

Definition at line 603 of file clapsing.cc.

604 {
605  poly res=NULL;
606  On(SW_RATIONAL);
607  if (rField_is_Zp(r) || rField_is_Q(r)
608  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
609  {
610  setCharacteristic( rChar(r) );
612  res = convFactoryPSingP( F % G,r );
613  }
614  // mod is not implemented for ZZ coeffs in factory
615  else if (r->cf->extRing!=NULL)
616  {
617  if (rField_is_Q_a(r)) setCharacteristic( 0 );
618  else setCharacteristic( rChar(r) );
619  if (r->cf->extRing->qideal!=NULL)
620  {
621  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
622  r->cf->extRing);
623  Variable a=rootOf(mipo);
624  CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
625  G( convSingAPFactoryAP( g,a,r ) );
626  res= convFactoryAPSingAP( F % G, r );
627  prune (a);
628  }
629  else
630  {
632  res= convFactoryPSingTrP( F % G,r );
633  }
634  }
635 #if 0 // not yet working
636  else if (rField_is_GF())
637  {
638  //Print("GF(%d^%d)\n",nfCharP,nfMinPoly[0]);
639  setCharacteristic( nfCharP,nfMinPoly[0], currRing->parameter[0][0] );
640  CanonicalForm F( convSingGFFactoryGF( f ) ), G( convSingGFFactoryGF( g ) );
641  res = convFactoryGFSingGF( F / G );
642  }
643 #endif
644  else
646  Off(SW_RATIONAL);
647  return res;
648 }
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:116
void Off(int sw)
switches
factory&#39;s class for variables
Definition: factory.h:117
int rChar(ring r)
Definition: ring.cc:713
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:320
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:534
factory&#39;s main class
Definition: canonicalform.h:77
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:507
g
Definition: cfModGcd.cc:4031
void WerrorS(const char *s)
Definition: feFopen.cc:24
static BOOLEAN rField_is_GF(const ring r)
Definition: ring.h:516
static TreeM * G
Definition: janet.cc:31
void setCharacteristic(int c)
Definition: cf_char.cc:23
void prune(Variable &alpha)
Definition: variable.cc:261
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
Variable rootOf(const CanonicalForm &, char name='@')
returns a symbolic root of polynomial with name name Use it to define algebraic variables ...
Definition: variable.cc:162
CanonicalForm res
Definition: facAbsFact.cc:64
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
const char feNotImplemented[]
Definition: reporter.cc:54
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
void On(int sw)
switches
FILE * f
Definition: checklibs.c:9
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
#define NULL
Definition: omList.c:12
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
CanonicalForm mipo
Definition: facAlgExt.cc:57
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:151
static int nfMinPoly[16]
Definition: ffields.cc:548

◆ singclap_pmult()

poly singclap_pmult ( poly  f,
poly  g,
const ring  r 
)

Definition at line 509 of file clapsing.cc.

510 {
511  poly res=NULL;
512  On(SW_RATIONAL);
513  if (rField_is_Zp(r) || rField_is_Q(r) || rField_is_Z(r)
514  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
515  {
516  if (rField_is_Z(r)) Off(SW_RATIONAL);
517  setCharacteristic( rChar(r) );
519  res = convFactoryPSingP( F * G,r );
520  }
521  else if (r->cf->extRing!=NULL)
522  {
523  if (rField_is_Q_a(r)) setCharacteristic( 0 );
524  else setCharacteristic( rChar(r) );
525  if (r->cf->extRing->qideal!=NULL)
526  {
527  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
528  r->cf->extRing);
529  Variable a=rootOf(mipo);
530  CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
531  G( convSingAPFactoryAP( g,a,r ) );
532  res= convFactoryAPSingAP( F * G, r );
533  prune (a);
534  }
535  else
536  {
538  res= convFactoryPSingTrP( F * G,r );
539  }
540  }
541 #if 0 // not yet working
542  else if (rField_is_GF())
543  {
544  //Print("GF(%d^%d)\n",nfCharP,nfMinPoly[0]);
545  setCharacteristic( nfCharP,nfMinPoly[0], currRing->parameter[0][0] );
546  CanonicalForm F( convSingGFFactoryGF( f ) ), G( convSingGFFactoryGF( g ) );
547  res = convFactoryGFSingGF( F * G );
548  }
549 #endif
550  else
552  Off(SW_RATIONAL);
553  return res;
554 }
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:116
void Off(int sw)
switches
factory&#39;s class for variables
Definition: factory.h:117
int rChar(ring r)
Definition: ring.cc:713
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:320
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:534
factory&#39;s main class
Definition: canonicalform.h:77
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:507
g
Definition: cfModGcd.cc:4031
void WerrorS(const char *s)
Definition: feFopen.cc:24
static BOOLEAN rField_is_GF(const ring r)
Definition: ring.h:516
static BOOLEAN rField_is_Z(const ring r)
Definition: ring.h:504
static TreeM * G
Definition: janet.cc:31
void setCharacteristic(int c)
Definition: cf_char.cc:23
void prune(Variable &alpha)
Definition: variable.cc:261
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
Variable rootOf(const CanonicalForm &, char name='@')
returns a symbolic root of polynomial with name name Use it to define algebraic variables ...
Definition: variable.cc:162
CanonicalForm res
Definition: facAbsFact.cc:64
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
const char feNotImplemented[]
Definition: reporter.cc:54
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
void On(int sw)
switches
FILE * f
Definition: checklibs.c:9
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
#define NULL
Definition: omList.c:12
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
CanonicalForm mipo
Definition: facAlgExt.cc:57
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:151
static int nfMinPoly[16]
Definition: ffields.cc:548

◆ singclap_resultant()

poly singclap_resultant ( poly  f,
poly  g,
poly  x,
const ring  r 
)

Definition at line 277 of file clapsing.cc.

278 {
279  poly res=NULL;
280  int i=p_IsPurePower(x, r);
281  if (i==0)
282  {
283  WerrorS("3rd argument must be a ring variable");
284  goto resultant_returns_res;
285  }
286  if ((f==NULL) || (g==NULL))
287  goto resultant_returns_res;
288  // for now there is only the possibility to handle polynomials over
289  // Q and Fp ...
290  if (rField_is_Zp(r) || rField_is_Q(r)
291  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
292  {
293  Variable X(i);
294  setCharacteristic( rChar(r) );
296  res=convFactoryPSingP( resultant( F, G, X),r );
297  Off(SW_RATIONAL);
298  goto resultant_returns_res;
299  }
300  // and over Q(a) / Fp(a)
301  else if (r->cf->extRing!=NULL)
302  {
303  if (rField_is_Q_a(r)) setCharacteristic( 0 );
304  else setCharacteristic( rChar(r) );
305  Variable X(i+rPar(r));
306  if (r->cf->extRing->qideal!=NULL)
307  {
308  //Variable X(i);
309  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
310  r->cf->extRing);
311  Variable a=rootOf(mipo);
312  CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
313  G( convSingAPFactoryAP( g,a,r ) );
314  res= convFactoryAPSingAP( resultant( F, G, X ),r );
315  prune (a);
316  }
317  else
318  {
319  //Variable X(i+rPar(currRing));
320  number nf,ng;
321  p_Cleardenom_n(f,r,nf);p_Cleardenom_n(g,r,ng);
322  int ef,eg;
323  ef=pGetExp_Var(f,i,r);
324  eg=pGetExp_Var(g,i,r);
326  res= convFactoryPSingTrP( resultant( F, G, X ),r );
327  if ((nf!=NULL)&&(!n_IsOne(nf,r->cf)))
328  {
329  number n=n_Invers(nf,r->cf);
330  while(eg>0)
331  {
332  res=__p_Mult_nn(res,n,r);
333  eg--;
334  }
335  n_Delete(&n,r->cf);
336  }
337  n_Delete(&nf,r->cf);
338  if ((ng!=NULL)&&(!n_IsOne(ng,r->cf)))
339  {
340  number n=n_Invers(ng,r->cf);
341  while(ef>0)
342  {
343  res=__p_Mult_nn(res,n,r);
344  ef--;
345  }
346  n_Delete(&n,r->cf);
347  }
348  n_Delete(&ng,r->cf);
349  }
350  Off(SW_RATIONAL);
351  goto resultant_returns_res;
352  }
353  else
355 resultant_returns_res:
356  p_Delete(&f,r);
357  p_Delete(&g,r);
358  p_Delete(&x,r);
359  return res;
360 }
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:116
void Off(int sw)
switches
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:468
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:593
factory&#39;s class for variables
Definition: factory.h:117
int rChar(ring r)
Definition: ring.cc:713
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:320
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:534
factory&#39;s main class
Definition: canonicalform.h:77
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:507
g
Definition: cfModGcd.cc:4031
void WerrorS(const char *s)
Definition: feFopen.cc:24
static TreeM * G
Definition: janet.cc:31
void setCharacteristic(int c)
Definition: cf_char.cc:23
void prune(Variable &alpha)
Definition: variable.cc:261
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
Variable rootOf(const CanonicalForm &, char name='@')
returns a symbolic root of polynomial with name name Use it to define algebraic variables ...
Definition: variable.cc:162
void p_Cleardenom_n(poly ph, const ring r, number &c)
Definition: p_polys.cc:2900
Definition: gnumpfl.cc:26
CanonicalForm res
Definition: facAbsFact.cc:64
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
const char feNotImplemented[]
Definition: reporter.cc:54
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of &#39;a&#39;; raise an error if &#39;a&#39; is not invertible ...
Definition: coeffs.h:564
FILE * f
Definition: checklibs.c:9
int i
Definition: cfEzgcd.cc:125
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
int pGetExp_Var(poly p, int i, const ring r)
Definition: clapsing.cc:263
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:856
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
Definition: p_polys.cc:1216
#define __p_Mult_nn(p, n, r)
Definition: p_polys.h:926
#define NULL
Definition: omList.c:12
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
CanonicalForm mipo
Definition: facAlgExt.cc:57
Variable x
Definition: cfModGcd.cc:4023
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:455
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:151
CanonicalForm resultant(const CanonicalForm &f, const CanonicalForm &g, const Variable &x)
CanonicalForm resultant ( const CanonicalForm & f, const CanonicalForm & g, const Variable & x ) ...

◆ singclap_sqrfree()

ideal singclap_sqrfree ( poly  f,
intvec **  v,
int  with_exps,
const ring  r 
)

Definition at line 1218 of file clapsing.cc.

1219 {
1220  p_Test(f,r);
1221 #ifdef FACTORIZE2_DEBUG
1222  printf("singclap_sqrfree, degree %d\n",pTotaldegree(f));
1223 #endif
1224  // with_exps: 3,1 return only true factors, no exponents
1225  // 2 return true factors and exponents
1226  // 0 return coeff, factors and exponents
1227  BOOLEAN save_errorreported=errorreported;
1228 
1229  ideal res=NULL;
1230 
1231  // handle factorize(0) =========================================
1232  if (f==NULL)
1233  {
1234  res=idInit(1,1);
1235  if (with_exps!=1 && with_exps!=3)
1236  {
1237  (*v)=new intvec(1);
1238  (**v)[0]=1;
1239  }
1240  return res;
1241  }
1242  // handle factorize(mon) =========================================
1243  if (pNext(f)==NULL)
1244  {
1245  int i=0;
1246  int n=0;
1247  int e;
1248  for(i=rVar(r);i>0;i--) if(p_GetExp(f,i,r)!=0) n++;
1249  if (with_exps==0 || with_exps==3) n++; // with coeff
1250  res=idInit(si_max(n,1),1);
1251  if(with_exps!=1)
1252  {
1253  (*v)=new intvec(si_max(1,n));
1254  (**v)[0]=1;
1255  }
1256  res->m[0]=p_NSet(n_Copy(pGetCoeff(f),r->cf),r);
1257  if (n==0)
1258  {
1259  res->m[0]=p_One(r);
1260  // (**v)[0]=1; is already done
1261  }
1262  else
1263  {
1264  for(i=rVar(r);i>0;i--)
1265  {
1266  e=p_GetExp(f,i,r);
1267  if(e!=0)
1268  {
1269  n--;
1270  poly p=p_One(r);
1271  p_SetExp(p,i,1,r);
1272  p_Setm(p,r);
1273  res->m[n]=p;
1274  if (with_exps!=1) (**v)[n]=e;
1275  }
1276  }
1277  }
1278  p_Delete(&f,r);
1279  return res;
1280  }
1281  //PrintS("S:");pWrite(f);PrintLn();
1282  // use factory/libfac in general ==============================
1283  Off(SW_RATIONAL);
1285  CFFList L;
1286  number N=NULL;
1287  number NN=NULL;
1288  number old_lead_coeff=n_Copy(pGetCoeff(f), r->cf);
1289  Variable a;
1290 
1291  if (!rField_is_Zp(r) && !rField_is_Zp_a(r)) /* Q, Q(a) */
1292  {
1293  //if (f!=NULL) // already tested at start of routine
1294  number n0=n_Copy(pGetCoeff(f),r->cf);
1295  if (with_exps==0 || with_exps==3)
1296  N=n_Copy(n0,r->cf);
1297  p_Cleardenom(f, r);
1298  //after here f should not have a denominator!!
1299  //PrintS("S:");p_Write(f,r);PrintLn();
1300  NN=n_Div(n0,pGetCoeff(f),r->cf);
1301  n_Delete(&n0,r->cf);
1302  if (with_exps==0 || with_exps==3)
1303  {
1304  n_Delete(&N,r->cf);
1305  N=n_Copy(NN,r->cf);
1306  }
1307  }
1308  else if (rField_is_Zp_a(r))
1309  {
1310  //if (f!=NULL) // already tested at start of routine
1311  if (singclap_factorize_retry==0)
1312  {
1313  number n0=n_Copy(pGetCoeff(f),r->cf);
1314  if (with_exps==0 || with_exps==3)
1315  N=n_Copy(n0,r->cf);
1316  p_Norm(f,r);
1317  p_Cleardenom(f, r);
1318  NN=n_Div(n0,pGetCoeff(f),r->cf);
1319  n_Delete(&n0,r->cf);
1320  if (with_exps==0 || with_exps==3)
1321  {
1322  n_Delete(&N,r->cf);
1323  N=n_Copy(NN,r->cf);
1324  }
1325  }
1326  }
1327  if (rField_is_Q(r) || rField_is_Zp(r)
1328  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
1329  {
1330  setCharacteristic( rChar(r) );
1331  CanonicalForm F( convSingPFactoryP( f,r ) );
1332  L = sqrFree( F );
1333  }
1334  else if (r->cf->extRing!=NULL)
1335  {
1336  if (rField_is_Q_a (r)) setCharacteristic (0);
1337  else setCharacteristic( rChar(r) );
1338  if (r->cf->extRing->qideal!=NULL)
1339  {
1340  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
1341  r->cf->extRing);
1342  a=rootOf(mipo);
1343  CanonicalForm F( convSingAPFactoryAP( f, a, r ) );
1344  L= sqrFree (F);
1345  }
1346  else
1347  {
1349  L = sqrFree( F );
1350  }
1351  }
1352  #if 0
1353  else if (rField_is_GF())
1354  {
1355  int c=rChar(r);
1356  setCharacteristic( c, primepower(c) );
1357  CanonicalForm F( convSingGFFactoryGF( f ) );
1358  if (F.isUnivariate())
1359  {
1360  L = factorize( F );
1361  }
1362  else
1363  {
1364  goto notImpl;
1365  }
1366  }
1367  #endif
1368  else
1369  {
1370  goto notImpl;
1371  }
1372  {
1373  // convert into ideal
1374  int n = L.length();
1375  if (n==0) n=1;
1376  CFFListIterator J=L;
1377  int j=0;
1378  if (with_exps!=1)
1379  {
1380  if ((with_exps==2)&&(n>1))
1381  {
1382  n--;
1383  J++;
1384  }
1385  *v = new intvec( n );
1386  }
1387  else if (L.getFirst().factor().inCoeffDomain() && with_exps!=3)
1388  {
1389  n--;
1390  J++;
1391  }
1392  res = idInit( n ,1);
1393  for ( ; J.hasItem(); J++, j++ )
1394  {
1395  if (with_exps!=1 && with_exps!=3) (**v)[j] = J.getItem().exp();
1396  if (rField_is_Zp(r) || rField_is_Q(r)
1397  || (rField_is_Zn(r)&&(r->cf->convSingNFactoryN!=ndConvSingNFactoryN)))
1398  res->m[j] = convFactoryPSingP( J.getItem().factor(),r );
1399  else if (r->cf->extRing!=NULL) /* Q(a), Fp(a) */
1400  {
1401  if (r->cf->extRing->qideal==NULL)
1402  res->m[j]=convFactoryPSingTrP( J.getItem().factor(),r );
1403  else
1404  res->m[j]=convFactoryAPSingAP( J.getItem().factor(),r );
1405  }
1406  }
1407  if (res->m[0]==NULL)
1408  {
1409  res->m[0]=p_One(r);
1410  }
1411  if (N!=NULL)
1412  {
1413  __p_Mult_nn(res->m[0],N,r);
1414  n_Delete(&N,r->cf);
1415  N=NULL;
1416  }
1417  }
1418  if (r->cf->extRing!=NULL)
1419  if (r->cf->extRing->qideal!=NULL)
1420  prune (a);
1421  if (rField_is_Q_a(r) && (r->cf->extRing->qideal!=NULL))
1422  {
1423  int i=IDELEMS(res)-1;
1424  int stop=1;
1425  if (with_exps!=0 || with_exps==3) stop=0;
1426  for(;i>=stop;i--)
1427  {
1428  p_Norm(res->m[i],r);
1429  }
1430  if (with_exps==0 || with_exps==3) p_SetCoeff(res->m[0],old_lead_coeff,r);
1431  else n_Delete(&old_lead_coeff,r->cf);
1432  }
1433  else
1434  n_Delete(&old_lead_coeff,r->cf);
1435  p_Delete(&f,r);
1436  errorreported=save_errorreported;
1437 notImpl:
1438  if (res==NULL)
1440  if (NN!=NULL)
1441  {
1442  n_Delete(&NN,r->cf);
1443  }
1444  if (N!=NULL)
1445  {
1446  n_Delete(&N,r->cf);
1447  }
1448  return res;
1449 }
int j
Definition: facHensel.cc:105
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:116
void Off(int sw)
switches
static BOOLEAN rField_is_Zp_a(const ring r)
Definition: ring.h:524
factory&#39;s class for variables
Definition: factory.h:117
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1455
int rChar(ring r)
Definition: ring.cc:713
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:586
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:284
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:320
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:534
factory&#39;s main class
Definition: canonicalform.h:77
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:507
void WerrorS(const char *s)
Definition: feFopen.cc:24
static BOOLEAN rField_is_GF(const ring r)
Definition: ring.h:516
void p_Norm(poly p1, const ring r)
Definition: p_polys.cc:3679
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
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:411
void setCharacteristic(int c)
Definition: cf_char.cc:23
void prune(Variable &alpha)
Definition: variable.cc:261
T getFirst() const
Definition: ftmpl_list.cc:279
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:272
Variable rootOf(const CanonicalForm &, char name='@')
returns a symbolic root of polynomial with name name Use it to define algebraic variables ...
Definition: variable.cc:162
CFFList factorize(const CanonicalForm &f, bool issqrfree=false)
factorization over or
Definition: cf_factor.cc:390
Definition: intvec.h:19
CanonicalForm res
Definition: facAbsFact.cc:64
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
poly p_One(const ring r)
Definition: p_polys.cc:1303
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:468
static long pTotaldegree(poly p)
Definition: polys.h:277
T & getItem() const
Definition: ftmpl_list.cc:431
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
const char feNotImplemented[]
Definition: reporter.cc:54
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
void On(int sw)
switches
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
FILE * f
Definition: checklibs.c:9
int i
Definition: cfEzgcd.cc:125
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
#define IDELEMS(i)
Definition: simpleideals.h:23
#define p_Test(p, r)
Definition: p_polys.h:162
short errorreported
Definition: feFopen.cc:23
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:856
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
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:487
#define __p_Mult_nn(p, n, r)
Definition: p_polys.h:926
#define NULL
Definition: omList.c:12
int length() const
Definition: ftmpl_list.cc:273
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:451
CanonicalForm mipo
Definition: facAlgExt.cc:57
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:615
#define pNext(p)
Definition: monomials.h:36
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:232
int singclap_factorize_retry
Definition: clapsing.cc:838
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:455
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:151
int p
Definition: cfModGcd.cc:4019
static const int SW_SYMMETRIC_FF
set to 1 for symmetric representation over F_q
Definition: cf_defs.h:30
int BOOLEAN
Definition: auxiliary.h:85
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2791
CFFList sqrFree(const CanonicalForm &f, bool sort=false)
squarefree factorization
Definition: cf_factor.cc:757

◆ singntl_HNF() [1/3]

matrix singntl_HNF ( matrix  m,
const ring  s 
)

Definition at line 1697 of file clapsing.cc.

1698 {
1699  int r=m->rows();
1700  if (r!=m->cols())
1701  {
1702  Werror("HNF of %d x %d matrix",r,m->cols());
1703  return NULL;
1704  }
1705 
1706  matrix res=mpNew(r,r);
1707 
1708  if (rField_is_Q(s))
1709  {
1710 
1711  CFMatrix M(r,r);
1712  int i,j;
1713  for(i=r;i>0;i--)
1714  {
1715  for(j=r;j>0;j--)
1716  {
1717  M(i,j)=convSingPFactoryP(MATELEM(m,i,j),s );
1718  }
1719  }
1720  CFMatrix *MM=cf_HNF(M);
1721  for(i=r;i>0;i--)
1722  {
1723  for(j=r;j>0;j--)
1724  {
1725  MATELEM(res,i,j)=convFactoryPSingP((*MM)(i,j),s);
1726  }
1727  }
1728  delete MM;
1729  }
1730  return res;
1731 }
int & rows()
Definition: matpol.h:23
const CanonicalForm int s
Definition: facAbsFact.cc:55
int j
Definition: facHensel.cc:105
#define M
Definition: sirandom.c:24
CanonicalForm res
Definition: facAbsFact.cc:64
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
int i
Definition: cfEzgcd.cc:125
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
CFMatrix * cf_HNF(CFMatrix &A)
The input matrix A is an n x m matrix of rank m (so n >= m), and D is a multiple of the determinant o...
Definition: cf_hnf.cc:38
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
int & cols()
Definition: matpol.h:24
#define NULL
Definition: omList.c:12
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
void Werror(const char *fmt,...)
Definition: reporter.cc:189
#define MATELEM(mat, i, j)
1-based access to matrix
Definition: matpol.h:29

◆ singntl_HNF() [2/3]

intvec* singntl_HNF ( intvec m)

Definition at line 1733 of file clapsing.cc.

1734 {
1735  int r=m->rows();
1736  if (r!=m->cols())
1737  {
1738  Werror("HNF of %d x %d matrix",r,m->cols());
1739  return NULL;
1740  }
1741  setCharacteristic( 0 );
1742  CFMatrix M(r,r);
1743  int i,j;
1744  for(i=r;i>0;i--)
1745  {
1746  for(j=r;j>0;j--)
1747  {
1748  M(i,j)=IMATELEM(*m,i,j);
1749  }
1750  }
1751  CFMatrix *MM=cf_HNF(M);
1752  intvec *mm=ivCopy(m);
1753  for(i=r;i>0;i--)
1754  {
1755  for(j=r;j>0;j--)
1756  {
1757  IMATELEM(*mm,i,j)=convFactoryISingI((*MM)(i,j));
1758  }
1759  }
1760  delete MM;
1761  return mm;
1762 }
int j
Definition: facHensel.cc:105
int rows() const
Definition: intvec.h:96
intvec * ivCopy(const intvec *o)
Definition: intvec.h:135
void setCharacteristic(int c)
Definition: cf_char.cc:23
#define M
Definition: sirandom.c:24
int convFactoryISingI(const CanonicalForm &f)
Definition: clapconv.cc:110
Definition: intvec.h:19
int i
Definition: cfEzgcd.cc:125
CFMatrix * cf_HNF(CFMatrix &A)
The input matrix A is an n x m matrix of rank m (so n >= m), and D is a multiple of the determinant o...
Definition: cf_hnf.cc:38
#define NULL
Definition: omList.c:12
int cols() const
Definition: intvec.h:95
#define IMATELEM(M, I, J)
Definition: intvec.h:85
void Werror(const char *fmt,...)
Definition: reporter.cc:189

◆ singntl_HNF() [3/3]

bigintmat* singntl_HNF ( bigintmat b)

Definition at line 1764 of file clapsing.cc.

1765 {
1766  int r=b->rows();
1767  if (r!=b->cols())
1768  {
1769  Werror("HNF of %d x %d matrix",r,b->cols());
1770  return NULL;
1771  }
1772  setCharacteristic( 0 );
1773  CFMatrix M(r,r);
1774  int i,j;
1775  for(i=r;i>0;i--)
1776  {
1777  for(j=r;j>0;j--)
1778  {
1779  M(i,j)=n_convSingNFactoryN(BIMATELEM(*b,i,j),FALSE,b->basecoeffs());
1780  }
1781  }
1782  CFMatrix *MM=cf_HNF(M);
1783  bigintmat *mm=bimCopy(b);
1784  for(i=r;i>0;i--)
1785  {
1786  for(j=r;j>0;j--)
1787  {
1788  BIMATELEM(*mm,i,j)=n_convFactoryNSingN((*MM)(i,j),b->basecoeffs());
1789  }
1790  }
1791  delete MM;
1792  return mm;
1793 }
int j
Definition: facHensel.cc:105
#define FALSE
Definition: auxiliary.h:94
Matrices of numbers.
Definition: bigintmat.h:50
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:621
int rows() const
Definition: bigintmat.h:145
void setCharacteristic(int c)
Definition: cf_char.cc:23
CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: numbers.cc:626
#define M
Definition: sirandom.c:24
bigintmat * bimCopy(const bigintmat *b)
same as copy constructor - apart from it being able to accept NULL as input
Definition: bigintmat.cc:405
int cols() const
Definition: bigintmat.h:144
int i
Definition: cfEzgcd.cc:125
CFMatrix * cf_HNF(CFMatrix &A)
The input matrix A is an n x m matrix of rank m (so n >= m), and D is a multiple of the determinant o...
Definition: cf_hnf.cc:38
#define BIMATELEM(M, I, J)
Definition: bigintmat.h:133
#define NULL
Definition: omList.c:12
coeffs basecoeffs() const
Definition: bigintmat.h:146
void Werror(const char *fmt,...)
Definition: reporter.cc:189

◆ singntl_LLL() [1/2]

matrix singntl_LLL ( matrix  m,
const ring  s 
)

Definition at line 1795 of file clapsing.cc.

1796 {
1797  int r=m->rows();
1798  int c=m->cols();
1799  matrix res=mpNew(r,c);
1800  if (rField_is_Q(s))
1801  {
1802  CFMatrix M(r,c);
1803  int i,j;
1804  for(i=r;i>0;i--)
1805  {
1806  for(j=c;j>0;j--)
1807  {
1808  M(i,j)=convSingPFactoryP(MATELEM(m,i,j),s);
1809  }
1810  }
1811  CFMatrix *MM=cf_LLL(M);
1812  for(i=r;i>0;i--)
1813  {
1814  for(j=c;j>0;j--)
1815  {
1816  MATELEM(res,i,j)=convFactoryPSingP((*MM)(i,j),s);
1817  }
1818  }
1819  delete MM;
1820  }
1821  return res;
1822 }
int & rows()
Definition: matpol.h:23
const CanonicalForm int s
Definition: facAbsFact.cc:55
int j
Definition: facHensel.cc:105
CFMatrix * cf_LLL(CFMatrix &A)
performs LLL reduction.
Definition: cf_hnf.cc:48
#define M
Definition: sirandom.c:24
CanonicalForm res
Definition: facAbsFact.cc:64
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:40
int i
Definition: cfEzgcd.cc:125
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
int & cols()
Definition: matpol.h:24
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:85
#define MATELEM(mat, i, j)
1-based access to matrix
Definition: matpol.h:29

◆ singntl_LLL() [2/2]

intvec* singntl_LLL ( intvec m)

Definition at line 1824 of file clapsing.cc.

1825 {
1826  int r=m->rows();
1827  int c=m->cols();
1828  setCharacteristic( 0 );
1829  CFMatrix M(r,c);
1830  int i,j;
1831  for(i=r;i>0;i--)
1832  {
1833  for(j=c;j>0;j--)
1834  {
1835  M(i,j)=IMATELEM(*m,i,j);
1836  }
1837  }
1838  CFMatrix *MM=cf_LLL(M);
1839  intvec *mm=ivCopy(m);
1840  for(i=r;i>0;i--)
1841  {
1842  for(j=c;j>0;j--)
1843  {
1844  IMATELEM(*mm,i,j)=convFactoryISingI((*MM)(i,j));
1845  }
1846  }
1847  delete MM;
1848  return mm;
1849 }
int j
Definition: facHensel.cc:105
int rows() const
Definition: intvec.h:96
intvec * ivCopy(const intvec *o)
Definition: intvec.h:135
void setCharacteristic(int c)
Definition: cf_char.cc:23
CFMatrix * cf_LLL(CFMatrix &A)
performs LLL reduction.
Definition: cf_hnf.cc:48
#define M
Definition: sirandom.c:24
int convFactoryISingI(const CanonicalForm &f)
Definition: clapconv.cc:110
Definition: intvec.h:19
int i
Definition: cfEzgcd.cc:125
int cols() const
Definition: intvec.h:95
#define IMATELEM(M, I, J)
Definition: intvec.h:85

Variable Documentation

◆ singclap_factorize_retry

int singclap_factorize_retry

Definition at line 838 of file clapsing.cc.