Typedefs | Functions
clapsing.h File Reference

Go to the source code of this file.

Typedefs

typedef polyrec * poly
 
typedef ip_smatrixmatrix
 

Functions

poly singclap_gcd (poly f, poly g, const ring r)
 destroys f and g More...
 
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...
 
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_pdivide (poly f, poly g, const ring r)
 
void singclap_divide_content (poly f, 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 singntl_HNF (matrix A, const ring r)
 
intvecsingntl_HNF (intvec *A)
 
bigintmatsingntl_HNF (bigintmat *A)
 
matrix singntl_LLL (matrix A, const ring r)
 
intvecsingntl_LLL (intvec *A)
 
ideal singclap_absFactorize (poly f, ideal &mipos, intvec **exps, int &n, 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 r)
 
int singclap_det_i (intvec *m, const ring r)
 
number singclap_det_bi (bigintmat *m, const coeffs cf)
 
number nChineseRemainder (number *x, number *q, int rl, const coeffs r)
 

Typedef Documentation

◆ matrix

typedef ip_smatrix* matrix

Definition at line 20 of file clapsing.h.

◆ poly

typedef polyrec* poly

Definition at line 16 of file clapsing.h.

Function Documentation

◆ nChineseRemainder()

number nChineseRemainder ( number *  x,
number *  q,
int  rl,
const coeffs  r 
)

◆ singclap_absFactorize()

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

Definition at line 1782 of file clapsing.cc.

1783 {
1784  p_Test(f, r);
1785 
1786  ideal res=NULL;
1787 
1788  int offs = rPar(r);
1789  if (f==NULL)
1790  {
1791  res= idInit (1, 1);
1792  mipos= idInit (1, 1);
1793  mipos->m[0]= convFactoryPSingTrP (Variable (offs), r); //overkill
1794  (*exps)=new intvec (1);
1795  (**exps)[0]= 1;
1796  numFactors= 0;
1797  return res;
1798  }
1800 
1801  bool isRat= isOn (SW_RATIONAL);
1802  if (!isRat)
1803  On (SW_RATIONAL);
1804 
1805  CFAFList absFactors= absFactorize (F);
1806 
1807  int n= absFactors.length();
1808  *exps=new intvec (n);
1809 
1810  res= idInit (n, 1);
1811 
1812  mipos= idInit (n, 1);
1813 
1814  Variable x= Variable (offs);
1815  Variable alpha;
1816  int i= 0;
1817  numFactors= 0;
1818  int count;
1819  CFAFListIterator iter= absFactors;
1820  CanonicalForm lead= iter.getItem().factor();
1821  if (iter.getItem().factor().inCoeffDomain())
1822  {
1823  i++;
1824  iter++;
1825  }
1826  for (; iter.hasItem(); iter++, i++)
1827  {
1828  (**exps)[i]= iter.getItem().exp();
1829  alpha= iter.getItem().minpoly().mvar();
1830  if (iter.getItem().minpoly().isOne())
1831  lead /= power (bCommonDen (iter.getItem().factor()), iter.getItem().exp());
1832  else
1833  lead /= power (power (bCommonDen (iter.getItem().factor()), degree (iter.getItem().minpoly())), iter.getItem().exp());
1834  res->m[i]= convFactoryPSingTrP (replacevar (iter.getItem().factor()*bCommonDen (iter.getItem().factor()), alpha, x), r);
1835  if (iter.getItem().minpoly().isOne())
1836  {
1837  count= iter.getItem().exp();
1838  mipos->m[i]= convFactoryPSingTrP (x,r);
1839  }
1840  else
1841  {
1842  count= iter.getItem().exp()*degree (iter.getItem().minpoly());
1843  mipos->m[i]= convFactoryPSingTrP (replacevar (iter.getItem().minpoly(), alpha, x), r);
1844  }
1845  if (!iter.getItem().minpoly().isOne())
1846  prune (alpha);
1847  numFactors += count;
1848  }
1849  if (!isRat)
1850  Off (SW_RATIONAL);
1851 
1852  (**exps)[0]= 1;
1853  res->m[0]= convFactoryPSingTrP (lead, r);
1854  mipos->m[0]= convFactoryPSingTrP (x, r);
1855  return res;
1856 }
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:590
factory's class for variables
Definition: factory.h:115
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:288
CFFListIterator iter
Definition: facAbsBiFact.cc:54
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:324
factory's main class
Definition: canonicalform.h:75
Variable alpha
Definition: facAbsBiFact.cc:52
void prune(Variable &alpha)
Definition: variable.cc:261
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
Definition: intvec.h:14
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:123
CanonicalForm bCommonDen(const CanonicalForm &f)
CanonicalForm bCommonDen ( const CanonicalForm & f )
#define p_Test(p, r)
Definition: p_polys.h:160
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
#define NULL
Definition: omList.c:10
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  r 
)

Definition at line 1568 of file clapsing.cc.

1569 {
1570  int r=m->rows();
1571  if (r!=m->cols())
1572  {
1573  Werror("det of %d x %d matrix",r,m->cols());
1574  return NULL;
1575  }
1576  poly res=NULL;
1577  CFMatrix M(r,r);
1578  int i,j;
1579  for(i=r;i>0;i--)
1580  {
1581  for(j=r;j>0;j--)
1582  {
1583  M(i,j)=convSingPFactoryP(MATELEM(m,i,j),s);
1584  }
1585  }
1586  res= convFactoryPSingP( determinant(M,r),s ) ;
1587  Off(SW_RATIONAL);
1588  return res;
1589 }
int & rows()
Definition: matpol.h:24
const CanonicalForm int s
Definition: facAbsFact.cc:55
void Off(int sw)
switches
poly res
Definition: myNF.cc:322
#define M
Definition: sirandom.c:24
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
static const int SW_RATIONAL
set to 1 for computations over Q
Definition: cf_defs.h:28
int i
Definition: cfEzgcd.cc:123
int & cols()
Definition: matpol.h:25
#define NULL
Definition: omList.c:10
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
CanonicalForm determinant(const CFMatrix &M, int n)
Definition: cf_linsys.cc:222
polyrec * poly
Definition: hilb.h:10
void Werror(const char *fmt,...)
Definition: reporter.cc:189
#define MATELEM(mat, i, j)
Definition: matpol.h:29

◆ singclap_det_bi()

number singclap_det_bi ( bigintmat m,
const coeffs  cf 
)

Definition at line 1609 of file clapsing.cc.

1610 {
1611  assume(m->basecoeffs()==cf);
1612  CFMatrix M(m->rows(),m->cols());
1613  int i,j;
1614  BOOLEAN setchar=TRUE;
1615  for(i=m->rows();i>0;i--)
1616  {
1617  for(j=m->cols();j>0;j--)
1618  {
1619  M(i,j)=n_convSingNFactoryN(BIMATELEM(*m,i,j),setchar,cf);
1620  setchar=FALSE;
1621  }
1622  }
1623  number res=n_convFactoryNSingN( determinant(M,m->rows()),cf ) ;
1624  return res;
1625 }
#define FALSE
Definition: auxiliary.h:94
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:587
int rows() const
Definition: bigintmat.h:146
#define TRUE
Definition: auxiliary.h:98
CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: numbers.cc:592
poly res
Definition: myNF.cc:322
#define M
Definition: sirandom.c:24
int j
Definition: myNF.cc:70
#define assume(x)
Definition: mod2.h:394
int cols() const
Definition: bigintmat.h:145
int i
Definition: cfEzgcd.cc:123
#define BIMATELEM(M, I, J)
Definition: bigintmat.h:134
CanonicalForm cf
Definition: cfModGcd.cc:4024
coeffs basecoeffs() const
Definition: bigintmat.h:147
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  r 
)

Definition at line 1591 of file clapsing.cc.

1592 {
1593 // assume( r == currRing ); // Anything else is not guaranted to work!
1594 
1595  setCharacteristic( 0 ); // ?
1596  CFMatrix M(m->rows(),m->cols());
1597  int i,j;
1598  for(i=m->rows();i>0;i--)
1599  {
1600  for(j=m->cols();j>0;j--)
1601  {
1602  M(i,j)=IMATELEM(*m,i,j);
1603  }
1604  }
1605  int res= convFactoryISingI( determinant(M,m->rows()) ) ;
1606  return res;
1607 }
int rows() const
Definition: intvec.h:88
void setCharacteristic(int c)
Definition: cf_char.cc:23
poly res
Definition: myNF.cc:322
#define M
Definition: sirandom.c:24
int convFactoryISingI(const CanonicalForm &f)
Definition: clapconv.cc:114
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
CanonicalForm determinant(const CFMatrix &M, int n)
Definition: cf_linsys.cc:222
int cols() const
Definition: intvec.h:87
#define IMATELEM(M, I, J)
Definition: intvec.h:77

◆ singclap_divide_content()

void singclap_divide_content ( poly  f,
const ring  r 
)

Definition at line 586 of file clapsing.cc.

587 {
588  if ( f==NULL )
589  {
590  return;
591  }
592  else if ( pNext( f ) == NULL )
593  {
594  p_SetCoeff( f, n_Init( 1, r->cf ), r );
595  return;
596  }
597  else
598  {
599  if ( rField_is_Q_a(r) )
600  setCharacteristic( 0 );
601  else if ( rField_is_Zp_a(r) )
603  else
604  return; /* not implemented*/
605 
606  CFList L;
607  CanonicalForm g, h;
608  poly p = pNext(f);
609 
610  // first attemp: find 2 smallest g:
611 
612  number g1=pGetCoeff(f);
613  number g2=pGetCoeff(p); // p==pNext(f);
614  pIter(p);
615  int sz1=n_Size(g1, r->cf);
616  int sz2=n_Size(g2, r->cf);
617  if (sz1>sz2)
618  {
619  number gg=g1;
620  g1=g2; g2=gg;
621  int sz=sz1;
622  sz1=sz2; sz2=sz;
623  }
624  while (p!=NULL)
625  {
626  int n_sz=n_Size(pGetCoeff(p),r->cf);
627  if (n_sz<sz1)
628  {
629  sz2=sz1;
630  g2=g1;
631  g1=pGetCoeff(p);
632  sz1=n_sz;
633  if (sz1<=3) break;
634  }
635  else if(n_sz<sz2)
636  {
637  sz2=n_sz;
638  g2=pGetCoeff(p);
639  sz2=n_sz;
640  }
641  pIter(p);
642  }
643  g = convSingPFactoryP( NUM(((fraction)g1)), r->cf->extRing );
644  g = gcd( g, convSingPFactoryP( NUM(((fraction)g2)) , r->cf->extRing));
645 
646  // second run: gcd's
647 
648  p = f;
649  while ( (p != NULL) && (g != 1) && ( g != 0))
650  {
651  h = convSingPFactoryP( NUM(((fraction)pGetCoeff(p))), r->cf->extRing );
652  pIter( p );
653 
654  g = gcd( g, h );
655 
656  L.append( h );
657  }
658  if (( g == 1 ) || (g == 0))
659  {
660  // pTest(f);
661  return;
662  }
663  else
664  {
666  for ( i = L, p = f; i.hasItem(); i++, p=pNext(p) )
667  {
668  fraction c=(fraction)pGetCoeff(p);
669  p_Delete(&(NUM(c)),r->cf->extRing); // 2nd arg used to be nacRing
670  NUM(c)=convFactoryPSingP( i.getItem() / g, r->cf->extRing );
671  //nTest((number)c);
672  //#ifdef LDEBUG
673  //number cn=(number)c;
674  //StringSetS(""); nWrite(nt); StringAppend(" ==> ");
675  //nWrite(cn);PrintS(StringEndS("\n")); // NOTE/TODO: use StringAppendS("\n"); omFree(s);
676  //#endif
677  }
678  }
679  // pTest(f);
680  }
681 }
static BOOLEAN rField_is_Zp_a(const ring r)
Definition: ring.h:521
return P p
Definition: myNF.cc:203
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:542
int rChar(ring r)
Definition: ring.cc:686
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:531
factory&#39;s main class
Definition: canonicalform.h:75
g
Definition: cfModGcd.cc:4031
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
void setCharacteristic(int c)
Definition: cf_char.cc:23
#define pIter(p)
Definition: monomials.h:44
const ring r
Definition: syzextra.cc:208
T & getItem() const
Definition: ftmpl_list.cc:431
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
FILE * f
Definition: checklibs.c:9
int i
Definition: cfEzgcd.cc:123
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:843
#define NULL
Definition: omList.c:10
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
int gcd(int a, int b)
Definition: walkSupport.cc:839
#define pNext(p)
Definition: monomials.h:43
void append(const T &)
Definition: ftmpl_list.cc:256
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
static FORCE_INLINE int n_Size(number n, const coeffs r)
return a non-negative measure for the complexity of n; return 0 only when n represents zero; (used fo...
Definition: coeffs.h:574

◆ singclap_extgcd()

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

Definition at line 447 of file clapsing.cc.

448 {
449  // for now there is only the possibility to handle univariate
450  // polynomials over
451  // Q and Fp ...
452  res=NULL;pa=NULL;pb=NULL;
454  if ( rField_is_Q(r) || rField_is_Zp(r) )
455  {
458  CanonicalForm FpG=F+G;
459  if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
460  //if (!F.isUnivariate() || !G.isUnivariate() || F.mvar()!=G.mvar())
461  {
462  Off(SW_RATIONAL);
463  WerrorS("not univariate");
464  return TRUE;
465  }
466  CanonicalForm Fa,Gb;
467  On(SW_RATIONAL);
468  res=convFactoryPSingP( extgcd( F, G, Fa, Gb ),r );
469  pa=convFactoryPSingP(Fa,r);
470  pb=convFactoryPSingP(Gb,r);
471  Off(SW_RATIONAL);
472  }
473  // and over Q(a) / Fp(a)
474  else if ( r->cf->extRing!=NULL )
475  {
476  if (rField_is_Q_a(r)) setCharacteristic( 0 );
477  else setCharacteristic( rChar(r) );
478  CanonicalForm Fa,Gb;
479  if (r->cf->extRing->qideal!=NULL)
480  {
481  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
482  r->cf->extRing);
483  Variable a=rootOf(mipo);
485  G( convSingAPFactoryAP( g,a,r ) );
486  CanonicalForm FpG=F+G;
487  if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
488  //if (!F.isUnivariate() || !G.isUnivariate() || F.mvar()!=G.mvar())
489  {
490  WerrorS("not univariate");
491  return TRUE;
492  }
493  res= convFactoryAPSingAP( extgcd( F, G, Fa, Gb ),r );
494  pa=convFactoryAPSingAP(Fa,r);
495  pb=convFactoryAPSingAP(Gb,r);
496  prune (a);
497  }
498  else
499  {
501  CanonicalForm FpG=F+G;
502  if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
503  //if (!F.isUnivariate() || !G.isUnivariate() || F.mvar()!=G.mvar())
504  {
505  Off(SW_RATIONAL);
506  WerrorS("not univariate");
507  return TRUE;
508  }
509  res= convFactoryPSingTrP( extgcd( F, G, Fa, Gb ), r );
510  pa=convFactoryPSingTrP(Fa, r);
511  pb=convFactoryPSingTrP(Gb, r);
512  }
513  Off(SW_RATIONAL);
514  }
515  else
516  {
518  return TRUE;
519  }
520 #ifndef SING_NDEBUG
521  // checking the result of extgcd:
522  poly dummy;
523  dummy=p_Sub(p_Add_q(pp_Mult_qq(f,pa,r),pp_Mult_qq(g,pb,r),r),p_Copy(res,r),r);
524  if (dummy!=NULL)
525  {
526  PrintS("extgcd( ");p_Write(f,r);p_Write0(g,r);PrintS(" )\n");
527  PrintS("extgcd( ");p_Write(f,r);p_Write0(g,r);PrintS(" )\n");
528  p_Delete(&dummy,r);
529  }
530 #endif
531  return FALSE;
532 }
const poly a
Definition: syzextra.cc:212
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:120
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:115
int rChar(ring r)
Definition: ring.cc:686
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:288
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:324
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:531
factory&#39;s main class
Definition: canonicalform.h:75
#define TRUE
Definition: auxiliary.h:98
g
Definition: cfModGcd.cc:4031
void WerrorS(const char *s)
Definition: feFopen.cc:24
static TreeM * G
Definition: janet.cc:38
poly p_Sub(poly p1, poly p2, const ring r)
Definition: p_polys.cc:1943
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:804
void prune(Variable &alpha)
Definition: variable.cc:261
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 res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition: p_polys.h:1070
bool isUnivariate() const
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
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:196
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:843
#define NULL
Definition: omList.c:10
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
CanonicalForm mipo
Definition: facAlgExt.cc:57
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:206
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:155
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:877
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 771 of file clapsing.cc.

773 {
774  p_Test(f,r);
775 #ifdef FACTORIZE2_DEBUG
776  printf("singclap_factorize, degree %ld\n",p_Totaldegree(f,r));
777 #endif
778  // with_exps: 3,1 return only true factors, no exponents
779  // 2 return true factors and exponents
780  // 0 return coeff, factors and exponents
781  BOOLEAN save_errorreported=errorreported;
782 
783  ideal res=NULL;
784 
785  // handle factorize(0) =========================================
786  if (f==NULL)
787  {
788  res=idInit(1,1);
789  if (with_exps!=1)
790  {
791  (*v)=new intvec(1);
792  (**v)[0]=1;
793  }
794  return res;
795  }
796  // handle factorize(mon) =========================================
797  if (pNext(f)==NULL)
798  {
799  int i=0;
800  int n=0;
801  int e;
802  for(i=rVar(r);i>0;i--) if(p_GetExp(f,i,r)!=0) n++;
803  if (with_exps==0) n++; // with coeff
804  res=idInit(si_max(n,1),1);
805  switch(with_exps)
806  {
807  case 0: // with coef & exp.
808  res->m[0]=p_NSet(n_Copy(pGetCoeff(f),r->cf),r);
809  // no break
810  case 2: // with exp.
811  (*v)=new intvec(si_max(1,n));
812  (**v)[0]=1;
813  // no break
814  case 1: ;
815 #ifdef TEST
816  default: ;
817 #endif
818  }
819  if (n==0)
820  {
821  res->m[0]=p_One(r);
822  // (**v)[0]=1; is already done
823  }
824  else
825  {
826  for(i=rVar(r);i>0;i--)
827  {
828  e=p_GetExp(f,i,r);
829  if(e!=0)
830  {
831  n--;
832  poly p=p_One(r);
833  p_SetExp(p,i,1,r);
834  p_Setm(p,r);
835  res->m[n]=p;
836  if (with_exps!=1) (**v)[n]=e;
837  }
838  }
839  }
840  p_Delete(&f,r);
841  return res;
842  }
843  //PrintS("S:");p_Write(f,r);PrintLn();
844  // use factory/libfac in general ==============================
845  Off(SW_RATIONAL);
847  CFFList L;
848  number N=NULL;
849  number NN=NULL;
850  number old_lead_coeff=n_Copy(pGetCoeff(f), r->cf);
851 
852  Variable a;
853  if (!rField_is_Zp(r) && !rField_is_Zp_a(r) && !rField_is_Z(r)) /* Q, Q(a) */
854  {
855  //if (f!=NULL) // already tested at start of routine
856  {
857  number n0=n_Copy(pGetCoeff(f),r->cf);
858  if (with_exps==0)
859  N=n_Copy(n0,r->cf);
860  p_Cleardenom(f, r);
861  //after here f should not have a denominator!!
862  //PrintS("S:");p_Write(f,r);PrintLn();
863  NN=n_Div(n0,pGetCoeff(f),r->cf);
864  n_Delete(&n0,r->cf);
865  if (with_exps==0)
866  {
867  n_Delete(&N,r->cf);
868  N=n_Copy(NN,r->cf);
869  }
870  }
871  }
872  else if (rField_is_Zp_a(r))
873  {
874  //if (f!=NULL) // already tested at start of routine
876  {
877  number n0=n_Copy(pGetCoeff(f),r->cf);
878  if (with_exps==0)
879  N=n_Copy(n0,r->cf);
880  p_Norm(f,r);
881  p_Cleardenom(f, r);
882  NN=n_Div(n0,pGetCoeff(f),r->cf);
883  n_Delete(&n0,r->cf);
884  if (with_exps==0)
885  {
886  n_Delete(&N,r->cf);
887  N=n_Copy(NN,r->cf);
888  }
889  }
890  }
891  if (rField_is_Q(r) || rField_is_Zp(r) || (rField_is_Z(r)))
892  {
895  L = factorize( F );
896  }
897  // and over Q(a) / Fp(a)
898  else if (r->cf->extRing!=NULL)
899  {
900  if (rField_is_Q_a (r)) setCharacteristic (0);
901  else setCharacteristic( rChar(r) );
902  if (r->cf->extRing->qideal!=NULL)
903  {
904  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
905  r->cf->extRing);
906  a=rootOf(mipo);
907  CanonicalForm F( convSingAPFactoryAP( f, a, r ) );
908  if (rField_is_Zp_a(r))
909  {
910  L = factorize( F, a );
911  }
912  else
913  {
914  // over Q(a)
915  L= factorize (F, a);
916  }
917  }
918  else
919  {
921  L = factorize( F );
922  }
923  }
924  else
925  {
926  goto notImpl;
927  }
928  {
929  poly ff=p_Copy(f,r); // a copy for the retry stuff
930  // the first factor should be a constant
931  if ( ! L.getFirst().factor().inCoeffDomain() )
932  L.insert(CFFactor(1,1));
933  // convert into ideal
934  int n = L.length();
935  if (n==0) n=1;
936  CFFListIterator J=L;
937  int j=0;
938  if (with_exps!=1)
939  {
940  if ((with_exps==2)&&(n>1))
941  {
942  n--;
943  J++;
944  }
945  *v = new intvec( n );
946  }
947  res = idInit( n ,1);
948  for ( ; J.hasItem(); J++, j++ )
949  {
950  if (with_exps!=1) (**v)[j] = J.getItem().exp();
951  if (rField_is_Zp(r) || rField_is_Q(r)|| rField_is_Z(r)) /* Q, Fp, Z */
952  {
953  //count_Factors(res,*v,f, j, convFactoryPSingP( J.getItem().factor() );
954  res->m[j] = convFactoryPSingP( J.getItem().factor(),r );
955  }
956 #if 0
957  else if (rField_is_GF())
958  res->m[j] = convFactoryGFSingGF( J.getItem().factor() );
959 #endif
960  else if (r->cf->extRing!=NULL) /* Q(a), Fp(a) */
961  {
962 #ifndef SING_NDEBUG
963  intvec *w=NULL;
964  if (v!=NULL) w=*v;
965 #endif
966  if (r->cf->extRing->qideal==NULL)
967  {
968 #ifdef SING_NDEBUG
969  res->m[j]= convFactoryPSingTrP( J.getItem().factor(),r );
970 #else
971  if(!count_Factors(res,w,j,ff,convFactoryPSingTrP( J.getItem().factor(),r ),r))
972  {
973  if (w!=NULL)
974  (*w)[j]=1;
975  res->m[j]=p_One(r);
976  }
977 #endif
978  }
979  else
980  {
981 #ifdef SING_NDEBUG
982  res->m[j]= convFactoryAPSingAP( J.getItem().factor(),r );
983 #else
984  if (!count_Factors(res,w,j,ff,convFactoryAPSingAP( J.getItem().factor(),r ),r))
985  {
986  if (w!=NULL)
987  (*w)[j]=1;
988  res->m[j]=p_One(r);
989  }
990 #endif
991  }
992  }
993  }
994  if (r->cf->extRing!=NULL)
995  if (r->cf->extRing->qideal!=NULL)
996  prune (a);
997 #ifndef SING_NDEBUG
998  if ((r->cf->extRing!=NULL) && (!p_IsConstantPoly(ff,r)))
999  {
1002  {
1003  int jj;
1004 #ifdef FACTORIZE2_DEBUG
1005  printf("factorize_retry\n");
1006 #endif
1007  intvec *ww=NULL;
1008  id_Test(res,r);
1009  ideal h=singclap_factorize ( ff, &ww , with_exps, r );
1010  id_Test(h,r);
1011  int l=(*v)->length();
1012  (*v)->resize(l+ww->length());
1013  for(jj=0;jj<ww->length();jj++)
1014  (**v)[jj+l]=(*ww)[jj];
1015  delete ww;
1016  ideal hh=idInit(IDELEMS(res)+IDELEMS(h),1);
1017  for(jj=IDELEMS(res)-1;jj>=0;jj--)
1018  {
1019  hh->m[jj]=res->m[jj];
1020  res->m[jj]=NULL;
1021  }
1022  for(jj=IDELEMS(h)-1;jj>=0;jj--)
1023  {
1024  hh->m[jj+IDELEMS(res)]=h->m[jj];
1025  h->m[jj]=NULL;
1026  }
1027  id_Delete(&res,r);
1028  id_Delete(&h,r);
1029  res=hh;
1030  id_Test(res,r);
1031  ff=NULL;
1032  }
1033  else
1034  {
1035  WarnS("problem with factorize");
1036 #if 0
1037  pWrite(ff);
1038  idShow(res);
1039 #endif
1040  id_Delete(&res,r);
1041  res=idInit(2,1);
1042  res->m[0]=p_One(r);
1043  res->m[1]=ff; ff=NULL;
1044  }
1045  }
1046 #endif
1047  p_Delete(&ff,r);
1048  if (N!=NULL)
1049  {
1050  p_Mult_nn(res->m[0],N,r);
1051  n_Delete(&N,r->cf);
1052  N=NULL;
1053  }
1054  // delete constants
1055  if (res!=NULL)
1056  {
1057  int i=IDELEMS(res)-1;
1058  int j=0;
1059  for(;i>=0;i--)
1060  {
1061  if ((res->m[i]!=NULL)
1062  && (pNext(res->m[i])==NULL)
1063  && (p_IsConstant(res->m[i],r)))
1064  {
1065  if (with_exps!=0)
1066  {
1067  p_Delete(&(res->m[i]),r);
1068  if ((v!=NULL) && ((*v)!=NULL))
1069  (**v)[i]=0;
1070  j++;
1071  }
1072  else if (i!=0)
1073  {
1074  while ((v!=NULL) && ((*v)!=NULL) && ((**v)[i]>1))
1075  {
1076  res->m[0]=p_Mult_q(res->m[0],p_Copy(res->m[i],r),r);
1077  (**v)[i]--;
1078  }
1079  res->m[0]=p_Mult_q(res->m[0],res->m[i],r);
1080  res->m[i]=NULL;
1081  if ((v!=NULL) && ((*v)!=NULL))
1082  (**v)[i]=1;
1083  j++;
1084  }
1085  }
1086  }
1087  if (j>0)
1088  {
1089  idSkipZeroes(res);
1090  if ((v!=NULL) && ((*v)!=NULL))
1091  {
1092  intvec *w=*v;
1093  int len=IDELEMS(res);
1094  *v = new intvec( len );
1095  for (i=0,j=0;i<si_min(w->length(),len);i++)
1096  {
1097  if((*w)[i]!=0)
1098  {
1099  (**v)[j]=(*w)[i]; j++;
1100  }
1101  }
1102  delete w;
1103  }
1104  }
1105  if (res->m[0]==NULL)
1106  {
1107  res->m[0]=p_One(r);
1108  }
1109  }
1110  }
1111  if (rField_is_Q_a(r) && (r->cf->extRing->qideal!=NULL))
1112  {
1113  int i=IDELEMS(res)-1;
1114  int stop=1;
1115  if (with_exps!=0) stop=0;
1116  for(;i>=stop;i--)
1117  {
1118  p_Norm(res->m[i],r);
1119  }
1120  if (with_exps==0) p_SetCoeff(res->m[0],old_lead_coeff,r);
1121  else n_Delete(&old_lead_coeff,r->cf);
1122  }
1123  else
1124  n_Delete(&old_lead_coeff,r->cf);
1125  errorreported=save_errorreported;
1126 notImpl:
1127  if (res==NULL)
1129  if (NN!=NULL)
1130  {
1131  n_Delete(&NN,r->cf);
1132  }
1133  if (N!=NULL)
1134  {
1135  n_Delete(&N,r->cf);
1136  }
1137  if (f!=NULL) p_Delete(&f,r);
1138  //PrintS("......S\n");
1139  return res;
1140 }
const poly a
Definition: syzextra.cc:212
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:120
void Off(int sw)
switches
static BOOLEAN rField_is_Zp_a(const ring r)
Definition: ring.h:521
static int si_min(const int a, const int b)
Definition: auxiliary.h:121
return P p
Definition: myNF.cc:203
factory&#39;s class for variables
Definition: factory.h:115
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1442
#define id_Test(A, lR)
Definition: simpleideals.h:80
int rChar(ring r)
Definition: ring.cc:686
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:288
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:324
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:531
factory&#39;s main class
Definition: canonicalform.h:75
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1430
void pWrite(poly p)
Definition: polys.h:290
void WerrorS(const char *s)
Definition: feFopen.cc:24
static BOOLEAN rField_is_GF(const ring r)
Definition: ring.h:513
static BOOLEAN rField_is_Z(const ring r)
Definition: ring.h:504
void p_Norm(poly p1, const ring r)
Definition: p_polys.cc:3619
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:51
#define WarnS
Definition: emacs.cc:81
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
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:804
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:60
T getFirst() const
Definition: ftmpl_list.cc:279
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 res
Definition: myNF.cc:322
BOOLEAN count_Factors(ideal I, intvec *v, int j, poly &f, poly fac, const ring r)
Definition: clapsing.cc:683
CFFList factorize(const CanonicalForm &f, bool issqrfree=false)
factorization over or
Definition: cf_factor.cc:390
const ring r
Definition: syzextra.cc:208
Definition: intvec.h:14
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
poly p_One(const ring r)
Definition: p_polys.cc:1312
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:464
int j
Definition: myNF.cc:70
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1876
T & getItem() const
Definition: ftmpl_list.cc:431
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
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:120
FILE * f
Definition: checklibs.c:9
int i
Definition: cfEzgcd.cc:123
static poly p_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:895
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
#define IDELEMS(i)
Definition: simpleideals.h:24
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
#define p_Test(p, r)
Definition: p_polys.h:160
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:843
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
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:483
#define NULL
Definition: omList.c:10
int length() const
Definition: ftmpl_list.cc:273
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
int length() const
Definition: intvec.h:86
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:455
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:619
const CanonicalForm & w
Definition: facAbsFact.cc:55
static BOOLEAN p_IsConstantPoly(const poly p, const ring r)
Definition: p_polys.h:1890
#define pNext(p)
Definition: monomials.h:43
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
int singclap_factorize_retry
Definition: clapsing.cc:769
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
ideal singclap_factorize(poly f, intvec **v, int with_exps, const ring r)
Definition: clapsing.cc:771
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:155
polyrec * poly
Definition: hilb.h:10
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:978
int BOOLEAN
Definition: auxiliary.h:85
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2747
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1020
int l
Definition: cfEzgcd.cc:94

◆ singclap_gcd()

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

destroys f and g

Definition at line 264 of file clapsing.cc.

265 {
266  poly res=NULL;
267 
268  if (f!=NULL)
269  {
270  //if (r->cf->has_simple_Inverse) p_Norm(f,r);
271  if (rField_is_Zp(r)) p_Norm(f,r);
272  else p_Cleardenom(f, r);
273  }
274  if (g!=NULL)
275  {
276  //if (r->cf->has_simple_Inverse) p_Norm(g,r);
277  if (rField_is_Zp(r)) p_Norm(g,r);
278  else p_Cleardenom(g, r);
279  }
280  else return f; // g==0 => gcd=f (but do a p_Cleardenom/pNorm)
281  if (f==NULL) return g; // f==0 => gcd=g (but do a p_Cleardenom/pNorm)
282 
283  res=singclap_gcd_r(f,g,r);
284  p_Delete(&f, r);
285  p_Delete(&g, r);
286  return res;
287 }
poly singclap_gcd_r(poly f, poly g, const ring r)
Definition: clapsing.cc:52
g
Definition: cfModGcd.cc:4031
void p_Norm(poly p1, const ring r)
Definition: p_polys.cc:3619
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
FILE * f
Definition: checklibs.c:9
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:843
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2747

◆ 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 105 of file clapsing.cc.

106 {
107  poly res=NULL;
108 
109  if (g == NULL)
110  {
111  res= f;
112  f=p_One (r);
113  return res;
114  }
115  if (f==NULL)
116  {
117  res= g;
118  g=p_One (r);
119  return res;
120  }
121  if (pNext(g)==NULL)
122  {
123  poly G=p_GcdMon(g,f,r);
124  if (!n_IsOne(pGetCoeff(G),r->cf)
125  || (!p_IsConstant(G,r)))
126  {
127  f=p_Div_mm(f,G,r);
128  g=p_Div_mm(g,G,r);
129  }
130  return G;
131  }
132  else if (pNext(f)==NULL)
133  {
134  poly G=p_GcdMon(f,g,r);
135  if (!n_IsOne(pGetCoeff(G),r->cf)
136  || (!p_IsConstant(G,r)))
137  {
138  f=p_Div_mm(f,G,r);
139  g=p_Div_mm(g,G,r);
140  }
141  return G;
142  }
143 
144  Off(SW_RATIONAL);
145  CanonicalForm F,G,GCD;
146  if (rField_is_Q(r) || (rField_is_Zp(r)))
147  {
148  bool b1=isOn(SW_USE_EZGCD_P);
150  F=convSingPFactoryP( f,r );
151  G=convSingPFactoryP( g,r );
152  GCD=gcd(F,G);
153  if (!GCD.isOne())
154  {
155  p_Delete(&f,r);
156  p_Delete(&g,r);
157  if (getCharacteristic() == 0)
158  On (SW_RATIONAL);
159  F /= GCD;
160  G /= GCD;
161  if (getCharacteristic() == 0)
162  {
163  CanonicalForm denF= bCommonDen (F);
164  CanonicalForm denG= bCommonDen (G);
165  G *= denG;
166  F *= denF;
167  Off (SW_RATIONAL);
168  CanonicalForm gcddenFdenG= gcd (denG, denF);
169  denG /= gcddenFdenG;
170  denF /= gcddenFdenG;
171  On (SW_RATIONAL);
172  G *= denF;
173  F *= denG;
174  }
175  f=convFactoryPSingP( F, r);
176  g=convFactoryPSingP( G, r);
177  }
178  res=convFactoryPSingP( GCD , r);
179  if (!b1) Off (SW_USE_EZGCD_P);
180  }
181  // and over Q(a) / Fp(a)
182  else if ( r->cf->extRing )
183  {
184  if ( rField_is_Q_a(r)) setCharacteristic( 0 );
185  else setCharacteristic( rChar(r) );
186  if (r->cf->extRing->qideal!=NULL)
187  {
188  bool b1=isOn(SW_USE_QGCD);
189  if ( rField_is_Q_a(r) ) On(SW_USE_QGCD);
190  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
191  r->cf->extRing);
192  Variable a=rootOf(mipo);
193  F=( convSingAPFactoryAP( f,a,r ) );
194  G=( convSingAPFactoryAP( g,a,r ) );
195  GCD=gcd(F,G);
196  if (!GCD.isOne())
197  {
198  p_Delete(&f,r);
199  p_Delete(&g,r);
200  if (getCharacteristic() == 0)
201  On (SW_RATIONAL);
202  F /= GCD;
203  G /= GCD;
204  if (getCharacteristic() == 0)
205  {
206  CanonicalForm denF= bCommonDen (F);
207  CanonicalForm denG= bCommonDen (G);
208  G *= denG;
209  F *= denF;
210  Off (SW_RATIONAL);
211  CanonicalForm gcddenFdenG= gcd (denG, denF);
212  denG /= gcddenFdenG;
213  denF /= gcddenFdenG;
214  On (SW_RATIONAL);
215  G *= denF;
216  F *= denG;
217  }
218  f= convFactoryAPSingAP( F,r );
219  g= convFactoryAPSingAP( G,r );
220  }
221  res= convFactoryAPSingAP( GCD,r );
222  prune (a);
223  if (!b1) Off(SW_USE_QGCD);
224  }
225  else
226  {
227  F=( convSingTrPFactoryP( f,r ) );
228  G=( convSingTrPFactoryP( g,r ) );
229  GCD=gcd(F,G);
230  if (!GCD.isOne())
231  {
232  p_Delete(&f,r);
233  p_Delete(&g,r);
234  if (getCharacteristic() == 0)
235  On (SW_RATIONAL);
236  F /= GCD;
237  G /= GCD;
238  if (getCharacteristic() == 0)
239  {
240  CanonicalForm denF= bCommonDen (F);
241  CanonicalForm denG= bCommonDen (G);
242  G *= denG;
243  F *= denF;
244  Off (SW_RATIONAL);
245  CanonicalForm gcddenFdenG= gcd (denG, denF);
246  denG /= gcddenFdenG;
247  denF /= gcddenFdenG;
248  On (SW_RATIONAL);
249  G *= denF;
250  F *= denG;
251  }
252  f= convFactoryPSingTrP( F,r );
253  g= convFactoryPSingTrP( G,r );
254  }
255  res= convFactoryPSingTrP( GCD,r );
256  }
257  }
258  else
260  Off(SW_RATIONAL);
261  return res;
262 }
CF_NO_INLINE bool isOne() const
CF_INLINE bool CanonicalForm::isOne, isZero () const.
Definition: cf_inline.cc:354
const poly a
Definition: syzextra.cc:212
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:120
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:1507
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:472
factory&#39;s class for variables
Definition: factory.h:115
poly p_GcdMon(poly f, poly g, const ring r)
polynomial gcd for f=mon
Definition: p_polys.cc:4786
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:686
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:288
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:324
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:531
factory&#39;s main class
Definition: canonicalform.h:75
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:51
static TreeM * G
Definition: janet.cc:38
void setCharacteristic(int c)
Definition: cf_char.cc:23
int getCharacteristic()
Definition: cf_char.cc:51
void prune(Variable &alpha)
Definition: variable.cc:261
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 res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
poly p_One(const ring r)
Definition: p_polys.cc:1312
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1876
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
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:843
#define NULL
Definition: omList.c:10
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
CanonicalForm mipo
Definition: facAlgExt.cc:57
int gcd(int a, int b)
Definition: walkSupport.cc:839
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:43
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:155
polyrec * poly
Definition: hilb.h:10

◆ singclap_gcd_r()

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

Definition at line 52 of file clapsing.cc.

53 {
54  poly res=NULL;
55 
56  assume(f!=NULL);
57  assume(g!=NULL);
58 
59  if(pNext(f)==NULL)
60  {
61  return p_GcdMon(f,g,r);
62  }
63  else if(pNext(g)==NULL)
64  {
65  return p_GcdMon(g,f,r);
66  }
67 
70  {
73  res=convFactoryPSingP( gcd( F, G ) , r);
74  }
75  // and over Q(a) / Fp(a)
76  else if ( r->cf->extRing!=NULL )
77  {
78  if ( rField_is_Q_a(r)) setCharacteristic( 0 );
79  else setCharacteristic( rChar(r) );
80  if (r->cf->extRing->qideal!=NULL)
81  {
82  bool b1=isOn(SW_USE_QGCD);
83  if ( rField_is_Q_a(r) ) On(SW_USE_QGCD);
84  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
85  r->cf->extRing);
86  Variable a=rootOf(mipo);
88  G( convSingAPFactoryAP( g,a,r ) );
89  res= convFactoryAPSingAP( gcd( F, G ),r );
90  prune (a);
91  if (!b1) Off(SW_USE_QGCD);
92  }
93  else
94  {
96  res= convFactoryPSingTrP( gcd( F, G ),r );
97  }
98  }
99  else
101  Off(SW_RATIONAL);
102  return res;
103 }
const poly a
Definition: syzextra.cc:212
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:120
void Off(int sw)
switches
factory&#39;s class for variables
Definition: factory.h:115
poly p_GcdMon(poly f, poly g, const ring r)
polynomial gcd for f=mon
Definition: p_polys.cc:4786
int rChar(ring r)
Definition: ring.cc:686
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:288
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:324
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:531
factory&#39;s main class
Definition: canonicalform.h:75
g
Definition: cfModGcd.cc:4031
void WerrorS(const char *s)
Definition: feFopen.cc:24
static TreeM * G
Definition: janet.cc:38
void setCharacteristic(int c)
Definition: cf_char.cc:23
void prune(Variable &alpha)
Definition: variable.cc:261
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 res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:394
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
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:10
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
CanonicalForm mipo
Definition: facAlgExt.cc:57
int gcd(int a, int b)
Definition: walkSupport.cc:839
static const int SW_USE_QGCD
set to 1 to use Encarnacion GCD over Q(a)
Definition: cf_defs.h:40
static BOOLEAN rField_is_Ring_Z(const ring r)
Definition: ring.h:474
#define pNext(p)
Definition: monomials.h:43
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:155
polyrec * poly
Definition: hilb.h:10

◆ singclap_irrCharSeries()

matrix singclap_irrCharSeries ( ideal  I,
const ring  r 
)

Definition at line 1385 of file clapsing.cc.

1386 {
1387  if (idIs0(I)) return mpNew(1,1);
1388 
1389  // for now there is only the possibility to handle polynomials over
1390  // Q and Fp ...
1391  matrix res=NULL;
1392  int i;
1393  Off(SW_RATIONAL);
1395  CFList L;
1396  ListCFList LL;
1397  if (rField_is_Q(r) || rField_is_Zp(r))
1398  {
1400  for(i=0;i<IDELEMS(I);i++)
1401  {
1402  poly p=I->m[i];
1403  if (p!=NULL)
1404  {
1405  p=p_Copy(p,r);
1406  p_Cleardenom(p, r);
1407  L.append(convSingPFactoryP(p,r));
1408  p_Delete(&p,r);
1409  }
1410  }
1411  }
1412  // and over Q(a) / Fp(a)
1413  else if (nCoeff_is_transExt (r->cf))
1414  {
1416  for(i=0;i<IDELEMS(I);i++)
1417  {
1418  poly p=I->m[i];
1419  if (p!=NULL)
1420  {
1421  p=p_Copy(p,r);
1422  p_Cleardenom(p, r);
1424  p_Delete(&p,r);
1425  }
1426  }
1427  }
1428  else
1429  {
1431  return res;
1432  }
1433 
1434  // a very bad work-around --- FIX IT in libfac
1435  // should be fixed as of 2001/6/27
1436  int tries=0;
1437  int m,n;
1439  loop
1440  {
1441  LL=irrCharSeries(L);
1442  m= LL.length(); // Anzahl Zeilen
1443  n=0;
1444  for ( LLi = LL; LLi.hasItem(); LLi++ )
1445  {
1446  n = si_max(LLi.getItem().length(),n);
1447  }
1448  if ((m!=0) && (n!=0)) break;
1449  tries++;
1450  if (tries>=5) break;
1451  }
1452  if ((m==0) || (n==0))
1453  {
1454  Warn("char_series returns %d x %d matrix from %d input polys (%d)",
1455  m,n,IDELEMS(I)+1,LL.length());
1456  iiWriteMatrix((matrix)I,"I",2,r,0);
1457  m=si_max(m,1);
1458  n=si_max(n,1);
1459  }
1460  res=mpNew(m,n);
1461  CFListIterator Li;
1462  for ( m=1, LLi = LL; LLi.hasItem(); LLi++, m++ )
1463  {
1464  for (n=1, Li = LLi.getItem(); Li.hasItem(); Li++, n++)
1465  {
1466  if (rField_is_Q(r) || rField_is_Zp(r))
1467  MATELEM(res,m,n)=convFactoryPSingP(Li.getItem(),r);
1468  else
1469  MATELEM(res,m,n)=convFactoryPSingTrP(Li.getItem(),r);
1470  }
1471  }
1472  Off(SW_RATIONAL);
1473  return res;
1474 }
void Off(int sw)
switches
loop
Definition: myNF.cc:98
return P p
Definition: myNF.cc:203
int rChar(ring r)
Definition: ring.cc:686
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:288
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:324
ListCFList irrCharSeries(const CFList &PS)
irreducible characteristic series
Definition: cfCharSets.cc:568
void WerrorS(const char *s)
Definition: feFopen.cc:24
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:804
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
Definition: matpol.cc:746
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
T & getItem() const
Definition: ftmpl_list.cc:431
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
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:119
void On(int sw)
switches
static int si_max(const int a, const int b)
Definition: auxiliary.h:120
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:935
int i
Definition: cfEzgcd.cc:123
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
#define IDELEMS(i)
Definition: simpleideals.h:24
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:47
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:843
#define NULL
Definition: omList.c:10
int length() const
Definition: ftmpl_list.cc:273
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
void append(const T &)
Definition: ftmpl_list.cc:256
polyrec * poly
Definition: hilb.h:10
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:2747
#define MATELEM(mat, i, j)
Definition: matpol.h:29
#define Warn
Definition: emacs.cc:80

◆ singclap_neworder()

char* singclap_neworder ( ideal  I,
const ring  r 
)

Definition at line 1476 of file clapsing.cc.

1477 {
1478  int i;
1479  Off(SW_RATIONAL);
1481  CFList L;
1482  if (rField_is_Q(r) || rField_is_Zp(r))
1483  {
1485  for(i=0;i<IDELEMS(I);i++)
1486  {
1487  poly p=I->m[i];
1488  if (p!=NULL)
1489  {
1490  p=p_Copy(p,r);
1491  p_Cleardenom(p, r);
1492  L.append(convSingPFactoryP(p,r));
1493  }
1494  }
1495  }
1496  // and over Q(a) / Fp(a)
1497  else if (nCoeff_is_transExt (r->cf))
1498  {
1500  for(i=0;i<IDELEMS(I);i++)
1501  {
1502  poly p=I->m[i];
1503  if (p!=NULL)
1504  {
1505  p=p_Copy(p,r);
1506  p_Cleardenom(p, r);
1508  }
1509  }
1510  }
1511  else
1512  {
1514  return NULL;
1515  }
1516 
1517  List<int> IL=neworderint(L);
1518  ListIterator<int> Li;
1519  StringSetS("");
1520  Li = IL;
1521  int offs=rPar(r);
1522  int* mark=(int*)omAlloc0((rVar(r)+offs)*sizeof(int));
1523  int cnt=rVar(r)+offs;
1524  loop
1525  {
1526  if(! Li.hasItem()) break;
1527  BOOLEAN done=TRUE;
1528  i=Li.getItem()-1;
1529  mark[i]=1;
1530  if (i<offs)
1531  {
1532  done=FALSE;
1533  //StringAppendS(r->parameter[i]);
1534  }
1535  else
1536  {
1537  StringAppendS(r->names[i-offs]);
1538  }
1539  Li++;
1540  cnt--;
1541  if(cnt==0) break;
1542  if (done) StringAppendS(",");
1543  }
1544  for(i=0;i<rVar(r)+offs;i++)
1545  {
1546  BOOLEAN done=TRUE;
1547  if(mark[i]==0)
1548  {
1549  if (i<offs)
1550  {
1551  done=FALSE;
1552  //StringAppendS(r->parameter[i]);
1553  }
1554  else
1555  {
1556  StringAppendS(r->names[i-offs]);
1557  }
1558  cnt--;
1559  if(cnt==0) break;
1560  if (done) StringAppendS(",");
1561  }
1562  }
1563  char * s=StringEndS();
1564  if (s[strlen(s)-1]==',') s[strlen(s)-1]='\0';
1565  return s;
1566 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
std::pair< int, int > mark
void Off(int sw)
switches
loop
Definition: myNF.cc:98
#define FALSE
Definition: auxiliary.h:94
return P p
Definition: myNF.cc:203
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:590
int rChar(ring r)
Definition: ring.cc:686
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:288
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
char * StringEndS()
Definition: reporter.cc:151
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:804
const ring r
Definition: syzextra.cc:208
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:935
int i
Definition: cfEzgcd.cc:123
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
#define IDELEMS(i)
Definition: simpleideals.h:24
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:495
#define NULL
Definition: omList.c:10
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
void append(const T &)
Definition: ftmpl_list.cc:256
polyrec * poly
Definition: hilb.h:10
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:2747
#define omAlloc0(size)
Definition: omAllocDecl.h:211

◆ singclap_pdivide()

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

Definition at line 534 of file clapsing.cc.

535 {
536  poly res=NULL;
537  On(SW_RATIONAL);
538  if (rField_is_Zp(r) || rField_is_Q(r))
539  {
542  res = convFactoryPSingP( F / G,r );
543  }
544  else if (rField_is_Ring_Z(r))
545  {
546  Off(SW_RATIONAL);
549  res = convFactoryPSingP( F / G,r );
550  }
551  else if (r->cf->extRing!=NULL)
552  {
553  if (rField_is_Q_a(r)) setCharacteristic( 0 );
554  else setCharacteristic( rChar(r) );
555  if (r->cf->extRing->qideal!=NULL)
556  {
557  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
558  r->cf->extRing);
559  Variable a=rootOf(mipo);
561  G( convSingAPFactoryAP( g,a,r ) );
562  res= convFactoryAPSingAP( F / G, r );
563  prune (a);
564  }
565  else
566  {
568  res= convFactoryPSingTrP( F / G,r );
569  }
570  }
571 #if 0 // not yet working
572  else if (rField_is_GF())
573  {
574  //Print("GF(%d^%d)\n",nfCharP,nfMinPoly[0]);
575  setCharacteristic( nfCharP,nfMinPoly[0], currRing->parameter[0][0] );
576  CanonicalForm F( convSingGFFactoryGF( f ) ), G( convSingGFFactoryGF( g ) );
577  res = convFactoryGFSingGF( F / G );
578  }
579 #endif
580  else
582  Off(SW_RATIONAL);
583  return res;
584 }
const poly a
Definition: syzextra.cc:212
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:120
void Off(int sw)
switches
factory&#39;s class for variables
Definition: factory.h:115
int rChar(ring r)
Definition: ring.cc:686
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:288
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:324
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:531
factory&#39;s main class
Definition: canonicalform.h:75
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:513
static TreeM * G
Definition: janet.cc:38
void setCharacteristic(int c)
Definition: cf_char.cc:23
void prune(Variable &alpha)
Definition: variable.cc:261
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 res
Definition: myNF.cc:322
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
const ring r
Definition: syzextra.cc:208
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
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:10
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
CanonicalForm mipo
Definition: facAlgExt.cc:57
static BOOLEAN rField_is_Ring_Z(const ring r)
Definition: ring.h:474
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:155
polyrec * poly
Definition: hilb.h:10
static int nfMinPoly[16]
Definition: ffields.cc:528

◆ singclap_resultant()

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

Definition at line 304 of file clapsing.cc.

305 {
306  poly res=NULL;
307  int i=p_IsPurePower(x, r);
308  if (i==0)
309  {
310  WerrorS("3rd argument must be a ring variable");
311  goto resultant_returns_res;
312  }
313  if ((f==NULL) || (g==NULL))
314  goto resultant_returns_res;
315  // for now there is only the possibility to handle polynomials over
316  // Q and Fp ...
317  if (rField_is_Zp(r) || rField_is_Q(r))
318  {
319  Variable X(i);
322  res=convFactoryPSingP( resultant( F, G, X),r );
323  Off(SW_RATIONAL);
324  goto resultant_returns_res;
325  }
326  // and over Q(a) / Fp(a)
327  else if (r->cf->extRing!=NULL)
328  {
329  if (rField_is_Q_a(r)) setCharacteristic( 0 );
330  else setCharacteristic( rChar(r) );
331  Variable X(i+rPar(r));
332  if (r->cf->extRing->qideal!=NULL)
333  {
334  //Variable X(i);
335  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
336  r->cf->extRing);
337  Variable a=rootOf(mipo);
339  G( convSingAPFactoryAP( g,a,r ) );
340  res= convFactoryAPSingAP( resultant( F, G, X ),r );
341  prune (a);
342  }
343  else
344  {
345  //Variable X(i+rPar(currRing));
346  number nf,ng;
348  int ef,eg;
349  ef=pGetExp_Var(f,i,r);
350  eg=pGetExp_Var(g,i,r);
352  res= convFactoryPSingTrP( resultant( F, G, X ),r );
353  if ((nf!=NULL)&&(!n_IsOne(nf,r->cf)))
354  {
355  number n=n_Invers(nf,r->cf);
356  while(eg>0)
357  {
358  res=p_Mult_nn(res,n,r);
359  eg--;
360  }
361  n_Delete(&n,r->cf);
362  }
363  n_Delete(&nf,r->cf);
364  if ((ng!=NULL)&&(!n_IsOne(ng,r->cf)))
365  {
366  number n=n_Invers(ng,r->cf);
367  while(ef>0)
368  {
369  res=p_Mult_nn(res,n,r);
370  ef--;
371  }
372  n_Delete(&n,r->cf);
373  }
374  n_Delete(&ng,r->cf);
375  }
376  Off(SW_RATIONAL);
377  goto resultant_returns_res;
378  }
379  else
381 resultant_returns_res:
382  p_Delete(&f,r);
383  p_Delete(&g,r);
384  p_Delete(&x,r);
385  return res;
386 }
const poly a
Definition: syzextra.cc:212
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:120
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:472
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:590
factory&#39;s class for variables
Definition: factory.h:115
int rChar(ring r)
Definition: ring.cc:686
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:288
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:324
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:531
factory&#39;s main class
Definition: canonicalform.h:75
g
Definition: cfModGcd.cc:4031
void WerrorS(const char *s)
Definition: feFopen.cc:24
static TreeM * G
Definition: janet.cc:38
void setCharacteristic(int c)
Definition: cf_char.cc:23
void prune(Variable &alpha)
Definition: variable.cc:261
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:2875
Definition: gnumpfl.cc:27
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
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:568
FILE * f
Definition: checklibs.c:9
int i
Definition: cfEzgcd.cc:123
static poly p_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:895
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:290
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:843
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
Definition: p_polys.cc:1225
#define NULL
Definition: omList.c:10
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
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:459
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:155
polyrec * poly
Definition: hilb.h:10
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 1142 of file clapsing.cc.

1143 {
1144  p_Test(f,r);
1145 #ifdef FACTORIZE2_DEBUG
1146  printf("singclap_sqrfree, degree %d\n",pTotaldegree(f));
1147 #endif
1148  // with_exps: 3,1 return only true factors, no exponents
1149  // 2 return true factors and exponents
1150  // 0 return coeff, factors and exponents
1151  BOOLEAN save_errorreported=errorreported;
1152 
1153  ideal res=NULL;
1154 
1155  // handle factorize(0) =========================================
1156  if (f==NULL)
1157  {
1158  res=idInit(1,1);
1159  if (with_exps!=1 && with_exps!=3)
1160  {
1161  (*v)=new intvec(1);
1162  (**v)[0]=1;
1163  }
1164  return res;
1165  }
1166  // handle factorize(mon) =========================================
1167  if (pNext(f)==NULL)
1168  {
1169  int i=0;
1170  int n=0;
1171  int e;
1172  for(i=rVar(r);i>0;i--) if(p_GetExp(f,i,r)!=0) n++;
1173  if (with_exps==0 || with_exps==3) n++; // with coeff
1174  res=idInit(si_max(n,1),1);
1175  switch(with_exps)
1176  {
1177  case 0: // with coef & exp.
1178  res->m[0]=p_NSet(n_Copy(pGetCoeff(f),r->cf),r);
1179  // no break
1180  case 3: // with coef & exp.
1181  res->m[0]=p_NSet(n_Copy(pGetCoeff(f),r->cf),r);
1182  // no break
1183  case 2: // with exp.
1184  (*v)=new intvec(si_max(1,n));
1185  (**v)[0]=1;
1186  // no break
1187  case 1: ;
1188  #ifdef TEST
1189  default: ;
1190  #endif
1191  }
1192  res->m[0]=p_NSet(n_Copy(pGetCoeff(f),r->cf),r);
1193  if (n==0)
1194  {
1195  res->m[0]=p_One(r);
1196  // (**v)[0]=1; is already done
1197  }
1198  else
1199  {
1200  for(i=rVar(r);i>0;i--)
1201  {
1202  e=p_GetExp(f,i,r);
1203  if(e!=0)
1204  {
1205  n--;
1206  poly p=p_One(r);
1207  p_SetExp(p,i,1,r);
1208  p_Setm(p,r);
1209  res->m[n]=p;
1210  if (with_exps!=1) (**v)[n]=e;
1211  }
1212  }
1213  }
1214  p_Delete(&f,r);
1215  return res;
1216  }
1217  //PrintS("S:");pWrite(f);PrintLn();
1218  // use factory/libfac in general ==============================
1219  Off(SW_RATIONAL);
1221  CFFList L;
1222  number N=NULL;
1223  number NN=NULL;
1224  number old_lead_coeff=n_Copy(pGetCoeff(f), r->cf);
1225  Variable a;
1226 
1227  if (!rField_is_Zp(r) && !rField_is_Zp_a(r)) /* Q, Q(a) */
1228  {
1229  //if (f!=NULL) // already tested at start of routine
1230  number n0=n_Copy(pGetCoeff(f),r->cf);
1231  if (with_exps==0 || with_exps==3)
1232  N=n_Copy(n0,r->cf);
1233  p_Cleardenom(f, r);
1234  //after here f should not have a denominator!!
1235  //PrintS("S:");p_Write(f,r);PrintLn();
1236  NN=n_Div(n0,pGetCoeff(f),r->cf);
1237  n_Delete(&n0,r->cf);
1238  if (with_exps==0 || with_exps==3)
1239  {
1240  n_Delete(&N,r->cf);
1241  N=n_Copy(NN,r->cf);
1242  }
1243  }
1244  else if (rField_is_Zp_a(r))
1245  {
1246  //if (f!=NULL) // already tested at start of routine
1247  if (singclap_factorize_retry==0)
1248  {
1249  number n0=n_Copy(pGetCoeff(f),r->cf);
1250  if (with_exps==0 || with_exps==3)
1251  N=n_Copy(n0,r->cf);
1252  p_Norm(f,r);
1253  p_Cleardenom(f, r);
1254  NN=n_Div(n0,pGetCoeff(f),r->cf);
1255  n_Delete(&n0,r->cf);
1256  if (with_exps==0 || with_exps==3)
1257  {
1258  n_Delete(&N,r->cf);
1259  N=n_Copy(NN,r->cf);
1260  }
1261  }
1262  }
1263  if (rField_is_Q(r) || rField_is_Zp(r))
1264  {
1267  L = sqrFree( F );
1268  }
1269  else if (r->cf->extRing!=NULL)
1270  {
1271  if (rField_is_Q_a (r)) setCharacteristic (0);
1272  else setCharacteristic( rChar(r) );
1273  if (r->cf->extRing->qideal!=NULL)
1274  {
1275  CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->qideal->m[0],
1276  r->cf->extRing);
1277  a=rootOf(mipo);
1278  CanonicalForm F( convSingAPFactoryAP( f, a, r ) );
1279  L= sqrFree (F);
1280  }
1281  else
1282  {
1284  L = sqrFree( F );
1285  }
1286  }
1287  #if 0
1288  else if (rField_is_GF())
1289  {
1290  int c=rChar(r);
1291  setCharacteristic( c, primepower(c) );
1292  CanonicalForm F( convSingGFFactoryGF( f ) );
1293  if (F.isUnivariate())
1294  {
1295  L = factorize( F );
1296  }
1297  else
1298  {
1299  goto notImpl;
1300  }
1301  }
1302  #endif
1303  else
1304  {
1305  goto notImpl;
1306  }
1307  {
1308  // convert into ideal
1309  int n = L.length();
1310  if (n==0) n=1;
1311  CFFListIterator J=L;
1312  int j=0;
1313  if (with_exps!=1)
1314  {
1315  if ((with_exps==2)&&(n>1))
1316  {
1317  n--;
1318  J++;
1319  }
1320  *v = new intvec( n );
1321  }
1322  else if (L.getFirst().factor().inCoeffDomain() && with_exps!=3)
1323  {
1324  n--;
1325  J++;
1326  }
1327  res = idInit( n ,1);
1328  for ( ; J.hasItem(); J++, j++ )
1329  {
1330  if (with_exps!=1 && with_exps!=3) (**v)[j] = J.getItem().exp();
1331  if (rField_is_Zp(r) || rField_is_Q(r))
1332  res->m[j] = convFactoryPSingP( J.getItem().factor(),r );
1333  else if (r->cf->extRing!=NULL) /* Q(a), Fp(a) */
1334  {
1335  if (r->cf->extRing->qideal==NULL)
1336  res->m[j]=convFactoryPSingTrP( J.getItem().factor(),r );
1337  else
1338  res->m[j]=convFactoryAPSingAP( J.getItem().factor(),r );
1339  }
1340  }
1341  if (res->m[0]==NULL)
1342  {
1343  res->m[0]=p_One(r);
1344  }
1345  if (N!=NULL)
1346  {
1347  p_Mult_nn(res->m[0],N,r);
1348  n_Delete(&N,r->cf);
1349  N=NULL;
1350  }
1351  }
1352  if (r->cf->extRing!=NULL)
1353  if (r->cf->extRing->qideal!=NULL)
1354  prune (a);
1355  if (rField_is_Q_a(r) && (r->cf->extRing->qideal!=NULL))
1356  {
1357  int i=IDELEMS(res)-1;
1358  int stop=1;
1359  if (with_exps!=0 || with_exps==3) stop=0;
1360  for(;i>=stop;i--)
1361  {
1362  p_Norm(res->m[i],r);
1363  }
1364  if (with_exps==0 || with_exps==3) p_SetCoeff(res->m[0],old_lead_coeff,r);
1365  else n_Delete(&old_lead_coeff,r->cf);
1366  }
1367  else
1368  n_Delete(&old_lead_coeff,r->cf);
1369  p_Delete(&f,r);
1370  errorreported=save_errorreported;
1371 notImpl:
1372  if (res==NULL)
1374  if (NN!=NULL)
1375  {
1376  n_Delete(&NN,r->cf);
1377  }
1378  if (N!=NULL)
1379  {
1380  n_Delete(&N,r->cf);
1381  }
1382  return res;
1383 }
const poly a
Definition: syzextra.cc:212
CanonicalForm convSingAPFactoryAP(poly p, const Variable &a, const ring r)
Definition: clapconv.cc:120
void Off(int sw)
switches
static BOOLEAN rField_is_Zp_a(const ring r)
Definition: ring.h:521
return P p
Definition: myNF.cc:203
factory&#39;s class for variables
Definition: factory.h:115
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1442
int rChar(ring r)
Definition: ring.cc:686
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
CanonicalForm convSingTrPFactoryP(poly p, const ring r)
Definition: clapconv.cc:288
poly convFactoryPSingTrP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:324
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:531
factory&#39;s main class
Definition: canonicalform.h:75
void WerrorS(const char *s)
Definition: feFopen.cc:24
static BOOLEAN rField_is_GF(const ring r)
Definition: ring.h:513
void p_Norm(poly p1, const ring r)
Definition: p_polys.cc:3619
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:407
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
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 res
Definition: myNF.cc:322
CFFList factorize(const CanonicalForm &f, bool issqrfree=false)
factorization over or
Definition: cf_factor.cc:390
const ring r
Definition: syzextra.cc:208
Definition: intvec.h:14
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
poly p_One(const ring r)
Definition: p_polys.cc:1312
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:464
int j
Definition: myNF.cc:70
static long pTotaldegree(poly p)
Definition: polys.h:264
T & getItem() const
Definition: ftmpl_list.cc:431
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
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:120
FILE * f
Definition: checklibs.c:9
int i
Definition: cfEzgcd.cc:123
static poly p_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:895
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
#define IDELEMS(i)
Definition: simpleideals.h:24
#define p_Test(p, r)
Definition: p_polys.h:160
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:843
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
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:483
#define NULL
Definition: omList.c:10
int length() const
Definition: ftmpl_list.cc:273
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:455
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:619
#define pNext(p)
Definition: monomials.h:43
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
int singclap_factorize_retry
Definition: clapsing.cc:769
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
poly convFactoryAPSingAP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:155
polyrec * poly
Definition: hilb.h:10
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:2747
CFFList sqrFree(const CanonicalForm &f, bool sort=false)
squarefree factorization
Definition: cf_factor.cc:757

◆ singntl_HNF() [1/3]

matrix singntl_HNF ( matrix  A,
const ring  r 
)

Definition at line 1628 of file clapsing.cc.

1629 {
1630  int r=m->rows();
1631  if (r!=m->cols())
1632  {
1633  Werror("HNF of %d x %d matrix",r,m->cols());
1634  return NULL;
1635  }
1636 
1637  matrix res=mp_New(r,r);
1638 
1639  if (rField_is_Q(s))
1640  {
1641 
1642  CFMatrix M(r,r);
1643  int i,j;
1644  for(i=r;i>0;i--)
1645  {
1646  for(j=r;j>0;j--)
1647  {
1648  M(i,j)=convSingPFactoryP(MATELEM(m,i,j),s );
1649  }
1650  }
1651  CFMatrix *MM=cf_HNF(M);
1652  for(i=r;i>0;i--)
1653  {
1654  for(j=r;j>0;j--)
1655  {
1656  MATELEM(res,i,j)=convFactoryPSingP((*MM)(i,j),s);
1657  }
1658  }
1659  delete MM;
1660  }
1661  return res;
1662 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
poly res
Definition: myNF.cc:322
#define M
Definition: sirandom.c:24
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
int m
Definition: cfEzgcd.cc:119
int i
Definition: cfEzgcd.cc:123
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
static matrix mp_New(int r, int c)
Definition: matpol.h:35
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:10
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
void Werror(const char *fmt,...)
Definition: reporter.cc:189
#define MATELEM(mat, i, j)
Definition: matpol.h:29

◆ singntl_HNF() [2/3]

intvec* singntl_HNF ( intvec A)

Definition at line 1664 of file clapsing.cc.

1665 {
1666  int r=m->rows();
1667  if (r!=m->cols())
1668  {
1669  Werror("HNF of %d x %d matrix",r,m->cols());
1670  return NULL;
1671  }
1672  setCharacteristic( 0 );
1673  CFMatrix M(r,r);
1674  int i,j;
1675  for(i=r;i>0;i--)
1676  {
1677  for(j=r;j>0;j--)
1678  {
1679  M(i,j)=IMATELEM(*m,i,j);
1680  }
1681  }
1682  CFMatrix *MM=cf_HNF(M);
1683  intvec *mm=ivCopy(m);
1684  for(i=r;i>0;i--)
1685  {
1686  for(j=r;j>0;j--)
1687  {
1688  IMATELEM(*mm,i,j)=convFactoryISingI((*MM)(i,j));
1689  }
1690  }
1691  delete MM;
1692  return mm;
1693 }
intvec * ivCopy(const intvec *o)
Definition: intvec.h:126
void setCharacteristic(int c)
Definition: cf_char.cc:23
#define M
Definition: sirandom.c:24
const ring r
Definition: syzextra.cc:208
int convFactoryISingI(const CanonicalForm &f)
Definition: clapconv.cc:114
Definition: intvec.h:14
int j
Definition: myNF.cc:70
int m
Definition: cfEzgcd.cc:119
int i
Definition: cfEzgcd.cc:123
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:10
#define IMATELEM(M, I, J)
Definition: intvec.h:77
void Werror(const char *fmt,...)
Definition: reporter.cc:189

◆ singntl_HNF() [3/3]

bigintmat* singntl_HNF ( bigintmat A)

Definition at line 1695 of file clapsing.cc.

1696 {
1697  int r=b->rows();
1698  if (r!=b->cols())
1699  {
1700  Werror("HNF of %d x %d matrix",r,b->cols());
1701  return NULL;
1702  }
1703  setCharacteristic( 0 );
1704  CFMatrix M(r,r);
1705  int i,j;
1706  for(i=r;i>0;i--)
1707  {
1708  for(j=r;j>0;j--)
1709  {
1710  M(i,j)=n_convSingNFactoryN(BIMATELEM(*b,i,j),FALSE,b->basecoeffs());
1711  }
1712  }
1713  CFMatrix *MM=cf_HNF(M);
1714  bigintmat *mm=bimCopy(b);
1715  for(i=r;i>0;i--)
1716  {
1717  for(j=r;j>0;j--)
1718  {
1719  BIMATELEM(*mm,i,j)=n_convFactoryNSingN((*MM)(i,j),b->basecoeffs());
1720  }
1721  }
1722  delete MM;
1723  return mm;
1724 }
#define FALSE
Definition: auxiliary.h:94
Matrices of numbers.
Definition: bigintmat.h:51
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:587
void setCharacteristic(int c)
Definition: cf_char.cc:23
CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: numbers.cc:592
#define M
Definition: sirandom.c:24
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
bigintmat * bimCopy(const bigintmat *b)
same as copy constructor - apart from it being able to accept NULL as input
Definition: bigintmat.cc:406
int i
Definition: cfEzgcd.cc:123
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:134
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
void Werror(const char *fmt,...)
Definition: reporter.cc:189

◆ singntl_LLL() [1/2]

matrix singntl_LLL ( matrix  A,
const ring  r 
)

Definition at line 1726 of file clapsing.cc.

1727 {
1728  int r=m->rows();
1729  int c=m->cols();
1730  matrix res=mp_New(r,c);
1731  if (rField_is_Q(s))
1732  {
1733  CFMatrix M(r,c);
1734  int i,j;
1735  for(i=r;i>0;i--)
1736  {
1737  for(j=c;j>0;j--)
1738  {
1739  M(i,j)=convSingPFactoryP(MATELEM(m,i,j),s);
1740  }
1741  }
1742  CFMatrix *MM=cf_LLL(M);
1743  for(i=r;i>0;i--)
1744  {
1745  for(j=c;j>0;j--)
1746  {
1747  MATELEM(res,i,j)=convFactoryPSingP((*MM)(i,j),s);
1748  }
1749  }
1750  delete MM;
1751  }
1752  return res;
1753 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
poly res
Definition: myNF.cc:322
CFMatrix * cf_LLL(CFMatrix &A)
performs LLL reduction.
Definition: cf_hnf.cc:48
#define M
Definition: sirandom.c:24
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
poly convFactoryPSingP(const CanonicalForm &f, const ring r)
Definition: clapconv.cc:41
int m
Definition: cfEzgcd.cc:119
int i
Definition: cfEzgcd.cc:123
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:501
static matrix mp_New(int r, int c)
Definition: matpol.h:35
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:88
#define MATELEM(mat, i, j)
Definition: matpol.h:29

◆ singntl_LLL() [2/2]

intvec* singntl_LLL ( intvec A)

Definition at line 1755 of file clapsing.cc.

1756 {
1757  int r=m->rows();
1758  int c=m->cols();
1759  setCharacteristic( 0 );
1760  CFMatrix M(r,c);
1761  int i,j;
1762  for(i=r;i>0;i--)
1763  {
1764  for(j=c;j>0;j--)
1765  {
1766  M(i,j)=IMATELEM(*m,i,j);
1767  }
1768  }
1769  CFMatrix *MM=cf_LLL(M);
1770  intvec *mm=ivCopy(m);
1771  for(i=r;i>0;i--)
1772  {
1773  for(j=c;j>0;j--)
1774  {
1775  IMATELEM(*mm,i,j)=convFactoryISingI((*MM)(i,j));
1776  }
1777  }
1778  delete MM;
1779  return mm;
1780 }
intvec * ivCopy(const intvec *o)
Definition: intvec.h:126
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
const ring r
Definition: syzextra.cc:208
int convFactoryISingI(const CanonicalForm &f)
Definition: clapconv.cc:114
Definition: intvec.h:14
int j
Definition: myNF.cc:70
int m
Definition: cfEzgcd.cc:119
int i
Definition: cfEzgcd.cc:123
#define IMATELEM(M, I, J)
Definition: intvec.h:77