Changeset ce2576 in git

Timestamp:

Nov 10, 2011, 5:59:46 PM (12 years ago)

Author:

Martin Lee <martinlee84@…>

Branches:

(u'spielwiese', '91fdef05f09f54b8d58d92a472e9c4a43aa4656f')

Children:

3826d071b0fe1a52a0fa5cdc532b9c99960c5018

Parents:

6051d879db769fabc5f68f3052af02b306ccf1a6

git-author:

Martin Lee <martinlee84@web.de>2011-11-10 17:59:46+01:00

git-committer:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2011-11-10 18:27:53+01:00

Message:

FIX: conversion over algebraic extensions and partly transcendental
NOTE: conversion over transcendental extensions do not work due to bug in p_Cleardenom in p_polys.cc

Location:

libpolys/polys

Files:

• clapconv.cc (modified) (5 diffs)
• clapconv.h (modified) (1 diff)
• clapsing.cc (modified) (18 diffs)

libpolys/polys/clapconv.cc

@@ -17 +17 @@
 #include <omalloc/omalloc.h>
 #include <coeffs/coeffs.h>
+#include <coeffs/longrat.h>
+#include <coeffs/modulop.h>
 #include <polys/monomials/p_polys.h>
 #include <polys/sbuckets.h>
 #include <polys/clapconv.h>
 
-//typedef __mpz_struct lint;
+#include "simpleideals.h"
+
+#define TRANSEXT_PRIVATES
+#include <polys/ext_fields/transext.h>
+
+typedef __mpz_struct lint;
 
 void out_cf(char *s1,const CanonicalForm &f,char *s2);
 
 static void conv_RecPP ( const CanonicalForm & f, int * exp, sBucket_pt result, ring r );
+
+static void convRecTrP ( const CanonicalForm & f, int * exp, poly & result, int offs, const ring r );
+
+static void convRecGFGF ( const CanonicalForm & f, int * exp, poly & result );
 
 static number convFactoryNSingAN( const CanonicalForm &f, const ring r);
@@ -60 +71 @@
     poly term = p_Init(r);
     pNext( term ) = NULL;
-    int varoffset=r->cf->factoryVarOffset;
     for ( int i = 1; i <= r->N; i++ )
-      p_SetExp( term, i-varoffset, exp[i], r);
+      p_SetExp( term, i, exp[i], r);
     pGetCoeff( term )=r->cf->convFactoryNSingN(f, r->cf);
     p_Setm( term, r );
@@ -89 +99 @@
     if (errorreported) break;
     setChar=FALSE;
-    int varoffset=r->cf->factoryVarOffset;
     for ( int i = n; i >0; i-- )
     {
       if ( (e = p_GetExp( p, i, r)) != 0 )
-        term *= power( Variable( i+varoffset ), e );
+        term *= power( Variable( i ), e );
     }
     result += term;
@@ -101 +110 @@
 }
 
-CanonicalForm convSingAFactoryA( number pp, Variable a, const coeffs cf )
+int convFactoryISingI( const CanonicalForm & f)
+{
+  if (!f.isImm()) WerrorS("int overflow in det");
+  return f.intval();
+}
+
+CanonicalForm convSingAPFactoryAP ( poly p , const Variable & a, const ring r)
+{
+  CanonicalForm result = 0;
+  int e, n = r-> N;
+  int off=rPar(r);
+
+  On(SW_RATIONAL);
+  while ( p!=NULL)
+  {
+    CanonicalForm term=convSingAFactoryA(((poly)p_GetCoeff(p, r->cf->extRing)),a, r);
+    for ( int i = 1; i <= n; i++ )
+    {
+      if ( (e = p_GetExp( p, i, r )) != 0 )
+        term *= power( Variable( i + off), e );
+    }
+    result += term;
+    pIter( p );
+  }
+  return result;
+}
+
+static void
+convRecAP_R ( const CanonicalForm & f, int * exp, poly & result, int par_start, int var_start, const ring r) ;
+
+poly convFactoryAPSingAP_R ( const CanonicalForm & f, int par_start, int var_start, const ring r )
+{
+  int n = rVar(r)+rPar(r)+1;
+  int * exp = (int *)omAlloc0(n*sizeof(int));
+  poly result = NULL;
+  convRecAP_R( f, exp, result,par_start, var_start, r );
+  omFreeSize((ADDRESS)exp,n*sizeof(int));
+  return result;
+}
+
+poly convFactoryAPSingAP ( const CanonicalForm & f, const ring r )
+{
+  return convFactoryAPSingAP_R(f,0,rPar(r),r);
+}
+
+static void convRecAP_R ( const CanonicalForm & f, int * exp, poly & result, int par_start, int var_start, const ring r )
+{
+  if (f.isZero())
+    return;
+  if ( ! f.inCoeffDomain() )
+  {
+    int l = f.level();
+    for ( CFIterator i = f; i.hasTerms(); i++ )
+    {
+      exp[l] = i.exp();
+      convRecAP_R( i.coeff(), exp, result, par_start, var_start, r);
+    }
+    exp[l] = 0;
+  }
+  else
+  {
+    poly z=(poly)convFactoryASingA( f,r );
+    if (z!=NULL)
+    {
+      poly term = p_Init(r);
+      pNext( term ) = NULL;
+      int i;
+      for ( i = rVar(r); i>0 ; i-- )
+        p_SetExp( term, i , exp[i+var_start],r);
+      //if (rRing_has_Comp(currRing->extRing)) p_SetComp(term, 0, currRing->extRing); // done by pInit
+      if (par_start==0)
+      {
+        for ( i = 1; i <= var_start; i++ )
+        //z->e[i-1]+=exp[i];
+          p_AddExp(z,i,exp[i],r->cf->extRing);
+      }
+      else
+      {
+        for ( i = par_start+1; i <= var_start+rPar(r); i++ )
+        //z->e[i-1]+=exp[i];
+          p_AddExp(z,i,exp[i-par_start],r->cf->extRing);
+      }
+      pGetCoeff(term)=(number)ALLOC0_RNUMBER();
+      p_GetCoeff(term, r->cf->extRing)=(number) z;
+      p_Setm( term,r );
+      result = p_Add_q( result, term, r );
+    }
+  }
+}
+
+CanonicalForm convSingAFactoryA ( poly p , const Variable & a, const ring r )
 {
   CanonicalForm result = 0;
   int e;
-  poly p=(poly)pp;
-  BOOLEAN setChar=TRUE;
 
   while ( p!=NULL )
   {
     CanonicalForm term;
-    term=cf->extRing->cf->convSingNFactoryN(pGetCoeff( p ),setChar, cf->extRing->cf);
-    if (errorreported) break;
-    setChar=FALSE;
-    if ( (e = p_GetExp( p, 1, cf->extRing)) != 0 )
-        term *= power( a, e );
+    if ( rField_is_Zp_a(r) )
+    {
+      term = n_Int( p_GetCoeff( p, r->cf->extRing ), r->cf->extRing->cf );
+    }
+    else
+    {
+      if ( SR_HDL(p_GetCoeff( p, r->cf->extRing )) & SR_INT )
+        term = SR_TO_INT(p_GetCoeff( p, r->cf->extRing )) ;
+      else
+      {
+        if ( p_GetCoeff( p, r->cf->extRing )->s == 3 )
+        {
+          lint dummy;
+          mpz_init_set( &dummy, (p_GetCoeff( p,r->cf->extRing )->z) );
+          term = make_cf( dummy );
+        }
+        else
+        {
+          // assume s==0 or s==1
+          lint num, den;
+          On(SW_RATIONAL);
+          mpz_init_set( &num, (p_GetCoeff( p, r->cf->extRing )->z) );
+          mpz_init_set( &den, (p_GetCoeff( p, r->cf->extRing )->n) );
+          term = make_cf( num, den, ( p_GetCoeff( p, r->cf->extRing )->s != 1 ));
+        }
+      }
+    }
+    if ( (e = p_GetExp( p, 1, r->cf->extRing )) != 0 )
+      term *= power( a , e );
     result += term;
-    pIter( p );
-  }
-  return result;
-}
-
-number convFactoryASingA ( const CanonicalForm & f, const coeffs cf )
+    p = pNext( p );
+  }
+  return result;
+}
+
+static number convFactoryNSingAN( const CanonicalForm &f, const ring r)
+{
+  if ( f.isImm() )
+    return n_Init( f.intval(), r->cf->extRing->cf);
+  else
+  {
+    number z=ALLOC_RNUMBER();
+#if defined(LDEBUG)
+    z->debug=123456;
+#endif
+    gmp_numerator( f, z->z );
+    if ( f.den().isOne() )
+    {
+      z->s = 3;
+    }
+    else
+    {
+      gmp_denominator( f, z->n );
+      z->s = 0;
+      nlNormalize(z,r->cf->extRing->cf);
+    }
+    /*#ifdef LDEBUG
+    nlTest(z,r->cf->extRing->cf);
+    #endif*/
+    return z;
+  }
+}
+
+poly convFactoryASingA ( const CanonicalForm & f, const ring r )
 {
   poly a=NULL;
@@ -128 +277 @@
   for( CFIterator i=f; i.hasTerms(); i++)
   {
-    t=p_New(cf->extRing);
-    // pNext( t ) = NULL; //already done by napNew
-    pGetCoeff(t)=cf->extRing->cf->convFactoryNSingN( i.coeff(), cf->extRing->cf );
-    if (n_IsZero(p_GetCoeff(t,cf->extRing),cf->extRing->cf))
-    {
-      p_Delete(&t,cf->extRing);
+    t= p_Init (r->cf->extRing);
+    p_GetCoeff(t, r->cf->extRing)= convFactoryNSingAN( i.coeff(), r );
+    if (n_IsZero(p_GetCoeff(t,r->cf->extRing),r->cf->extRing->cf))
+    {
+      p_Delete(&t,r->cf->extRing);
     }
     else
     {
-      p_SetExp(t,1,i.exp(),cf->extRing);
-      a=p_Add_q(a,t,cf->extRing);
-    }
-  }
-  number aa=(number)a;
-  n_Normalize(aa,cf);
-  return aa;
-}
-
-
-int convFactoryISingI( const CanonicalForm & f)
-{
-  if (!f.isImm()) WerrorS("int overflow in det");
-  return f.intval();
-}
+      p_SetExp(t,1,i.exp(),r->cf->extRing);
+      a=p_Add_q(a,t,r->cf->extRing);
+    }
+  }
+  if (a!=NULL)
+  {
+    if (r->cf->extRing->minideal->m[0]!=NULL)
+    {
+      poly l=r->cf->extRing->minideal->m[0];
+      if (p_GetExp(a,1,r->cf->extRing) >= p_GetExp(l,1,r->cf->extRing))
+        a = p_PolyDiv (a, l, FALSE, r->cf->extRing);
+    }
+  }
+  return a;
+}
+
+CanonicalForm convSingTrPFactoryP ( poly p, const ring r )
+{
+  CanonicalForm result = 0;
+  int e, n = rVar(r);
+  int offs = rPar(r);
+
+  while ( p!=NULL )
+  {
+    n_Normalize(p_GetCoeff(p, r), r->cf);
+    CanonicalForm term=convSingPFactoryP(NUM(p_GetCoeff(p, r)),r->cf->extRing);
+
+    if ((DEN(p_GetCoeff(p,r))!=NULL)
+    && (!errorreported))
+    {
+      WerrorS("conversion error: denominator!= 1");
+    }
+
+    for ( int i = n; i > 0; i-- )
+    {
+      if ( (e = p_GetExp( p, i,r )) != 0 )
+        term = term * power( Variable( i + offs ), e );
+    }
+    result += term;
+    p = pNext( p );
+  }
+  return result;
+}
+
+poly convFactoryPSingTrP ( const CanonicalForm & f, const ring r )
+{
+  int n = rVar(r)+1;
+  int * exp = (int*)omAlloc0(n*sizeof(int));
+  poly result = NULL;
+  convRecTrP( f, exp, result , rPar(r), r );
+  omFreeSize((ADDRESS)exp,n*sizeof(int));
+  return result;
+}
+
+static void
+convRecTrP ( const CanonicalForm & f, int * exp, poly & result , int offs, const ring r)
+{
+  if (f.isZero())
+    return;
+  if ( f.level() > offs )
+  {
+    int l = f.level();
+    for ( CFIterator i = f; i.hasTerms(); i++ )
+    {
+      exp[l-offs] = i.exp();
+      convRecTrP( i.coeff(), exp, result, offs, r );
+    }
+    exp[l-offs] = 0;
+  }
+  else
+  {
+    poly term = p_Init(r);
+    pNext( term ) = NULL;
+    for ( int i = rVar(r); i>0; i-- )
+      p_SetExp( term, i ,exp[i], r);
+    //if (rRing_has_Comp(currRing)) p_SetComp(term, 0, currRing); // done by pInit
+    pGetCoeff(term) = ALLOC0_RNUMBER(); // Q!?
+    NUM(pGetCoeff(term))=convFactoryPSingP( f, r->cf->extRing );
+    p_Setm( term,r );
+    result = p_Add_q( result, term,r );
+  }
+}
+
+#if 0
+CanonicalForm
+convSingGFFactoryGF( poly p )
+{
+  CanonicalForm result=CanonicalForm(0);
+  int e, n = pVariables;
+
+  while ( p != NULL )
+  {
+    CanonicalForm term;
+    term = make_cf_from_gf( (int)(long)pGetCoeff( p ) );
+    //int * A=(int *)&term;
+    //Print("term=%x, == 0 ?: %d\n",*A, term.isZero());
+    for ( int i = 1; i <= n; i++ )
+    {
+      if ( (e = pGetExp( p, i )) != 0 )
+         term *= power( Variable( i ), e );
+    }
+    result += term;
+    p = pNext( p );
+  }
+  return result;
+}
+
+poly
+convFactoryGFSingGF ( const CanonicalForm & f )
+{
+//    cerr << " f = " << f << endl;
+  int n = pVariables+1;
+  /* ASSERT( level( f ) <= pVariables, "illegal number of variables" ); */
+  int * exp = (int*)omAlloc0(n*sizeof(int));
+  poly result = NULL;
+  convRecGFGF( f, exp, result );
+  omFreeSize((ADDRESS)exp,n*sizeof(int));
+  return result;
+}
+
+static void
+convRecGFGF ( const CanonicalForm & f, int * exp, poly & result )
+{
+  if (f.isZero())
+    return;
+  if ( ! f.inCoeffDomain() )
+  {
+    int l = f.level();
+    for ( CFIterator i = f; i.hasTerms(); i++ )
+    {
+      exp[l] = i.exp();
+      convRecGFGF( i.coeff(), exp, result );
+    }
+    exp[l] = 0;
+  }
+  else
+  {
+    poly term = pInit();
+    pNext( term ) = NULL;
+    for ( int i = 1; i <= pVariables; i++ )
+      pSetExp( term, i, exp[i]);
+    //if (rRing_has_Comp(currRing)) p_SetComp(term, 0, currRing); // done by pInit
+    pGetCoeff( term ) = (number) gf_value (f);
+    pSetm( term );
+    result = pAdd( result, term );
+  }
+}
+
 #endif
+#endif

libpolys/polys/clapconv.h

@@ -22 +22 @@
 int convFactoryISingI( const CanonicalForm & f);
 
-CanonicalForm convSingAFactoryA( number pp, Variable a, const coeffs cf );
-number convFactoryASingA ( const CanonicalForm & f, const coeffs cf );
+CanonicalForm convSingAPFactoryAP ( poly p , const Variable & a, const ring r );
+poly convFactoryAPSingAP ( const CanonicalForm & f, const ring r );
+poly convFactoryAPSingAP_R ( const CanonicalForm & f, int par_start, int var_start );
+
+//CanonicalForm convSingGFFactoryGF ( poly p, const ring r );
+//poly convFactoryGFSingGF ( const CanonicalForm & f, const ring r );
+
+CanonicalForm convSingAFactoryA ( poly p , const Variable & a, const ring r );
+poly convFactoryASingA ( const CanonicalForm & f, const ring r );
+
+CanonicalForm convSingTrPFactoryP ( poly p, const ring r );
+poly convFactoryPSingTrP ( const CanonicalForm & f, const ring r );
 
 // HAVE_FACTORY

libpolys/polys/clapsing.cc

@@ -31 +31 @@
 #include "ext_fields/transext.h"
 
-// TODO(Martin, Please adapt the following code for the use in SW)
-
 
 #include "clapsing.h"
@@ -58 +56 @@
 
   Off(SW_RATIONAL);
-  CanonicalForm F( convSingPFactoryP( f,r ) ), G( convSingPFactoryP( g, r ) );
-  bool b1=isOn(SW_USE_QGCD);
-  bool b2=isOn(SW_USE_fieldGCD);
-  if ( rField_is_Q_a(r) ) On(SW_USE_QGCD);
-  else                   On(SW_USE_fieldGCD);
-  res=convFactoryPSingP( gcd( F, G ) , r);
-  if (!b1) Off(SW_USE_QGCD);
-  if (!b2) Off(SW_USE_fieldGCD);
+  if (rField_is_Q(r) || (rField_is_Zp(r)))
+  {
+    bool b1=isOn(SW_USE_EZGCD_P);
+    Off (SW_USE_NTL_GCD_P);
+    setCharacteristic( rChar(r) );
+    CanonicalForm F( convSingPFactoryP( f,r ) ), G( convSingPFactoryP( g, r ) );
+    res=convFactoryPSingP( gcd( F, G ) , r);
+    if (!b1) Off (SW_USE_EZGCD_P);
+  }
+  // and over Q(a) / Fp(a)
+  else if ( rField_is_Extension(r))
+  {
+    if ( rField_is_Q_a(r)) setCharacteristic( 0 );
+    else                   setCharacteristic( rChar(r) );
+    if (r->cf->extRing->minideal!=NULL)
+    {
+      bool b1=isOn(SW_USE_QGCD);
+      bool b2=isOn(SW_USE_fieldGCD);
+      if ( rField_is_Q_a(r) ) On(SW_USE_QGCD);
+      else                   On(SW_USE_fieldGCD);
+      CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->minideal->m[0],
+                                           r->cf->extRing);
+      Variable a=rootOf(mipo);
+      CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
+                    G( convSingAPFactoryAP( g,a,r ) );
+      res= convFactoryAPSingAP( gcd( F, G ),r );
+      if (!b1) Off(SW_USE_QGCD);
+      if (!b2) Off(SW_USE_fieldGCD);
+    }
+    else
+    {
+      CanonicalForm F( convSingTrPFactoryP( f,r ) ), G( convSingTrPFactoryP( g,r ) );
+      res= convFactoryPSingTrP( gcd( F, G ),r );
+    }
+  }
+  else
+    WerrorS( feNotImplemented );
   Off(SW_RATIONAL);
   return res;
@@ -111 +138 @@
   if ((f==NULL) || (g==NULL))
     goto resultant_returns_res;
-  {  
-    Variable X(i); // TODO: consider extensions
-    CanonicalForm F( convSingPFactoryP( f, r ) ), G( convSingPFactoryP( g, r ) );
-    res=convFactoryPSingP( resultant( F, G, X ), r );
+  // for now there is only the possibility to handle polynomials over
+  // Q and Fp ...
+  if (rField_is_Zp(r) || rField_is_Q(r))
+  {
+    Variable X(i);
+    setCharacteristic( rChar(r) );
+    CanonicalForm F( convSingPFactoryP( f,r ) ), G( convSingPFactoryP( g,r ) );
+    res=convFactoryPSingP( resultant( F, G, X),r );
     Off(SW_RATIONAL);
-  }
+    goto resultant_returns_res;
+  }
+  // and over Q(a) / Fp(a)
+  else if (rField_is_Extension(r))
+  {
+    if (rField_is_Q_a(r)) setCharacteristic( 0 );
+    else               setCharacteristic( rChar(r) );
+    Variable X(i+rPar(r));
+    if (r->cf->extRing->minideal!=NULL)
+    {
+      //Variable X(i);
+      CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->minideal->m[0],
+                                           r->cf->extRing);
+      Variable a=rootOf(mipo);
+      CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
+                    G( convSingAPFactoryAP( g,a,r ) );
+      res= convFactoryAPSingAP( resultant( F, G, X ),r );
+    }
+    else
+    {
+      //Variable X(i+rPar(currRing));
+      number nf,ng;
+      p_Cleardenom_n(f,r,nf);p_Cleardenom_n(g,r,ng);
+      int ef,eg;
+      ef=pGetExp_Var(f,i,r);
+      eg=pGetExp_Var(g,i,r);
+      CanonicalForm F( convSingTrPFactoryP( f,r ) ), G( convSingTrPFactoryP( g,r ) );
+      res= convFactoryPSingTrP( resultant( F, G, X ),r );
+      if ((nf!=NULL)&&(!n_IsOne(nf,r->cf))&&(!n_IsZero(nf,r->cf)))
+      {
+        number n=n_Invers(nf,r->cf);
+        while(eg>0)
+        {
+          res=p_Mult_nn(res,n,r);
+          eg--;
+        }
+        n_Delete(&n,r->cf);
+      }
+      n_Delete(&nf,r->cf);
+      if ((ng!=NULL)&&(!n_IsOne(ng,r->cf))&&(!n_IsZero(ng,r->cf)))
+      {
+        number n=n_Invers(ng,r->cf);
+        while(ef>0)
+        {
+          res=p_Mult_nn(res,n,r);
+          ef--;
+        }
+        n_Delete(&n,r->cf);
+      }
+      n_Delete(&ng,r->cf);
+    }
+    Off(SW_RATIONAL);
+    goto resultant_returns_res;
+  }
+  else
+    WerrorS( feNotImplemented );
 resultant_returns_res:
   p_Delete(&f,r);
@@ -190 +276 @@
   res=NULL;pa=NULL;pb=NULL;
   On(SW_SYMMETRIC_FF);
-  CanonicalForm F( convSingPFactoryP( f, r ) ), G( convSingPFactoryP( g, r ) );
-  CanonicalForm FpG=F+G;
-  if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
-  //if (!F.isUnivariate() || !G.isUnivariate() || F.mvar()!=G.mvar())
-  {
+  if ( rField_is_Q(r) || rField_is_Zp(r) )
+  {
+    setCharacteristic( rChar(r) );
+    CanonicalForm F( convSingPFactoryP( f,r ) ), G( convSingPFactoryP( g,r) );
+    CanonicalForm FpG=F+G;
+    if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
+    //if (!F.isUnivariate() || !G.isUnivariate() || F.mvar()!=G.mvar())
+    {
+      Off(SW_RATIONAL);
+      WerrorS("not univariate");
+      return TRUE;
+    }
+    CanonicalForm Fa,Gb;
+    On(SW_RATIONAL);
+    res=convFactoryPSingP( extgcd( F, G, Fa, Gb ),r );
+    pa=convFactoryPSingP(Fa,r);
+    pb=convFactoryPSingP(Gb,r);
     Off(SW_RATIONAL);
-    WerrorS("not univariate");
+  }
+  // and over Q(a) / Fp(a)
+  else if ( rField_is_Extension(r))
+  {
+    if (rField_is_Q_a(r)) setCharacteristic( 0 );
+    else                 setCharacteristic( rChar(r) );
+    CanonicalForm Fa,Gb;
+    if (r->cf->extRing->minideal!=NULL)
+    {
+      CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->minideal->m[0],
+                                           r->cf->extRing);
+      Variable a=rootOf(mipo);
+      CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
+                    G( convSingAPFactoryAP( g,a,r ) );
+      CanonicalForm FpG=F+G;
+      if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
+      //if (!F.isUnivariate() || !G.isUnivariate() || F.mvar()!=G.mvar())
+      {
+        WerrorS("not univariate");
+        return TRUE;
+      }
+      res= convFactoryAPSingAP( extgcd( F, G, Fa, Gb ),r );
+      pa=convFactoryAPSingAP(Fa,r);
+      pb=convFactoryAPSingAP(Gb,r);
+    }
+    else
+    {
+      CanonicalForm F( convSingTrPFactoryP( f, r ) ), G( convSingTrPFactoryP( g, r ) );
+      CanonicalForm FpG=F+G;
+      if (!(FpG.isUnivariate()|| FpG.inCoeffDomain()))
+      //if (!F.isUnivariate() || !G.isUnivariate() || F.mvar()!=G.mvar())
+      {
+        Off(SW_RATIONAL);
+        WerrorS("not univariate");
+        return TRUE;
+      }
+      res= convFactoryPSingTrP( extgcd( F, G, Fa, Gb ), r );
+      pa=convFactoryPSingTrP(Fa, r);
+      pb=convFactoryPSingTrP(Gb, r);
+    }
+    Off(SW_RATIONAL);
+  }
+  else
+  {
+    WerrorS( feNotImplemented );
     return TRUE;
   }
-  CanonicalForm Fa,Gb;
-  On(SW_RATIONAL);
-  res=convFactoryPSingP( extgcd( F, G, Fa, Gb ), r );
-  pa=convFactoryPSingP(Fa, r);
-  pb=convFactoryPSingP(Gb, r);
-  Off(SW_RATIONAL);
 #ifndef NDEBUG
   // checking the result of extgcd:
@@ -212 +348 @@
   {
     PrintS("extgcd( ");p_Write(f,r);p_Write0(g,r);PrintS(" )\n");
-    PrintS("gcd, co-factors:");p_Write(res,r); p_Write(pa,r);p_Write(pb,r);
+    PrintS("extgcd( ");p_Write(f,r);p_Write0(g,r);PrintS(" )\n");
     p_Delete(&dummy,r);
   }
@@ -223 +359 @@
   poly res=NULL;
   On(SW_RATIONAL);
-  CanonicalForm F( convSingPFactoryP( f,r ) ), G( convSingPFactoryP( g,r ) );
-  res = convFactoryPSingP( F / G,r );
+  if (rField_is_Zp(r) || rField_is_Q(r))
+  {
+    setCharacteristic( rChar(r) );
+    CanonicalForm F( convSingPFactoryP( f,r ) ), G( convSingPFactoryP( g,r ) );
+    res = convFactoryPSingP( F / G,r );
+  }
+  else if (rField_is_Extension(r))
+  {
+    if (rField_is_Q_a(r)) setCharacteristic( 0 );
+    else               setCharacteristic( rChar(r) );
+    if (r->cf->extRing->minideal!=NULL)
+    {
+      CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->minideal->m[0],
+                                                 r->cf->extRing);
+      Variable a=rootOf(mipo);
+      CanonicalForm F( convSingAPFactoryAP( f,a,r ) ),
+                    G( convSingAPFactoryAP( g,a,r ) );
+      res= convFactoryAPSingAP(  F / G, r  );
+    }
+    else
+    {
+      CanonicalForm F( convSingTrPFactoryP( f,r ) ), G( convSingTrPFactoryP( g,r ) );
+      res= convFactoryPSingTrP(  F / G,r  );
+    }
+  }
+  #if 0 // not yet working
+  else if (rField_is_GF())
+  {
+    //Print("GF(%d^%d)\n",nfCharP,nfMinPoly[0]);
+    setCharacteristic( nfCharP,nfMinPoly[0], currRing->parameter[0][0] );
+    CanonicalForm F( convSingGFFactoryGF( f ) ), G( convSingGFFactoryGF( g ) );
+    res = convFactoryGFSingGF( F / G );
+  }
+  #endif
+  else
+    WerrorS( feNotImplemented );
   Off(SW_RATIONAL);
   return res;
@@ -342 +512 @@
   {
 #ifdef FACTORIZE2_DEBUG
-    printf("start count_Factors(%d), Fdeg=%d, factor deg=%d\n",j,pTotaldegree(f),pTotaldegree(fac));
+    printf("start count_Factors(%d), Fdeg=%d, factor deg=%d\n",j,p_Totaldegree(f,r),p_Totaldegree(fac,r));
     p_wrp(fac,r);PrintLn();
 #endif
@@ -348 +518 @@
     CanonicalForm F, FAC,Q,R;
     Variable a;
-    F=convSingPFactoryP( f,r );
-    FAC=convSingPFactoryP( fac,r );
+    if (rField_is_Zp(r) || rField_is_Q(r))
+    {
+      F=convSingPFactoryP( f,r );
+      FAC=convSingPFactoryP( fac,r );
+    }
+    else if (rField_is_Extension(r))
+    {
+      if (r->cf->extRing->minideal!=NULL)
+      {
+        CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->minideal->m[0],
+                                    r->cf->extRing);
+        a=rootOf(mipo);
+        F=convSingAPFactoryAP( f,a,r );
+        FAC=convSingAPFactoryAP( fac,a,r );
+      }
+      else
+      {
+        F=convSingTrPFactoryP( f,r );
+        FAC=convSingTrPFactoryP( fac,r );
+      }
+    }
+    else
+      WerrorS( feNotImplemented );
 
     poly q;
@@ -361 +552 @@
       if (R.isZero())
       {
-        q = convFactoryPSingP( Q,r );
+        if (rField_is_Zp(r) || rField_is_Q(r))
+        {
+          q = convFactoryPSingP( Q,r );
+        }
+        else if (rField_is_Extension(r))
+        {
+          if (r->cf->extRing->minideal!=NULL)
+          {
+            q= convFactoryAPSingAP( Q,r );
+          }
+          else
+          {
+            q= convFactoryPSingTrP( Q,r );
+          }
+        }
         e++; p_Delete(&f,r); f=q; q=NULL; F=Q;
       }
@@ -394 +599 @@
   p_Test(f,r);
 #ifdef FACTORIZE2_DEBUG
-  printf("singclap_factorize, degree %ld\n",pTotaldegree(f));
+  printf("singclap_factorize, degree %ld\n",p_Totaldegree(f,r));
 #endif
   // with_exps: 3,1 return only true factors, no exponents
@@ -461 +666 @@
     return res;
   }
-  //PrintS("S:");pWrite(f);PrintLn();
+  //PrintS("S:");p_Write(f,r);PrintLn();
   // use factory/libfac in general ==============================
   Off(SW_RATIONAL);
@@ -482 +687 @@
         N=n_Copy(n0,r->cf);
       p_Cleardenom(f, r);
+      //after here f should not have a denominator!!
+      //PrintS("S:");p_Write(f,r);PrintLn();
       NN=n_Div(n0,pGetCoeff(f),r->cf);
       n_Delete(&n0,r->cf);
@@ -519 +726 @@
   else if (rField_is_Extension(r))
   {
+    if (rField_is_Q_a (r)) setCharacteristic (0);
+    else                   setCharacteristic( rChar(r) );
     if (r->cf->extRing->minideal!=NULL)
     {
@@ -524 +733 @@
                                            r->cf->extRing);
       Variable a=rootOf(mipo);
-      CanonicalForm F( convSingPFactoryP( f,r ) );
+      CanonicalForm F( convSingAPFactoryAP( f, a, r ) );
       if (rField_is_Zp_a(r))
       {
@@ -537 +746 @@
     else
     {
-      CanonicalForm F( convSingPFactoryP( f,r ) );
+      CanonicalForm F( convSingTrPFactoryP( f,r ) );
       L = factorize( F );
     }
@@ -583 +792 @@
         if (r->cf->extRing->minideal==NULL)
         {
-          if(!count_Factors(res,w,j,ff,convFactoryPSingP( J.getItem().factor(),r ),r))
+          if(!count_Factors(res,w,j,ff,convFactoryPSingTrP( J.getItem().factor(),r ),r))
           {
             if (w!=NULL)
@@ -592 +801 @@
         else
         {
-          if (!count_Factors(res,w,j,ff,convFactoryPSingP( J.getItem().factor(),r ),r))
+          if (!count_Factors(res,w,j,ff,convFactoryAPSingAP( J.getItem().factor(),r ),r))
           {
             if (w!=NULL)
@@ -1229 +1438 @@
 #endif
 
-/*
-napoly singclap_alglcm ( napoly f, napoly g )
-{
-
- // over Q(a) / Fp(a)
- if (nGetChar()==1) setCharacteristic( 0 );
- else               setCharacteristic( -nGetChar() );
- napoly res;
-
- if (currRing->minpoly!=NULL)
- {
-   CanonicalForm mipo=convSingPFactoryP(((lnumber)currRing->minpoly)->z,
-                                         currRing->extRing);
-   Variable a=rootOf(mipo);
-   CanonicalForm F( convSingAFactoryA( f,a, currRing ) ),
-                 G( convSingAFactoryA( g,a, currRing ) );
-   CanonicalForm GCD;
-
-   // calculate gcd
-   GCD = gcd( F, G );
-
-   // calculate lcm
-   res= convFactoryASingA( (F/GCD)*G,currRing );
- }
- else
- {
-   CanonicalForm F( convSingPFactoryP( f,currRing->extRing ) ),
-                 G( convSingPFactoryP( g,currRing->extRing ) );
-   CanonicalForm GCD;
-   // calculate gcd
-   GCD = gcd( F, G );
-
-   // calculate lcm
-   res= convFactoryPSingP( (F/GCD)*G, currRing->extRing );
- }
-
- Off(SW_RATIONAL);
- return res;
-}
-
-void singclap_algdividecontent ( napoly f, napoly g, napoly &ff, napoly &gg )
-{
- // over Q(a) / Fp(a)
- if (nGetChar()==1) setCharacteristic( 0 );
- else               setCharacteristic( -nGetChar() );
- ff=gg=NULL;
- On(SW_RATIONAL);
-
- if (currRing->minpoly!=NULL)
- {
-   CanonicalForm mipo=convSingPFactoryP(((lnumber)currRing->minpoly)->z,
-                         currRing->extRing);
-   Variable a=rootOf(mipo);
-   CanonicalForm F( convSingAFactoryA( f,a, currRing ) ),
-                 G( convSingAFactoryA( g,a, currRing ) );
-   CanonicalForm GCD;
-
-   GCD=gcd( F, G );
-
-   if ((GCD!=1) && (GCD!=0))
-   {
-     ff= convFactoryASingA( F/ GCD, currRing );
-     gg= convFactoryASingA( G/ GCD, currRing );
-   }
- }
- else
- {
-   CanonicalForm F( convSingPFactoryP( f,currRing->extRing ) ),
-                 G( convSingPFactoryP( g,currRing->extRing ) );
-   CanonicalForm GCD;
-
-   GCD=gcd( F, G );
-
-   if ((GCD!=1) && (GCD!=0))
-   {
-     ff= convFactoryPSingP( F/ GCD, currRing->extRing );
-     gg= convFactoryPSingP( G/ GCD, currRing->extRing );
-   }
- }
-
- Off(SW_RATIONAL);
-}
-*/
-
-#if 0
-lists singclap_chineseRemainder(lists x, lists q)
-{
-  //assume(x->nr == q->nr);
-  //assume(x->nr >= 0);
-  int n=x->nr+1;
-  if ((x->nr<0) || (x->nr!=q->nr))
-  {
-    WerrorS("list are empty or not of equal length");
-    return NULL;
-  }
-  lists res=(lists)omAlloc0Bin(slists_bin);
-  CFArray X(1,n), Q(1,n);
-  int i;
-  for(i=0; i<n; i++)
-  {
-    if (x->m[i-1].Typ()==INT_CMD)
-    {
-      X[i]=(int)x->m[i-1].Data();
-    }
-    else if (x->m[i-1].Typ()==NUMBER_CMD)
-    {
-      number N=(number)x->m[i-1].Data();
-      X[i]=convSingNFactoryN(N);
-    }
-    else
-    {
-      WerrorS("illegal type in chineseRemainder");
-      omFreeBin(res,slists_bin);
-      return NULL;
-    }
-    if (q->m[i-1].Typ()==INT_CMD)
-    {
-      Q[i]=(int)q->m[i-1].Data();
-    }
-    else if (q->m[i-1].Typ()==NUMBER_CMD)
-    {
-      number N=(number)x->m[i-1].Data();
-      Q[i]=convSingNFactoryN(N);
-    }
-    else
-    {
-      WerrorS("illegal type in chineseRemainder");
-      omFreeBin(res,slists_bin);
-      return NULL;
-    }
-  }
-  CanonicalForm r, prod;
-  chineseRemainder( X, Q, r, prod );
-  res->Init(2);
-  res->m[0].rtyp=NUMBER_CMD;
-  res->m[1].rtyp=NUMBER_CMD;
-  res->m[0].data=(char *)convFactoryNSingN( r );
-  res->m[1].data=(char *)convFactoryNSingN( prod );
-  return res;
-}
-#endif
-
-number   nChineseRemainder(number *x, number *q,int rl, const coeffs r)
-// elemenst in the array are x[0..(rl-1)], q[0..(rl-1)]
-{
-#ifdef HAVE_FACTORY
-  if (r->type!=n_Q)
-  { Werror("nChineseRemainder only for integers"); return NULL; }
-  setCharacteristic( 0 ); // only in char 0
-  CFArray X(rl), Q(rl);
-  int i;
-  for(i=rl-1;i>=0;i--)
-  {
-    X[i]=r->convSingNFactoryN(x[i],FALSE,r); // may be larger MAX_INT
-    Q[i]=r->convSingNFactoryN(q[i],FALSE,r); // may be larger MAX_INT
-  }
-  CanonicalForm xnew,qnew;
-  chineseRemainder(X,Q,xnew,qnew);
-  number n=r->convFactoryNSingN(xnew,r);
-  number p=r->convFactoryNSingN(qnew,r);
-  number p2=n_IntDiv(p,n_Init(2, r),r);
-  if (n_Greater(n,p2,r))
-  {
-     number n2=n_Sub(n,p,r);
-     n_Delete(&n,r);
-     n=n2;
-  }
-  n_Delete(&p,r);
-  n_Delete(&p2,r);
-  return n;
-#else
-  WerrorS("not implemented");
-  return n_Init(0,r);
-#endif
-}