Changeset ce3f53c in git


Ignore:
Timestamp:
May 6, 2011, 11:51:40 AM (13 years ago)
Author:
Martin Lee <martinlee84@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b52fc4b2495505785981d640dcf7eb3e456778ef')
Children:
fba6f18e59118e933bb2d9c5b69b31879517ddff
Parents:
d75f15102ef5a6cd3463bf6f11b85177f916e01b
git-author:
Martin Lee <martinlee84@web.de>2011-05-06 11:51:40+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 12:31:37+01:00
Message:
adapted conversion to and from factory
Location:
libpolys/polys
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • libpolys/polys/clapconv.h

    rd75f15 rce3f53c  
    1919#endif /* HAVE_FACTORY */
    2020
    21 poly convFactoryPSingP ( const CanonicalForm & f, const ring r=currRing );
    22 CanonicalForm convSingPFactoryP( poly p, const ring r=currRing );
     21poly convFactoryPSingP ( const CanonicalForm & f, const ring r );
     22CanonicalForm convSingPFactoryP( poly p, const ring r );
    2323
    2424CanonicalForm convSingAPFactoryAP ( poly p , const Variable & a, const ring r );
     
    2626poly convFactoryAPSingAP_R ( const CanonicalForm & f, int par_start, int var_start );
    2727
    28 CanonicalForm convSingGFFactoryGF ( poly p );
    29 poly convFactoryGFSingGF ( const CanonicalForm & f );
     28CanonicalForm convSingGFFactoryGF ( poly p, const ring r );
     29poly convFactoryGFSingGF ( const CanonicalForm & f, const ring r );
    3030
    31 CanonicalForm convSingAFactoryA ( napoly p , const Variable & a, const ring r );
    32 napoly convFactoryASingA ( const CanonicalForm & f, const ring r );
     31CanonicalForm convSingAFactoryA ( number p , const Variable & a, const ring r );
     32number convFactoryASingA ( const CanonicalForm & f, const ring r );
    3333
    34 CanonicalForm convSingTrPFactoryP ( poly p, const ring r=currRing );
    35 poly convFactoryPSingTrP ( const CanonicalForm & f, const ring r=currRing );
     34CanonicalForm convSingTrPFactoryP ( poly p, const ring r );
     35poly convFactoryPSingTrP ( const CanonicalForm & f, const ring r );
    3636
    3737// CanonicalForm convSingIFactoryI( int i);a <- by constructor of CanonicalForm
  • libpolys/polys/clapsing.cc

    rd75f15 rce3f53c  
    3030#include "monomials/ring.h"
    3131#include "simpleideals.h"
    32 
     32//#include "polys.h"
    3333
    3434void out_cf(const char *s1,const CanonicalForm &f,const char *s2);
     
    5757  if (rField_is_Q(r) || (rField_is_Zp(r)))
    5858  {
    59     setCharacteristic( n_GetChar(r->cf) );
     59    setCharacteristic( rChar(r) );
    6060    CanonicalForm F( convSingPFactoryP( f,r ) ), G( convSingPFactoryP( g, r ) );
    6161    res=convFactoryPSingP( gcd( F, G ) , r);
     
    6565  {
    6666    if ( rField_is_Q_a(r)) setCharacteristic( 0 );
    67     else                   setCharacteristic( -n_GetChar(r) );
    68     if (r->minpoly!=NULL)
     67    else                   setCharacteristic( -rChar(r) );
     68    if (r->cf->algring->minideal!=NULL)
    6969    {
    7070      bool b1=isOn(SW_USE_QGCD);
    7171      bool b2=isOn(SW_USE_fieldGCD);
    72       if ( rField_is_Q_a() ) On(SW_USE_QGCD);
     72      if ( rField_is_Q_a(r) ) On(SW_USE_QGCD);
    7373      else                   On(SW_USE_fieldGCD);
    74       CanonicalForm mipo=convSingPFactoryP(((lnumber)r->minpoly)->z,
    75                                            r->algring);
     74      CanonicalForm mipo=convSingPFactoryP(r->cf->algring->minideal->m[0],
     75                                           r->cf->algring);
    7676      Variable a=rootOf(mipo);
    7777      CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
    7878                    G( convSingAPFactoryAP( g,a,r ) );
    79       res= convFactoryAPSingAP( gcd( F, G ),currRing );
     79      res= convFactoryAPSingAP( gcd( F, G ),r );
    8080      if (!b1) Off(SW_USE_QGCD);
    8181      if (!b2) Off(SW_USE_fieldGCD);
     
    106106}
    107107
    108 poly singclap_gcd ( poly f, poly g )
     108poly singclap_gcd ( poly f, poly g, const ring r)
    109109{
    110110  poly res=NULL;
    111111
    112   if (f!=NULL) p_Cleardenom(f, currRing);
    113   if (g!=NULL) p_Cleardenom(g, currRing);
     112  if (f!=NULL) p_Cleardenom(f, r);
     113  if (g!=NULL) p_Cleardenom(g, r);
    114114  else         return f; // g==0 => gcd=f (but do a p_Cleardenom)
    115115  if (f==NULL) return g; // f==0 => gcd=g (but do a p_Cleardenom)
    116116
    117   res=singclap_gcd_r(f,g,currRing);
    118   pDelete(&f);
    119   pDelete(&g);
     117  res=singclap_gcd_r(f,g,r);
     118  p_Delete(&f, r);
     119  p_Delete(&g, r);
    120120  return res;
    121121}
    122122
    123123/*2 find the maximal exponent of var(i) in poly p*/
    124 int pGetExp_Var(poly p, int i)
     124int pGetExp_Var(poly p, int i, const ring r)
    125125{
    126126  int m=0;
     
    128128  while (p!=NULL)
    129129  {
    130     mm=pGetExp(p,i);
     130    mm=p_GetExp(p,i,r);
    131131    if (mm>m) m=mm;
    132132    pIter(p);
     
    136136
    137137// destroys f,g,x
    138 poly singclap_resultant ( poly f, poly g , poly x)
     138poly singclap_resultant ( poly f, poly g , poly x, const ring r)
    139139{
    140140  poly res=NULL;
    141   int i=pIsPurePower(x);
     141  int i=p_IsPurePower(x, r);
    142142  if (i==0)
    143143  {
     
    149149  // for now there is only the possibility to handle polynomials over
    150150  // Q and Fp ...
    151   if (rField_is_Zp() || rField_is_Q())
     151  if (rField_is_Zp(r) || rField_is_Q(r))
    152152  {
    153153    Variable X(i);
    154     setCharacteristic( nGetChar() );
    155     CanonicalForm F( convSingPFactoryP( f ) ), G( convSingPFactoryP( g ) );
    156     res=convFactoryPSingP( resultant( F, G, X ) );
     154    setCharacteristic( rChar(r) );
     155    CanonicalForm F( convSingPFactoryP( f, r ) ), G( convSingPFactoryP( g, r ) );
     156    res=convFactoryPSingP( resultant( F, G, X ), r );
    157157    Off(SW_RATIONAL);
    158158    goto resultant_returns_res;
    159159  }
    160160  // and over Q(a) / Fp(a)
    161   else if (rField_is_Extension())
    162   {
    163     if (rField_is_Q_a()) setCharacteristic( 0 );
    164     else               setCharacteristic( -nGetChar() );
    165     Variable X(i+rPar(currRing));
    166     if (currRing->minpoly!=NULL)
     161  else if (rField_is_Extension(r))
     162  {
     163    if (rField_is_Q_a(r)) setCharacteristic( 0 );
     164    else               setCharacteristic( - rChar(r) );
     165    Variable X(i+rPar(r));
     166    if (r->cf->algring->minideal!=NULL)
    167167    {
    168168      //Variable X(i);
    169       CanonicalForm mipo=convSingPFactoryP(((lnumber)currRing->minpoly)->z,
    170                                                  currRing->algring);
     169      CanonicalForm mipo=convSingPFactoryP(r->cf->algring->minideal->m[0],
     170                                           r->cf->algring);
    171171      Variable a=rootOf(mipo);
    172       CanonicalForm F( convSingAPFactoryAP( f,a,currRing ) ),
    173                     G( convSingAPFactoryAP( g,a,currRing ) );
    174       res= convFactoryAPSingAP( resultant( F, G, X ),currRing );
     172      CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
     173                    G( convSingAPFactoryAP( g,a,r ) );
     174      res= convFactoryAPSingAP( resultant( F, G, X ),r );
    175175    }
    176176    else
     
    178178      //Variable X(i+rPar(currRing));
    179179      number nf,ng;
    180       p_Cleardenom_n(f, currRing,nf);p_Cleardenom_n(g, currRing,ng);
     180      p_Cleardenom_n(f, r,nf);p_Cleardenom_n(g, r,ng);
    181181      int ef,eg;
    182       ef=pGetExp_Var(f,i);
    183       eg=pGetExp_Var(g,i);
    184       CanonicalForm F( convSingTrPFactoryP( f ) ), G( convSingTrPFactoryP( g ) );
    185       res= convFactoryPSingTrP( resultant( F, G, X ) );
    186       if ((nf!=NULL)&&(!nIsOne(nf))&&(!nIsZero(nf)))
    187       {
    188         number n=nInvers(nf);
     182      ef=pGetExp_Var(f,i,r);
     183      eg=pGetExp_Var(g,i,r);
     184      CanonicalForm F( convSingTrPFactoryP( f, r ) ), G( convSingTrPFactoryP( g, r ) );
     185      res= convFactoryPSingTrP( resultant( F, G, X ), r );
     186      if ((nf!=NULL)&&(!n_IsOne(nf,r->cf))&&(!n_IsZero(nf,r->cf)))
     187      {
     188        number n=n_Invers(nf,r->cf);
    189189        while(eg>0)
    190190        {
    191           res=pMult_nn(res,n);
     191          res=p_Mult_nn(res,n,r);
    192192          eg--;
    193193        }
    194         nDelete(&n);
    195       }
    196       nDelete(&nf);
    197       if ((ng!=NULL)&&(!nIsOne(ng))&&(!nIsZero(ng)))
    198       {
    199         number n=nInvers(ng);
     194        n_Delete(&n,r->cf);
     195      }
     196      n_Delete(&nf, r->cf);
     197      if ((ng!=NULL)&&(!n_IsOne(ng, r->cf))&&(!n_IsZero(ng,r->cf)))
     198      {
     199        number n=n_Invers(ng,r->cf);
    200200        while(ef>0)
    201201        {
    202           res=pMult_nn(res,n);
     202          res=p_Mult_nn(res,n,r);
    203203          ef--;
    204204        }
    205         nDelete(&n);
    206       }
    207       nDelete(&ng);
     205        n_Delete(&n,r->cf);
     206      }
     207      n_Delete(&ng,r->cf);
    208208    }
    209209    Off(SW_RATIONAL);
     
    213213    WerrorS( feNotImplemented );
    214214resultant_returns_res:
    215   pDelete(&f);
    216   pDelete(&g);
    217   pDelete(&x);
     215  p_Delete(&f,r);
     216  p_Delete(&g,r);
     217  p_Delete(&x,r);
    218218  return res;
    219219}
     
    278278//}
    279279
    280 BOOLEAN singclap_extgcd ( poly f, poly g, poly &res, poly &pa, poly &pb )
     280BOOLEAN singclap_extgcd ( poly f, poly g, poly &res, poly &pa, poly &pb , const ring r)
    281281{
    282282  // for now there is only the possibility to handle univariate
     
    285285  res=NULL;pa=NULL;pb=NULL;
    286286  On(SW_SYMMETRIC_FF);
    287   if (rField_is_Zp() || rField_is_Q())
    288   {
    289     setCharacteristic( nGetChar() );
    290     CanonicalForm F( convSingPFactoryP( f ) ), G( convSingPFactoryP( g ) );
     287  if (rField_is_Zp(r) || rField_is_Q(r))
     288  {
     289    setCharacteristic( rChar(r) );
     290    CanonicalForm F( convSingPFactoryP( f, r ) ), G( convSingPFactoryP( g, r ) );
    291291    CanonicalForm FpG=F+G;
    292292    if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
     
    299299    CanonicalForm Fa,Gb;
    300300    On(SW_RATIONAL);
    301     res=convFactoryPSingP( extgcd( F, G, Fa, Gb ) );
    302     pa=convFactoryPSingP(Fa);
    303     pb=convFactoryPSingP(Gb);
     301    res=convFactoryPSingP( extgcd( F, G, Fa, Gb ), r );
     302    pa=convFactoryPSingP(Fa, r);
     303    pb=convFactoryPSingP(Gb, r);
    304304    Off(SW_RATIONAL);
    305305  }
    306306  // and over Q(a) / Fp(a)
    307   else if (rField_is_Extension())
    308   {
    309     if (rField_is_Q_a()) setCharacteristic( 0 );
    310     else               setCharacteristic( -nGetChar() );
     307  else if (rField_is_Extension(r))
     308  {
     309    if (rField_is_Q_a(r)) setCharacteristic( 0 );
     310    else               setCharacteristic( - rChar(r) );
    311311    CanonicalForm Fa,Gb;
    312     if (currRing->minpoly!=NULL)
    313     {
    314       CanonicalForm mipo=convSingPFactoryP(((lnumber)currRing->minpoly)->z,
    315                                                  currRing->algring);
     312    if (r->cf->algring->minideal!=NULL)
     313    {
     314      CanonicalForm mipo=convSingPFactoryP(r->cf->algring->minideal->m[0],
     315                                           r->cf->algring);
    316316      Variable a=rootOf(mipo);
    317       CanonicalForm F( convSingAPFactoryAP( f,a,currRing ) ),
    318                     G( convSingAPFactoryAP( g,a,currRing ) );
     317      CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
     318                    G( convSingAPFactoryAP( g,a,r ) );
    319319      CanonicalForm FpG=F+G;
    320320      if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
     
    324324        return TRUE;
    325325      }
    326       res= convFactoryAPSingAP( extgcd( F, G, Fa, Gb ),currRing );
    327       pa=convFactoryAPSingAP(Fa,currRing);
    328       pb=convFactoryAPSingAP(Gb,currRing);
     326      res= convFactoryAPSingAP( extgcd( F, G, Fa, Gb ),r );
     327      pa=convFactoryAPSingAP(Fa,r);
     328      pb=convFactoryAPSingAP(Gb,r);
    329329    }
    330330    else
    331331    {
    332       CanonicalForm F( convSingTrPFactoryP( f ) ), G( convSingTrPFactoryP( g ) );
     332      CanonicalForm F( convSingTrPFactoryP( f,r ) ), G( convSingTrPFactoryP( g,r ) );
    333333      CanonicalForm FpG=F+G;
    334334      if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
     
    339339        return TRUE;
    340340      }
    341       res= convFactoryPSingTrP( extgcd( F, G, Fa, Gb ) );
    342       pa=convFactoryPSingTrP(Fa);
    343       pb=convFactoryPSingTrP(Gb);
     341      res= convFactoryPSingTrP( extgcd( F, G, Fa, Gb ),r );
     342      pa=convFactoryPSingTrP(Fa,r);
     343      pb=convFactoryPSingTrP(Gb,r);
    344344    }
    345345    Off(SW_RATIONAL);
     
    353353  // checking the result of extgcd:
    354354  poly dummy;
    355   dummy=pSub(pAdd(pMult(pCopy(f),pCopy(pa)),pMult(pCopy(g),pCopy(pb))),pCopy(res));
     355  dummy=p_Sub(p_Add_q(pp_Mult_qq(f,pa,r),pp_Mult_qq(g,pb,r),r),p_Copy(res,r),r);
    356356  if (dummy!=NULL)
    357357  {
    358     PrintS("extgcd( ");pWrite(f);pWrite0(g);PrintS(" )\n");
    359     PrintS("gcd, co-factors:");pWrite(res); pWrite(pa);pWrite(pb);
    360     pDelete(&dummy);
     358    PrintS("extgcd( ");p_Write(f,r);p_Write0(g,r);PrintS(" )\n");
     359    PrintS("gcd, co-factors:");p_Write(res,r); p_Write(pa,r);p_Write(pb,r);
     360    p_Delete(&dummy,r);
    361361  }
    362362#endif
     
    373373  if ( rField_is_Q(r) || rField_is_Zp(r) )
    374374  {
    375     setCharacteristic( n_GetChar(r) );
     375    setCharacteristic( rChar(r) );
    376376    CanonicalForm F( convSingPFactoryP( f,r ) ), G( convSingPFactoryP( g,r) );
    377377    CanonicalForm FpG=F+G;
     
    394394  {
    395395    if (rField_is_Q_a(r)) setCharacteristic( 0 );
    396     else                 setCharacteristic( -n_GetChar(r) );
     396    else                 setCharacteristic( - rChar(r) );
    397397    CanonicalForm Fa,Gb;
    398     if (r->minpoly!=NULL)
    399     {
    400       CanonicalForm mipo=convSingPFactoryP(((lnumber)r->minpoly)->z,
    401                                             r->algring);
     398    if (r->cf->algring->minideal!=NULL)
     399    {
     400      CanonicalForm mipo=convSingPFactoryP(r->cf->algring->minideal->m[0],
     401                                           r->cf->algring);
    402402      Variable a=rootOf(mipo);
    403403      CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
     
    410410        return TRUE;
    411411      }
    412       res= convFactoryAPSingAP( extgcd( F, G, Fa, Gb ),currRing );
    413       pa=convFactoryAPSingAP(Fa,currRing);
    414       pb=convFactoryAPSingAP(Gb,currRing);
     412      res= convFactoryAPSingAP( extgcd( F, G, Fa, Gb ),r );
     413      pa=convFactoryAPSingAP(Fa,r);
     414      pb=convFactoryAPSingAP(Gb,r);
    415415    }
    416416    else
     
    439439}
    440440
    441 poly singclap_pdivide ( poly f, poly g )
     441poly singclap_pdivide ( poly f, poly g, const ring r )
    442442{
    443443  poly res=NULL;
    444444  On(SW_RATIONAL);
    445   if (rField_is_Zp() || rField_is_Q())
    446   {
    447     setCharacteristic( nGetChar() );
    448     CanonicalForm F( convSingPFactoryP( f ) ), G( convSingPFactoryP( g ) );
    449     res = convFactoryPSingP( F / G );
    450   }
    451   else if (rField_is_Extension())
    452   {
    453     if (rField_is_Q_a()) setCharacteristic( 0 );
    454     else               setCharacteristic( -nGetChar() );
    455     if (currRing->minpoly!=NULL)
    456     {
    457       CanonicalForm mipo=convSingPFactoryP(((lnumber)currRing->minpoly)->z,
    458                                                  currRing->algring);
     445  if (rField_is_Zp(r) || rField_is_Q(r))
     446  {
     447    setCharacteristic( rChar(r) );
     448    CanonicalForm F( convSingPFactoryP( f,r ) ), G( convSingPFactoryP( g,r ) );
     449    res = convFactoryPSingP( F / G, r );
     450  }
     451  else if (rField_is_Extension(r))
     452  {
     453    if (rField_is_Q_a(r)) setCharacteristic( 0 );
     454    else               setCharacteristic( - rChar(r) );
     455    if (r->cf->algring->minideal!=NULL)
     456    {
     457      CanonicalForm mipo=convSingPFactoryP(r->cf->algring->minideal->m[0],
     458                                           r->cf->algring);
    459459      Variable a=rootOf(mipo);
    460       CanonicalForm F( convSingAPFactoryAP( f,a,currRing ) ),
    461                     G( convSingAPFactoryAP( g,a,currRing ) );
    462       res= convFactoryAPSingAP(  F / G,currRing );
     460      CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
     461                    G( convSingAPFactoryAP( g,a,r ) );
     462      res= convFactoryAPSingAP(  F / G,r );
    463463    }
    464464    else
    465465    {
    466       CanonicalForm F( convSingTrPFactoryP( f ) ), G( convSingTrPFactoryP( g ) );
    467       res= convFactoryPSingTrP(  F / G  );
     466      CanonicalForm F( convSingTrPFactoryP( f,r ) ), G( convSingTrPFactoryP( g,r ) );
     467      res= convFactoryPSingTrP(  F / G,r  );
    468468    }
    469469  }
     
    489489  if (rField_is_Zp(r) || rField_is_Q(r))
    490490  {
    491     setCharacteristic( n_GetChar(r) );
     491    setCharacteristic( rChar(r) );
    492492    CanonicalForm F( convSingPFactoryP( f,r ) ), G( convSingPFactoryP( g,r ) );
    493493    res = convFactoryPSingP( F / G,r );
     
    496496  {
    497497    if (rField_is_Q_a(r)) setCharacteristic( 0 );
    498     else               setCharacteristic( -n_GetChar(r) );
    499     if (r->minpoly!=NULL)
    500     {
    501       CanonicalForm mipo=convSingPFactoryP(((lnumber)r->minpoly)->z,
    502                                                  r->algring);
     498    else               setCharacteristic( - rChar(r) );
     499    if (r->cf->algring->minideal!=NULL)
     500    {
     501      CanonicalForm mipo=convSingPFactoryP(r->cf->algring->minideal->m[0],
     502                                           r->cf->algring);
    503503      Variable a=rootOf(mipo);
    504504      CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
     
    527527}
    528528
    529 void singclap_divide_content ( poly f )
     529void singclap_divide_content ( poly f, const ring r )
    530530{
    531531  if ( f==NULL )
     
    535535  else  if ( pNext( f ) == NULL )
    536536  {
    537     pSetCoeff( f, nInit( 1 ) );
     537    p_SetCoeff( f, n_Init( 1, r->cf ), r );
    538538    return;
    539539  }
    540540  else
    541541  {
    542     if ( rField_is_Q_a() )
     542    if ( rField_is_Q_a(r) )
    543543      setCharacteristic( 0 );
    544     else  if ( rField_is_Zp_a() )
    545       setCharacteristic( -nGetChar() );
     544    else  if ( rField_is_Zp_a(r) )
     545      setCharacteristic( -rChar(r) );
    546546    else
    547547      return; /* not implemented*/
     
    556556    number g2=pGetCoeff(p); // p==pNext(f);
    557557    pIter(p);
    558     int sz1=nSize(g1);
    559     int sz2=nSize(g2);
     558    int sz1=n_Size(g1, r->cf);
     559    int sz2=n_Size(g2, r->cf);
    560560    if (sz1>sz2)
    561561    {
     
    567567    while (p!=NULL)
    568568    {
    569       int n_sz=nSize(pGetCoeff(p));
     569      int n_sz=n_Size(pGetCoeff(p),r->cf);
    570570      if (n_sz<sz1)
    571571      {
     
    584584      pIter(p);
    585585    }
    586     g = convSingPFactoryP( ((lnumber)g1)->z, currRing->algring );
    587     g = gcd( g, convSingPFactoryP( ((lnumber)g2)->z , currRing->algring));
     586    g = convSingPFactoryP( ((lnumber)g1)->z, r->cf->algring );
     587    g = gcd( g, convSingPFactoryP( ((lnumber)g2)->z , r->cf->algring));
    588588
    589589    // second run: gcd's
     
    592592    while ( (p != NULL) && (g != 1)  && ( g != 0))
    593593    {
    594       h = convSingPFactoryP( ((lnumber)pGetCoeff(p))->z, currRing->algring );
     594      h = convSingPFactoryP( ((lnumber)pGetCoeff(p))->z, r->cf->algring );
    595595      pIter( p );
    596596
     
    610610      {
    611611        lnumber c=(lnumber)pGetCoeff(p);
    612         p_Delete(&c->z,currRing->algring); // 2nd arg used to be nacRing
    613         c->z=convFactoryPSingP( i.getItem() / g, currRing->algring );
     612        p_Delete(&c->z,r->cf->algring); // 2nd arg used to be nacRing
     613        c->z=convFactoryPSingP( i.getItem() / g, r->cf->algring );
    614614        //nTest((number)c);
    615615        //#ifdef LDEBUG
     
    624624}
    625625
    626 BOOLEAN count_Factors(ideal I, intvec *v,int j, poly &f, poly fac)
    627 {
    628   pTest(f);
    629   pTest(fac);
     626static int primepower(int c, const ring r)
     627{
     628  int p=1;
     629  int cc=c;
     630  while(cc!= rChar(r)) { cc*=c; p++; }
     631  return p;
     632}
     633
     634BOOLEAN count_Factors(ideal I, intvec *v,int j, poly &f, poly fac, const ring r)
     635{
     636  p_Test(f,r);
     637  p_Test(fac,r);
    630638  int e=0;
    631   if (!pIsConstantPoly(fac))
     639  if (!p_IsConstantPoly(fac,r))
    632640  {
    633641#ifdef FACTORIZE2_DEBUG
     
    638646    CanonicalForm F, FAC,Q,R;
    639647    Variable a;
    640     if (rField_is_Zp() || rField_is_Q())
    641     {
    642       F=convSingPFactoryP( f );
    643       FAC=convSingPFactoryP( fac );
    644     }
    645     else if (rField_is_Extension())
    646     {
    647       if (currRing->minpoly!=NULL)
    648       {
    649         CanonicalForm mipo=convSingPFactoryP(((lnumber)currRing->minpoly)->z,
    650                                     currRing->algring);
     648    if (rField_is_Zp(r) || rField_is_Q(r))
     649    {
     650      F=convSingPFactoryP( f,r );
     651      FAC=convSingPFactoryP( fac,r );
     652    }
     653    else if (rField_is_Extension(r))
     654    {
     655      if (r->cf->algring->minideal!=NULL)
     656      {
     657        CanonicalForm mipo=convSingPFactoryP(r->cf->algring->minideal->m[0],
     658                                             r->cf->algring);
    651659        a=rootOf(mipo);
    652         F=convSingAPFactoryAP( f,a,currRing );
    653         FAC=convSingAPFactoryAP( fac,a,currRing );
     660        F=convSingAPFactoryAP( f,a,r );
     661        FAC=convSingAPFactoryAP( fac,a,r );
    654662      }
    655663      else
    656664      {
    657         F=convSingTrPFactoryP( f );
    658         FAC=convSingTrPFactoryP( fac );
     665        F=convSingTrPFactoryP( f,r );
     666        FAC=convSingTrPFactoryP( fac,r );
    659667      }
    660668    }
     
    672680      if (R.isZero())
    673681      {
    674         if (rField_is_Zp() || rField_is_Q())
     682        if (rField_is_Zp(r) || rField_is_Q(r))
    675683        {
    676           q = convFactoryPSingP( Q );
     684          q = convFactoryPSingP( Q,r );
    677685        }
    678         else if (rField_is_Extension())
     686        else if (rField_is_Extension(r))
    679687        {
    680           if (currRing->minpoly!=NULL)
     688          if (r->cf->algring->minideal!=NULL)
    681689          {
    682             q= convFactoryAPSingAP(  Q,currRing  );
     690            q= convFactoryAPSingAP(  Q,r  );
    683691          }
    684692          else
    685693          {
    686             q= convFactoryPSingTrP(  Q  );
     694            q= convFactoryPSingTrP(  Q,r  );
    687695          }
    688696        }
    689         e++; pDelete(&f); f=q; q=NULL; F=Q;
     697        e++; p_Delete(&f,r); f=q; q=NULL; F=Q;
    690698      }
    691699      else
     
    710718extern int libfac_interruptflag;
    711719
    712 ideal singclap_factorize ( poly f, intvec ** v , int with_exps)
     720ideal singclap_factorize ( poly f, intvec ** v , int with_exps, const ring r)
    713721/* destroys f, sets *v */
    714722{
    715   pTest(f);
     723  p_Test(f,r);
    716724#ifdef FACTORIZE2_DEBUG
    717725  printf("singclap_factorize, degree %ld\n",pTotaldegree(f));
     
    741749    int n=0;
    742750    int e;
    743     for(i=pVariables;i>0;i--) if(pGetExp(f,i)!=0) n++;
     751    for(i=rVar(r);i>0;i--) if(p_GetExp(f,i,r)!=0) n++;
    744752    if (with_exps==0) n++; // with coeff
    745753    res=idInit(si_max(n,1),1);
     
    747755    {
    748756      case 0: // with coef & exp.
    749         res->m[0]=pNSet(nCopy(pGetCoeff(f)));
     757        res->m[0]=p_NSet(n_Copy(pGetCoeff(f),r->cf),r);
    750758        // no break
    751759      case 2: // with exp.
     
    760768    if (n==0)
    761769    {
    762       res->m[0]=pOne();
     770      res->m[0]=p_One(r);
    763771      // (**v)[0]=1; is already done
    764772    }
    765773    else
    766774    {
    767       for(i=pVariables;i>0;i--)
    768       {
    769         e=pGetExp(f,i);
     775      for(i=rVar(r);i>0;i--)
     776      {
     777        e=p_GetExp(f,i,r);
    770778        if(e!=0)
    771779        {
    772780          n--;
    773           poly p=pOne();
    774           pSetExp(p,i,1);
    775           pSetm(p);
     781          poly p=p_One(r);
     782          p_SetExp(p,i,1,r);
     783          p_Setm(p,r);
    776784          res->m[n]=p;
    777785          if (with_exps!=1) (**v)[n]=e;
     
    779787      }
    780788    }
    781     pDelete(&f);
     789    p_Delete(&f,r);
    782790    return res;
    783791  }
     
    788796  #ifdef HAVE_NTL
    789797  extern int prime_number;
    790   if(rField_is_Q()) prime_number=0;
     798  if(rField_is_Q(r)) prime_number=0;
    791799  #endif
    792800  CFFList L;
    793801  number N=NULL;
    794802  number NN=NULL;
    795   number old_lead_coeff=nCopy(pGetCoeff(f));
    796 
    797   if (!rField_is_Zp() && !rField_is_Zp_a()) /* Q, Q(a) */
     803  number old_lead_coeff=n_Copy(pGetCoeff(f), r->cf);
     804
     805  if (!rField_is_Zp(r) && !rField_is_Zp_a(r)) /* Q, Q(a) */
    798806  {
    799807    //if (f!=NULL) // already tested at start of routine
    800808    {
    801       number n0=nCopy(pGetCoeff(f));
     809      number n0=n_Copy(pGetCoeff(f),r->cf);
    802810      if (with_exps==0)
    803         N=nCopy(n0);
    804       p_Cleardenom(f, currRing);
    805       NN=nDiv(n0,pGetCoeff(f));
    806       nDelete(&n0);
     811        N=n_Copy(n0,r->cf);
     812      p_Cleardenom(f, r);
     813      NN=n_Div(n0,pGetCoeff(f),r->cf);
     814      n_Delete(&n0,r->cf);
    807815      if (with_exps==0)
    808816      {
    809         nDelete(&N);
    810         N=nCopy(NN);
    811       }
    812     }
    813   }
    814   else if (rField_is_Zp_a())
     817        n_Delete(&N,r->cf);
     818        N=n_Copy(NN,r->cf);
     819      }
     820    }
     821  }
     822  else if (rField_is_Zp_a(r))
    815823  {
    816824    //if (f!=NULL) // already tested at start of routine
    817825    if (singclap_factorize_retry==0)
    818826    {
    819       number n0=nCopy(pGetCoeff(f));
     827      number n0=n_Copy(pGetCoeff(f),r->cf);
    820828      if (with_exps==0)
    821         N=nCopy(n0);
    822       pNorm(f);
    823       p_Cleardenom(f, currRing);
    824       NN=nDiv(n0,pGetCoeff(f));
    825       nDelete(&n0);
     829        N=n_Copy(n0,r->cf);
     830      p_Norm(f,r);
     831      p_Cleardenom(f, r);
     832      NN=n_Div(n0,pGetCoeff(f),r->cf);
     833      n_Delete(&n0,r->cf);
    826834      if (with_exps==0)
    827835      {
    828         nDelete(&N);
    829         N=nCopy(NN);
    830       }
    831     }
    832   }
    833   if (rField_is_Q() || rField_is_Zp())
    834   {
    835     setCharacteristic( nGetChar() );
    836     CanonicalForm F( convSingPFactoryP( f ) );
     836        n_Delete(&N,r->cf);
     837        N=n_Copy(NN,r->cf);
     838      }
     839    }
     840  }
     841  if (rField_is_Q(r) || rField_is_Zp(r))
     842  {
     843    setCharacteristic( rChar(r) );
     844    CanonicalForm F( convSingPFactoryP( f,r ) );
    837845    L = factorize( F );
    838846  }
     
    854862  #endif
    855863  // and over Q(a) / Fp(a)
    856   else if (rField_is_Extension())
    857   {
    858     if (rField_is_Q_a()) setCharacteristic( 0 );
    859     else                 setCharacteristic( -nGetChar() );
    860     if (currRing->minpoly!=NULL)
    861     {
    862       CanonicalForm mipo=convSingPFactoryP(((lnumber)currRing->minpoly)->z,
    863                    currRing->algring);
     864  else if (rField_is_Extension(r))
     865  {
     866    if (rField_is_Q_a(r)) setCharacteristic( 0 );
     867    else                 setCharacteristic( -rChar(r) );
     868    if (r->cf->algring->minideal!=NULL)
     869    {
     870      CanonicalForm mipo=convSingPFactoryP(r->cf->algring->minideal->m[0],
     871                                           r->cf->algring);
    864872      Variable a=rootOf(mipo);
    865       CanonicalForm F( convSingAPFactoryAP( f,a,currRing ) );
    866       if (rField_is_Zp_a())
     873      CanonicalForm F( convSingAPFactoryAP( f,a,r ) );
     874      if (rField_is_Zp_a(r))
    867875      {
    868876        L = factorize( F, a );
     
    876884    else
    877885    {
    878       CanonicalForm F( convSingTrPFactoryP( f ) );
     886      CanonicalForm F( convSingTrPFactoryP( f,r ) );
    879887      L = factorize( F );
    880888    }
     
    885893  }
    886894  {
    887     poly ff=pCopy(f); // a copy for the retry stuff
     895    poly ff=p_Copy(f,r); // a copy for the retry stuff
    888896    // the first factor should be a constant
    889897    if ( ! L.getFirst().factor().inCoeffDomain() )
     
    907915    {
    908916      if (with_exps!=1) (**v)[j] = J.getItem().exp();
    909       if (rField_is_Zp() || rField_is_Q())           /* Q, Fp */
     917      if (rField_is_Zp(r) || rField_is_Q(r))           /* Q, Fp */
    910918      {
    911919        //count_Factors(res,*v,f, j, convFactoryPSingP( J.getItem().factor() );
    912         res->m[j] = convFactoryPSingP( J.getItem().factor() );
     920        res->m[j] = convFactoryPSingP( J.getItem().factor(),r );
    913921      }
    914922      #if 0
     
    916924        res->m[j] = convFactoryGFSingGF( J.getItem().factor() );
    917925      #endif
    918       else if (rField_is_Extension())     /* Q(a), Fp(a) */
     926      else if (rField_is_Extension(r))     /* Q(a), Fp(a) */
    919927      {
    920928        intvec *w=NULL;
    921929        if (v!=NULL) w=*v;
    922         if (currRing->minpoly==NULL)
     930        if (r->cf->algring->minideal==NULL)
    923931        {
    924           if(!count_Factors(res,w,j,ff,convFactoryPSingTrP( J.getItem().factor() )))
     932          if(!count_Factors(res,w,j,ff,convFactoryPSingTrP( J.getItem().factor(),r ),r))
    925933          {
    926934            if (w!=NULL)
    927935              (*w)[j]=1;
    928             res->m[j]=pOne();
     936            res->m[j]=p_One(r);
    929937          }
    930938        }
    931939        else
    932940        {
    933           if (!count_Factors(res,w,j,ff,convFactoryAPSingAP( J.getItem().factor(),currRing )))
     941          if (!count_Factors(res,w,j,ff,convFactoryAPSingAP( J.getItem().factor(),r ),r))
    934942          {
    935943            if (w!=NULL)
    936944              (*w)[j]=1;
    937             res->m[j]=pOne();
     945            res->m[j]=p_One(r);
    938946          }
    939947        }
    940948      }
    941949    }
    942     if (rField_is_Extension() && (!pIsConstantPoly(ff)))
     950    if (rField_is_Extension(r) && (!p_IsConstantPoly(ff,r)))
    943951    {
    944952      singclap_factorize_retry++;
     
    950958        #endif
    951959        intvec *ww=NULL;
    952         idTest(res);
    953         ideal h=singclap_factorize ( ff, &ww , with_exps);
    954         idTest(h);
     960        id_Test(res,r);
     961        ideal h=singclap_factorize ( ff, &ww , with_exps, r );
     962        id_Test(h,r);
    955963        int l=(*v)->length();
    956964        (*v)->resize(l+ww->length());
     
    969977          h->m[jj]=NULL;
    970978        }
    971         idDelete(&res);
    972         idDelete(&h);
     979        id_Delete(&res,r);
     980        id_Delete(&h,r);
    973981        res=hh;
    974         idTest(res);
     982        id_Test(res,r);
    975983        ff=NULL;
    976984      }
     
    982990        idShow(res);
    983991        #endif
    984         idDelete(&res);
     992        id_Delete(&res,r);
    985993        res=idInit(2,1);
    986         res->m[0]=pOne();
     994        res->m[0]=p_One(r);
    987995        res->m[1]=ff; ff=NULL;
    988996      }
    989997    }
    990     pDelete(&ff);
     998    p_Delete(&ff,r);
    991999    if (N!=NULL)
    9921000    {
    993       pMult_nn(res->m[0],N);
    994       nDelete(&N);
     1001      p_Mult_nn(res->m[0],N,r);
     1002      n_Delete(&N,r->cf);
    9951003      N=NULL;
    9961004    }
     
    10041012        if ((res->m[i]!=NULL)
    10051013        && (pNext(res->m[i])==NULL)
    1006         && (pIsConstant(res->m[i])))
     1014        && (p_IsConstant(res->m[i],r)))
    10071015        {
    10081016          if (with_exps!=0)
    10091017          {
    1010             pDelete(&(res->m[i]));
     1018            p_Delete(&(res->m[i]),r);
    10111019            if ((v!=NULL) && ((*v)!=NULL))
    10121020              (**v)[i]=0;
     
    10171025            while ((v!=NULL) && ((*v)!=NULL) && ((**v)[i]>1))
    10181026            {
    1019               res->m[0]=pMult(res->m[0],pCopy(res->m[i]));
     1027              res->m[0]=p_Mult_q(res->m[0],p_Copy(res->m[i],r),r);
    10201028              (**v)[i]--;
    10211029            }
    1022             res->m[0]=pMult(res->m[0],res->m[i]);
     1030            res->m[0]=p_Mult_q(res->m[0],res->m[i],r);
    10231031            res->m[i]=NULL;
    10241032            if ((v!=NULL) && ((*v)!=NULL))
     
    10481056      if (res->m[0]==NULL)
    10491057      {
    1050         res->m[0]=pOne();
    1051       }
    1052     }
    1053   }
    1054   if (rField_is_Q_a() && (currRing->minpoly!=NULL))
     1058        res->m[0]=p_One(r);
     1059      }
     1060    }
     1061  }
     1062  if (rField_is_Q_a(r) && (r->cf->algring->minideal!=NULL))
    10551063  {
    10561064    int i=IDELEMS(res)-1;
     
    10591067    for(;i>=stop;i--)
    10601068    {
    1061       pNorm(res->m[i]);
    1062     }
    1063     if (with_exps==0) pSetCoeff(res->m[0],old_lead_coeff);
    1064     else nDelete(&old_lead_coeff);
     1069      p_Norm(res->m[i],r);
     1070    }
     1071    if (with_exps==0) p_SetCoeff(res->m[0],old_lead_coeff,r);
     1072    else n_Delete(&old_lead_coeff,r->cf);
    10651073  }
    10661074  else
    1067     nDelete(&old_lead_coeff);
     1075    n_Delete(&old_lead_coeff,r->cf);
    10681076  errorreported=save_errorreported;
    10691077notImpl:
     
    10721080  if (NN!=NULL)
    10731081  {
    1074     nDelete(&NN);
     1082    n_Delete(&NN,r->cf);
    10751083  }
    10761084  if (N!=NULL)
    10771085  {
    1078     nDelete(&N);
    1079   }
    1080   if (f!=NULL) pDelete(&f);
     1086    n_Delete(&N,r->cf);
     1087  }
     1088  if (f!=NULL) p_Delete(&f,r);
    10811089  //PrintS("......S\n");
    10821090  return res;
    10831091}
    1084 ideal singclap_sqrfree ( poly f)
    1085 {
    1086   pTest(f);
     1092ideal singclap_sqrfree ( poly f, const ring r)
     1093{
     1094  p_Test(f,r);
    10871095#ifdef FACTORIZE2_DEBUG
    10881096  printf("singclap_sqrfree, degree %d\n",pTotaldegree(f));
     
    11071115    int n=0;
    11081116    int e;
    1109     for(i=pVariables;i>0;i--) if(pGetExp(f,i)!=0) n++;
     1117    for(i=rVar(r);i>0;i--) if(p_GetExp(f,i,r)!=0) n++;
    11101118    n++; // with coeff
    11111119    res=idInit(si_max(n,1),1);
    1112     res->m[0]=pNSet(nCopy(pGetCoeff(f)));
     1120    res->m[0]=p_NSet(n_Copy(pGetCoeff(f),r->cf),r);
    11131121    if (n==0)
    11141122    {
    1115       res->m[0]=pOne();
     1123      res->m[0]=p_One(r);
    11161124      // (**v)[0]=1; is already done
    11171125      return res;
    11181126    }
    1119     for(i=pVariables;i>0;i--)
    1120     {
    1121       e=pGetExp(f,i);
     1127    for(i=rVar(r);i>0;i--)
     1128    {
     1129      e=p_GetExp(f,i,r);
    11221130      if(e!=0)
    11231131      {
    11241132        n--;
    1125         poly p=pOne();
    1126         pSetExp(p,i,1);
    1127         pSetm(p);
     1133        poly p=p_One(r);
     1134        p_SetExp(p,i,1,r);
     1135        p_Setm(p,r);
    11281136        res->m[n]=p;
    11291137      }
     
    11371145  #ifdef HAVE_NTL
    11381146  extern int prime_number;
    1139   if(rField_is_Q()) prime_number=0;
     1147  if(rField_is_Q(r)) prime_number=0;
    11401148  #endif
    11411149  CFFList L;
    11421150
    1143   if (!rField_is_Zp() && !rField_is_Zp_a()) /* Q, Q(a) */
     1151  if (!rField_is_Zp(r) && !rField_is_Zp_a(r)) /* Q, Q(a) */
    11441152  {
    11451153    //if (f!=NULL) // already tested at start of routine
    11461154    {
    1147       p_Cleardenom(f, currRing);
    1148     }
    1149   }
    1150   else if (rField_is_Zp_a())
     1155      p_Cleardenom(f, r);
     1156    }
     1157  }
     1158  else if (rField_is_Zp_a(r))
    11511159  {
    11521160    //if (f!=NULL) // already tested at start of routine
    11531161    if (singclap_factorize_retry==0)
    11541162    {
    1155       pNorm(f);
    1156       p_Cleardenom(f, currRing);
    1157     }
    1158   }
    1159   if (rField_is_Q() || rField_is_Zp())
    1160   {
    1161     setCharacteristic( nGetChar() );
    1162     CanonicalForm F( convSingPFactoryP( f ) );
     1163      p_Norm(f,r);
     1164      p_Cleardenom(f, r);
     1165    }
     1166  }
     1167  if (rField_is_Q(r) || rField_is_Zp(r))
     1168  {
     1169    setCharacteristic( rChar(r) );
     1170    CanonicalForm F( convSingPFactoryP( f,r ) );
    11631171    L = sqrFree( F );
    11641172  }
     
    11661174  else if (rField_is_GF())
    11671175  {
    1168     int c=rChar(currRing);
     1176    int c=rChar(r);
    11691177    setCharacteristic( c, primepower(c) );
    11701178    CanonicalForm F( convSingGFFactoryGF( f ) );
     
    11801188  #endif
    11811189  // and over Q(a) / Fp(a)
    1182   else if (rField_is_Extension())
    1183   {
    1184     if (rField_is_Q_a()) setCharacteristic( 0 );
    1185     else                 setCharacteristic( -nGetChar() );
    1186     if (currRing->minpoly!=NULL)
    1187     {
    1188       CanonicalForm mipo=convSingPFactoryP(((lnumber)currRing->minpoly)->z,
    1189                     currRing->algring);
     1190  else if (rField_is_Extension(r))
     1191  {
     1192    if (rField_is_Q_a(r)) setCharacteristic( 0 );
     1193    else                 setCharacteristic( -rChar(r) );
     1194    if (r->cf->algring->minideal!=NULL)
     1195    {
     1196      CanonicalForm mipo=convSingPFactoryP(r->cf->algring->minideal->m[0],
     1197                                           r->cf->algring);
    11901198      Variable a=rootOf(mipo);
    1191       CanonicalForm F( convSingAPFactoryAP( f,a,currRing ) );
     1199      CanonicalForm F( convSingAPFactoryAP( f,a,r ) );
    11921200      CFFList SqrFreeMV( const CanonicalForm & f , const CanonicalForm & mipo=0) ;
    11931201
     
    11981206    else
    11991207    {
    1200       CanonicalForm F( convSingTrPFactoryP( f ) );
     1208      CanonicalForm F( convSingTrPFactoryP( f,r ) );
    12011209      L = sqrFree( F );
    12021210    }
     
    12151223    for ( ; J.hasItem(); J++, j++ )
    12161224    {
    1217       if (rField_is_Zp() || rField_is_Q())           /* Q, Fp */
     1225      if (rField_is_Zp(r) || rField_is_Q(r))           /* Q, Fp */
    12181226        //count_Factors(res,*v,f, j, convFactoryPSingP( J.getItem().factor() );
    1219         res->m[j] = convFactoryPSingP( J.getItem().factor() );
     1227        res->m[j] = convFactoryPSingP( J.getItem().factor(),r );
    12201228      #if 0
    12211229      else if (rField_is_GF())
    12221230        res->m[j] = convFactoryGFSingGF( J.getItem().factor() );
    12231231      #endif
    1224       else if (rField_is_Extension())     /* Q(a), Fp(a) */
    1225       {
    1226         if (currRing->minpoly==NULL)
    1227           res->m[j]=convFactoryPSingTrP( J.getItem().factor() );
     1232      else if (rField_is_Extension(r))     /* Q(a), Fp(a) */
     1233      {
     1234        if (r->cf->algring->minideal==NULL)
     1235          res->m[j]=convFactoryPSingTrP( J.getItem().factor(),r );
    12281236        else
    1229           res->m[j]=convFactoryAPSingAP( J.getItem().factor(),currRing );
     1237          res->m[j]=convFactoryAPSingAP( J.getItem().factor(),r );
    12301238      }
    12311239    }
    12321240    if (res->m[0]==NULL)
    12331241    {
    1234       res->m[0]=pOne();
    1235     }
    1236   }
    1237   pDelete(&f);
     1242      res->m[0]=p_One(r);
     1243    }
     1244  }
     1245  p_Delete(&f,r);
    12381246  errorreported=save_errorreported;
    12391247notImpl:
     
    12421250  return res;
    12431251}
    1244 matrix singclap_irrCharSeries ( ideal I)
     1252
     1253
     1254TODO(somebody, add libfac)
     1255/*matrix singclap_irrCharSeries ( ideal I, const ring r)
    12451256{
    12461257  if (idIs0(I)) return mpNew(1,1);
     
    12541265  CFList L;
    12551266  ListCFList LL;
    1256   if (((nGetChar() == 0) || (nGetChar() > 1) )
    1257   && (currRing->parameter==NULL))
    1258   {
    1259     setCharacteristic( nGetChar() );
     1267  if (((rChar(r) == 0) || (rChar(r) > 1) )
     1268  && (rPar(r)==0))
     1269  {
     1270    setCharacteristic( rChar(r) );
    12601271    for(i=0;i<IDELEMS(I);i++)
    12611272    {
     
    12631274      if (p!=NULL)
    12641275      {
    1265         p=pCopy(p);
    1266         p_Cleardenom(p, currRing);
    1267         L.append(convSingPFactoryP(p));
     1276        p=p_Copy(p,r);
     1277        p_Cleardenom(p, r);
     1278        L.append(convSingPFactoryP(p,r));
    12681279      }
    12691280    }
    12701281  }
    12711282  // and over Q(a) / Fp(a)
    1272   else if (( nGetChar()==1 ) /* Q(a) */
    1273   || (nGetChar() <-1))       /* Fp(a) */
    1274   {
    1275     if (nGetChar()==1) setCharacteristic( 0 );
    1276     else               setCharacteristic( -nGetChar() );
     1283  else if (( rChar(r)==1 ) // Q(a)
     1284  || (rChar(r) <-1))       // Fp(a)
     1285  {
     1286    if (rChar(r)==1) setCharacteristic( 0 );
     1287    else               setCharacteristic( -rChar(r) );
    12771288    for(i=0;i<IDELEMS(I);i++)
    12781289    {
     
    12801291      if (p!=NULL)
    12811292      {
    1282         p=pCopy(p);
    1283         p_Cleardenom(p, currRing);
    1284         L.append(convSingTrPFactoryP(p));
     1293        p=p_Copy(p,r);
     1294        p_Cleardenom(p, r);
     1295        L.append(convSingTrPFactoryP(p,r));
    12851296      }
    12861297    }
     
    13241335    for (n=1, Li = LLi.getItem(); Li.hasItem(); Li++, n++)
    13251336    {
    1326       if ( (nGetChar() == 0) || (nGetChar() > 1) )
    1327         MATELEM(res,m,n)=convFactoryPSingP(Li.getItem());
     1337      if ( (rChar(r) == 0) || (rChar(r) > 1) )
     1338        MATELEM(res,m,n)=convFactoryPSingP(Li.getItem(),r);
    13281339      else
    1329         MATELEM(res,m,n)=convFactoryPSingTrP(Li.getItem());
     1340        MATELEM(res,m,n)=convFactoryPSingTrP(Li.getItem(),r);
    13301341    }
    13311342  }
    13321343  Off(SW_RATIONAL);
    13331344  return res;
    1334 }
    1335 
    1336 char* singclap_neworder ( ideal I)
     1345}*/
     1346
     1347/*char* singclap_neworder ( ideal I, const ring r)
    13371348{
    13381349  int i;
     
    13401351  On(SW_SYMMETRIC_FF);
    13411352  CFList L;
    1342   if (((nGetChar() == 0) || (nGetChar() > 1) )
    1343   && (currRing->parameter==NULL))
    1344   {
    1345     setCharacteristic( nGetChar() );
     1353  if (((rChar(r) == 0) || (rChar(r) > 1) )
     1354  && (rPar(r)==0))
     1355  {
     1356    setCharacteristic( rChar(r) );
    13461357    for(i=0;i<IDELEMS(I);i++)
    13471358    {
    1348       L.append(convSingPFactoryP(I->m[i]));
     1359      L.append(convSingPFactoryP(I->m[i],r));
    13491360    }
    13501361  }
    13511362  // and over Q(a) / Fp(a)
    1352   else if (( nGetChar()==1 ) /* Q(a) */
    1353   || (nGetChar() <-1))       /* Fp(a) */
    1354   {
    1355     if (nGetChar()==1) setCharacteristic( 0 );
    1356     else               setCharacteristic( -nGetChar() );
     1363  else if (( rChar(r)==1 ) // Q(a)
     1364  || (rChar(r) <-1))       // Fp(a)
     1365  {
     1366    if (rChar(r)==1) setCharacteristic( 0 );
     1367    else               setCharacteristic( -rChar(r) );
    13571368    for(i=0;i<IDELEMS(I);i++)
    13581369    {
    1359       L.append(convSingTrPFactoryP(I->m[i]));
     1370      L.append(convSingTrPFactoryP(I->m[i],r));
    13601371    }
    13611372  }
     
    13701381  StringSetS("");
    13711382  Li = IL;
    1372   int offs=rPar(currRing);
    1373   int* mark=(int*)omAlloc0((pVariables+offs)*sizeof(int));
    1374   int cnt=pVariables+offs;
     1383  int offs=rPar(r);
     1384  int* mark=(int*)omAlloc0((rVar(r)+offs)*sizeof(int));
     1385  int cnt=rVar(r)+offs;
    13751386  loop
    13761387  {
     
    13821393    {
    13831394      done=FALSE;
    1384       //StringAppendS(currRing->parameter[i]);
     1395      //StringAppendS(r->parameter[i]);
    13851396    }
    13861397    else
    13871398    {
    1388       StringAppendS(currRing->names[i-offs]);
     1399      StringAppendS(r->names[i-offs]);
    13891400    }
    13901401    Li++;
     
    13931404    if (done) StringAppendS(",");
    13941405  }
    1395   for(i=0;i<pVariables+offs;i++)
     1406  for(i=0;i<rVar(r)+offs;i++)
    13961407  {
    13971408    BOOLEAN done=TRUE;
     
    14011412      {
    14021413        done=FALSE;
    1403         //StringAppendS(currRing->parameter[i]);
     1414        //StringAppendS(r->parameter[i]);
    14041415      }
    14051416      else
    14061417      {
    1407         StringAppendS(currRing->names[i-offs]);
     1418        StringAppendS(r->names[i-offs]);
    14081419      }
    14091420      cnt--;
     
    14151426  if (s[strlen(s)-1]==',') s[strlen(s)-1]='\0';
    14161427  return s;
    1417 }
    1418 
    1419 BOOLEAN singclap_isSqrFree(poly f)
     1428}*/
     1429
     1430BOOLEAN singclap_isSqrFree(poly f, const ring r)
    14201431{
    14211432  BOOLEAN b=FALSE;
    14221433  Off(SW_RATIONAL);
    14231434  //  Q / Fp
    1424   if (((nGetChar() == 0) || (nGetChar() > 1) )
    1425   &&(currRing->parameter==NULL))
    1426   {
    1427     setCharacteristic( nGetChar() );
    1428     CanonicalForm F( convSingPFactoryP( f ) );
    1429     if((nGetChar()>1)&&(!F.isUnivariate()))
     1435  if (((rChar(r) == 0) || (rChar(r) > 1) )
     1436  &&(rPar(r)==0))
     1437  {
     1438    setCharacteristic( rChar(r) );
     1439    CanonicalForm F( convSingPFactoryP( f,r ) );
     1440    if((rChar(r)>1)&&(!F.isUnivariate()))
    14301441      goto err;
    14311442    b=(BOOLEAN)isSqrFree(F);
    14321443  }
    14331444  // and over Q(a) / Fp(a)
    1434   else if (( nGetChar()==1 ) /* Q(a) */
    1435   || (nGetChar() <-1))       /* Fp(a) */
    1436   {
    1437     if (nGetChar()==1) setCharacteristic( 0 );
    1438     else               setCharacteristic( -nGetChar() );
    1439     //if (currRing->minpoly!=NULL)
     1445  else if (( rChar(r)==1 ) /* Q(a) */
     1446  || (rChar(r) <-1))       /* Fp(a) */
     1447  {
     1448    if (rChar(r)==1) setCharacteristic( 0 );
     1449    else               setCharacteristic( -rChar(r) );
     1450    //if (r->minpoly!=NULL)
    14401451    //{
    1441     //  CanonicalForm mipo=convSingPFactoryP(((lnumber)currRing->minpoly)->z,
    1442     //                                             currRing->algring);
     1452    //  CanonicalForm mipo=convSingPFactoryP(((lnumber)r->minpoly)->z,
     1453    //                                             r->algring);
    14431454    //  Variable a=rootOf(mipo);
    14441455    //  CanonicalForm F( convSingAPFactoryAP( f,a ) );
     
    14471458    //else
    14481459    {
    1449       CanonicalForm F( convSingTrPFactoryP( f ) );
     1460      CanonicalForm F( convSingTrPFactoryP( f,r ) );
    14501461      b=(BOOLEAN)isSqrFree(F);
    14511462    }
     
    14601471}
    14611472
    1462 poly singclap_det( const matrix m )
     1473poly singclap_det( const matrix m, const ring s )
    14631474{
    14641475  int r=m->rows();
     
    14691480  }
    14701481  poly res=NULL;
    1471   if (( nGetChar() == 0 || nGetChar() > 1 )
    1472   && (currRing->parameter==NULL))
    1473   {
    1474     setCharacteristic( nGetChar() );
     1482  if (( s->cf->ch == 0 || s->cf->ch > 1 )
     1483  && (rPar(s)==0))
     1484  {
     1485    setCharacteristic( s->cf->ch );
    14751486    CFMatrix M(r,r);
    14761487    int i,j;
     
    14791490      for(j=r;j>0;j--)
    14801491      {
    1481         M(i,j)=convSingPFactoryP(MATELEM(m,i,j));
    1482       }
    1483     }
    1484     res= convFactoryPSingP( determinant(M,r) ) ;
     1492        M(i,j)=convSingPFactoryP(MATELEM(m,i,j),s);
     1493      }
     1494    }
     1495    res= convFactoryPSingP( determinant(M,r),s ) ;
    14851496  }
    14861497  // and over Q(a) / Fp(a)
    1487   else if (( nGetChar()==1 ) /* Q(a) */
    1488   || (nGetChar() <-1))       /* Fp(a) */
    1489   {
    1490     if (nGetChar()==1) setCharacteristic( 0 );
    1491     else               setCharacteristic( -nGetChar() );
     1498  else if (( s->cf->ch==1 ) /* Q(a) */
     1499  || (s->cf->ch <-1))       /* Fp(a) */
     1500  {
     1501    if (s->cf->ch==1) setCharacteristic( 0 );
     1502    else               setCharacteristic( -s->cf->ch );
    14921503    CFMatrix M(r,r);
    14931504    poly res;
    1494     if (currRing->minpoly!=NULL)
    1495     {
    1496       CanonicalForm mipo=convSingPFactoryP(((lnumber)currRing->minpoly)->z,
    1497                                             currRing->algring);
     1505    if (rField_is_Extension(s)&& s->cf->algring->minideal!=NULL)
     1506    {
     1507      CanonicalForm mipo=convSingPFactoryP(s->cf->algring->minideal->m[0],
     1508                                           s->cf->algring);
    14981509      Variable a=rootOf(mipo);
    14991510      int i,j;
     
    15021513        for(j=r;j>0;j--)
    15031514        {
    1504           M(i,j)=convSingAPFactoryAP(MATELEM(m,i,j),a,currRing);
     1515          M(i,j)=convSingAPFactoryAP(MATELEM(m,i,j),a,s);
    15051516        }
    15061517      }
    1507       res= convFactoryAPSingAP( determinant(M,r),currRing ) ;
     1518      res= convFactoryAPSingAP( determinant(M,r),s ) ;
    15081519    }
    15091520    else
     
    15141525        for(j=r;j>0;j--)
    15151526        {
    1516           M(i,j)=convSingTrPFactoryP(MATELEM(m,i,j));
     1527          M(i,j)=convSingTrPFactoryP(MATELEM(m,i,j),s);
    15171528        }
    15181529      }
    1519       res= convFactoryPSingTrP( determinant(M,r) );
     1530      res= convFactoryPSingTrP( determinant(M,r),s );
    15201531    }
    15211532  }
     
    15261537}
    15271538
    1528 int singclap_det_i( intvec * m )
     1539int singclap_det_i( intvec * m)
    15291540{
    15301541  setCharacteristic( 0 );
     
    15381549    }
    15391550  }
    1540   int res= convFactoryISingI( determinant(M,m->rows())) ;
     1551  int res= convFactoryISingI( determinant(M,m->rows()) ) ;
    15411552  Off(SW_RATIONAL);
    15421553  return res;
    15431554}
    15441555#ifdef HAVE_NTL
    1545 matrix singntl_HNF(matrix  m )
     1556matrix singntl_HNF(matrix  m, const ring s )
    15461557{
    15471558  int r=m->rows();
     
    15521563  }
    15531564  matrix res=mpNew(r,r);
    1554   if (rField_is_Q(currRing))
     1565  if (rField_is_Q(s))
    15551566  {
    15561567
     
    15611572      for(j=r;j>0;j--)
    15621573      {
    1563         M(i,j)=convSingPFactoryP(MATELEM(m,i,j));
     1574        M(i,j)=convSingPFactoryP(MATELEM(m,i,j),s );
    15641575      }
    15651576    }
     
    15691580      for(j=r;j>0;j--)
    15701581      {
    1571         MATELEM(res,i,j)=convFactoryPSingP((*MM)(i,j));
     1582        MATELEM(res,i,j)=convFactoryPSingP((*MM)(i,j),s);
    15721583      }
    15731584    }
     
    15761587  return res;
    15771588}
    1578 intvec* singntl_HNF(intvec*  m )
     1589intvec* singntl_HNF(intvec*  m)
    15791590{
    15801591  int r=m->rows();
     
    16061617  return mm;
    16071618}
    1608 matrix singntl_LLL(matrix  m )
     1619matrix singntl_LLL(matrix  m, const ring s )
    16091620{
    16101621  int r=m->rows();
    16111622  int c=m->cols();
    16121623  matrix res=mpNew(r,c);
    1613   if (rField_is_Q(currRing))
     1624  if (rField_is_Q(s))
    16141625  {
    16151626    CFMatrix M(r,c);
     
    16191630      for(j=c;j>0;j--)
    16201631      {
    1621         M(i,j)=convSingPFactoryP(MATELEM(m,i,j));
     1632        M(i,j)=convSingPFactoryP(MATELEM(m,i,j),s);
    16221633      }
    16231634    }
     
    16271638      for(j=c;j>0;j--)
    16281639      {
    1629         MATELEM(res,i,j)=convFactoryPSingP((*MM)(i,j));
     1640        MATELEM(res,i,j)=convFactoryPSingP((*MM)(i,j),s);
    16301641      }
    16311642    }
     
    16341645  return res;
    16351646}
    1636 intvec* singntl_LLL(intvec*  m )
     1647intvec* singntl_LLL(intvec*  m)
    16371648{
    16381649  int r=m->rows();
  • libpolys/polys/clapsing.h

    rd75f15 rce3f53c  
    2121//#include <kernel/longtrans.h>
    2222
    23 poly singclap_gcd ( poly f, poly g );
     23poly singclap_gcd ( poly f, poly g, const ring r );
    2424poly singclap_gcd_r ( poly f, poly g, const ring r );
    2525/*
     
    2828*/
    2929
    30 poly singclap_resultant ( poly f, poly g , poly x);
     30poly singclap_resultant ( poly f, poly g , poly x, const ring r);
    3131
    32 BOOLEAN singclap_extgcd ( poly f, poly g, poly &res, poly &pa, poly &pb );
     32BOOLEAN singclap_extgcd ( poly f, poly g, poly &res, poly &pa, poly &pb , const ring r);
    3333BOOLEAN singclap_extgcd_r ( poly f, poly g, poly &res, poly &pa, poly &pb, const ring r );
    3434
    35 poly singclap_pdivide ( poly f, poly g );
     35poly singclap_pdivide ( poly f, poly g, const ring r );
    3636poly singclap_pdivide_r ( poly f, poly g, const ring r );
    3737
    38 void singclap_divide_content ( poly f );
     38void singclap_divide_content ( poly f, const ring r);
    3939
    40 ideal singclap_factorize ( poly f, intvec ** v , int with_exps);
     40ideal singclap_factorize ( poly f, intvec ** v , int with_exps, const ring r);
    4141
    42 ideal singclap_sqrfree ( poly f );
     42ideal singclap_sqrfree ( poly f, const ring r );
    4343
    44 matrix singclap_irrCharSeries ( ideal I);
     44matrix singclap_irrCharSeries ( ideal I, const ring r);
    4545
    4646#ifdef HAVE_NTL
    47 matrix singntl_HNF(matrix A);
    48 intvec* singntl_HNF(intvec* A);
    49 matrix singntl_LLL(matrix A);
    50 intvec* singntl_LLL(intvec* A);
     47matrix singntl_HNF(matrix A, const ring r);
     48intvec* singntl_HNF(intvec* A, const ring r);
     49matrix singntl_LLL(matrix A, const ring r);
     50intvec* singntl_LLL(intvec* A, const ring r);
    5151#endif
    5252
    53 BOOLEAN singclap_isSqrFree(poly f);
     53BOOLEAN singclap_isSqrFree(poly f, const ring r);
    5454
    55 char* singclap_neworder ( ideal I);
     55char* singclap_neworder ( ideal I, const ring r);
    5656
    57 poly singclap_det( const matrix m );
    58 int singclap_det_i( intvec * m );
     57poly singclap_det( const matrix m, const ring r );
     58int singclap_det_i( intvec * m, const ring r );
    5959/*
    6060BOOLEAN jjRESULTANT(leftv res, leftv u, leftv v, leftv w);
  • libpolys/polys/monomials/p_polys.cc

    rd75f15 rce3f53c  
    19091909    if ( (n_GetChar(r) == 1) || (n_GetChar(r) < 0) ) /* Q[a],Q(a),Zp[a],Z/p(a) */
    19101910    {
    1911       singclap_divide_content(ph);
     1911      singclap_divide_content(ph, r);
    19121912      if(!n_GreaterZero(pGetCoeff(ph),r->cf)) ph = p_Neg(ph,r);
    19131913    }
Note: See TracChangeset for help on using the changeset viewer.