Changeset 6a1aa7 in git for libpolys

Timestamp:

Jul 11, 2014, 5:08:34 PM (10 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '38077648e7239f98078663eb941c3c979511150a')

Children:

1234c77ed4ce613f813076f72fa15a303743e451312a931ca75e1ecf46c185282254d34874f9f4a4

Parents:

653440a090c5b7f2086e19c2cadf27bb08f91644

git-author:

Hans Schoenemann <hannes@mathematik.uni-kl.de>2014-07-11 17:08:34+02:00

git-committer:

Hans Schoenemann <hannes@mathematik.uni-kl.de>2014-07-11 17:09:41+02:00

Message:

preparation for more integer representations

n_Init_bigint: substituted by n_setMap/nMap
introduced cf->rep for different data representation
introduced several (experimental) integer variants
   via #define in libpolys/misc/auxiliary.h.in

Location:

libpolys

Files:

• coeffs/OPAE.cc (modified) (1 diff)
• coeffs/OPAEQ.cc (modified) (1 diff)
• coeffs/OPAEp.cc (modified) (1 diff)
• coeffs/coeffs.h (modified) (4 diffs)
• coeffs/ffields.cc (modified) (3 diffs)
• coeffs/gnumpc.cc (modified) (5 diffs)
• coeffs/gnumpfl.cc (modified) (5 diffs)
• coeffs/longrat.cc (modified) (5 diffs)
• coeffs/modulop.cc (modified) (5 diffs)
• coeffs/mpr_complex.cc (modified) (2 diffs)
• coeffs/numbers.cc (modified) (3 diffs)
• coeffs/rintegers.cc (modified) (6 diffs)
• coeffs/rmodulo2m.cc (modified) (4 diffs)
• coeffs/rmodulon.cc (modified) (4 diffs)
• coeffs/shortfl.cc (modified) (7 diffs)
• misc/auxiliary.h.in (modified) (2 diffs)
• polys/ext_fields/algext.cc (modified) (6 diffs)
• polys/ext_fields/transext.cc (modified) (6 diffs)

libpolys/coeffs/OPAE.cc

@@ -341 +341 @@
     r->cfName = nAEName;
     r->cfInpMult=nAEInpMult; //????
-    r->cfInit_bigint= NULL; // nAEMap0;
     r->cfCoeffWrite=nAECoeffWrite; //????
 

libpolys/coeffs/OPAEQ.cc

@@ -334 +334 @@
     r->cfName = nAEQName;
     r->cfInpMult=nAEQInpMult; //????
-    r->cfInit_bigint= NULL; // nAEQMap0;
     r->cfCoeffWrite=nAEQCoeffWrite; //????
 

libpolys/coeffs/OPAEp.cc

@@ -363 +363 @@
     r->cfName = nAEpName;
     r->cfInpMult=nAEpInpMult; //????
-    r->cfInit_bigint= NULL; // nAEpMap0;
     r->cfCoeffWrite=nAEpCoeffWrite; //????
 

libpolys/coeffs/coeffs.h

@@ -91 +91 @@
 } LongComplexInfo;
 
+
+enum n_coeffRep
+{
+  n_rep_unknown=0,
+  n_rep_int,      /**< (int), see modulop.h */
+  n_rep_gap_rat,  /**< (number), see longrat.h */
+  n_rep_gap_gmp,  /**< (), see rinteger.h, new impl. */
+  n_rep_poly,     /**< (poly), see algext.h */
+  n_rep_rat_fct,  /**< (fraction), see transext.h */
+  n_rep_gmp,      /**< (mpz_ptr), see rmodulon,h */
+  n_rep_float,    /**< (float), see shortfl.h */
+  n_rep_gmp_float,  /**< (gmp_float), see  */
+  n_rep_gmp_complex,/**< (gmp_complex), see gnumpc.h */
+  n_rep_gf        /**< (int), see ffields.h */
+};
+
 struct n_Procs_s
 {
@@ -96 +112 @@
    coeffs next;
    int     ref;
+   n_coeffRep rep;
    n_coeffType type;
    /// how many variables of factory are already used by this coeff
@@ -251 +268 @@
    /// Inplace: a += b
    void    (*cfInpAdd)(number &a, number b, const coeffs r);
-
-   /// maps the bigint i (from dummy == coeffs_BIGINT!!!) into the
-   /// coeffs dst
-   /// TODO: to be exchanged with a map!!!
-   number  (*cfInit_bigint)(number i, const coeffs dummy, const coeffs dst);
 
    /// rational reconstruction: "best" rational a/b with a/b = p mod n
@@ -768 +780 @@
 }
 
-static inline number  n_Init_bigint(number i, const coeffs dummy,
-                const coeffs dst)
-{
-  assume(dummy != NULL && dst != NULL); assume(dst->cfInit_bigint!=NULL);
-  return dst->cfInit_bigint(i, dummy, dst);
-}
-
 static inline number  n_RePart(number i, const coeffs cf)
 {

libpolys/coeffs/ffields.cc

@@ -798 +798 @@
     }
   }
-  if (nCoeff_is_Zp(src,dst->m_nfCharP))
+  if ((src->rep==n_rep_int) && nCoeff_is_Zp(src,dst->m_nfCharP))
   {
     return nfMapP;    /* Z/p -> GF(p,n) */
   }
+  if (src->rep==n_rep_gap_rat) /*Q, Z */
+    return nlModP;
   return NULL;     /* default */
 }
@@ -832 +834 @@
   r->is_field=TRUE;
   r->is_domain=TRUE;
+  r->rep=n_rep_gf;
   //r->cfInitChar=npInitChar;
   r->cfKillChar=nfKillChar;
@@ -860 +863 @@
 
   r->cfWriteLong = nfWriteLong;
-  r->cfInit_bigint = nlModP;
   r->cfRead = nfRead;
   //r->cfNormalize=ndNormalize;

libpolys/coeffs/gnumpc.cc

@@ -475 +475 @@
   n->is_field=TRUE;
   n->is_domain=TRUE;
+  n->rep=n_rep_gmp_complex;
 
   n->cfKillChar = ngcKillChar;
@@ -516 +517 @@
 
   n->cfSetChar=ngcSetChar;
-
-  n->cfInit_bigint=ngcMapQ;
 
 // we need to initialize n->nNULL at least for minpoly printing
@@ -624 +623 @@
 {
   assume( getCoeffType(r) == ID );
-  assume( getCoeffType(aRing) == n_Q );
+  assume( aRing->rep == n_rep_gap_rat);
 
   if ( from != NULL )
@@ -635 +634 @@
 }
 
+number ngcMapZ(number from, const coeffs aRing, const coeffs r)
+{
+  assume( getCoeffType(r) == ID );
+  assume( aRing->rep == n_rep_gap_gmp);
+
+  if ( from != NULL )
+  {
+    if (SR_HDL(from) & SR_INT)
+    {
+      gmp_float f_i= gmp_float(SR_TO_INT(from));
+      gmp_complex *res=new gmp_complex(f_i);
+      return (number)res;
+    }
+    gmp_float f_i=(mpz_ptr)from;
+    gmp_complex *res=new gmp_complex(f_i);
+    return (number)res;
+  }
+  else
+    return NULL;
+}
+
 static number ngcMapLongR(number from, const coeffs aRing, const coeffs r)
 {
@@ -692 +712 @@
   assume( getCoeffType(dst) == ID );
 
-  if (nCoeff_is_Q(src))
+  if (src->rep==n_rep_gap_rat) /* Q, Z*/
   {
     return ngcMapQ;
   }
-  if (nCoeff_is_long_R(src))
+  if (src->rep==n_rep_gap_gmp) /* Z */
+  {
+    return ngcMapZ;
+  }
+  if ((src->rep==n_rep_gmp_float) && nCoeff_is_long_R(src))
   {
     return ngcMapLongR;
   }
-  if (nCoeff_is_long_C(src))
+  if ((src->rep==n_rep_gmp_complex) && nCoeff_is_long_C(src))
   {
     return ngcCopyMap;
   }
-  if (nCoeff_is_R(src))
+  if ((src->rep==n_rep_float) && nCoeff_is_R(src))
   {
     return ngcMapR;
   }
-  if (nCoeff_is_Zp(src))
+  if ((src->rep==n_rep_int) && nCoeff_is_Zp(src))
   {
     return ngcMapP;

libpolys/coeffs/gnumpfl.cc

@@ -413 +413 @@
   n->is_field=TRUE;
   n->is_domain=TRUE;
+  n->rep=n_rep_gmp_float;
 
   n->cfKillChar = ndKillChar; /* dummy */
@@ -443 +444 @@
   n->cfSetMap = ngfSetMap;
   n->cfCoeffWrite = ngfCoeffWrite;
-  n->cfInit_bigint = ngfMapQ;
 #ifdef LDEBUG
   n->cfDBTest  = ndDBTest; // not yet implemented: ngfDBTest
@@ -474 +474 @@
 {
   assume( getCoeffType(dst) == ID );
-  assume( getCoeffType(src) == n_Q );
+  assume( src->rep == n_rep_gap_rat );
   
   gmp_float *res=new gmp_float(numberFieldToFloat(from,QTOF,dst));
   return (number)res;
 }
+number ngfMapZ(number from, const coeffs aRing, const coeffs r)
+{
+  assume( getCoeffType(r) == ID );
+  assume( aRing->rep == n_rep_gap_gmp);
+
+  if ( from != NULL )
+  {
+    if (SR_HDL(from) & SR_INT)
+    {
+      gmp_float f_i= gmp_float(SR_TO_INT(from));
+      gmp_float *res=new gmp_float(f_i);
+      return (number)res;
+    }
+    gmp_float f_i=(mpz_ptr)from;
+    gmp_float *res=new gmp_float(f_i);
+    return (number)res;
+  }
+  else
+    return NULL;
+}
+
 
 static number ngfMapR(number from, const coeffs src, const coeffs dst)
@@ -510 +531 @@
   assume( getCoeffType(dst) == ID );
   
-  if (nCoeff_is_Q(src))
+  if (src->rep==n_rep_gap_rat) /*Q, Z*/
   {
     return ngfMapQ;
   }
-  if (nCoeff_is_long_R(src))
+  if (src->rep==n_rep_gap_gmp) /*Q, Z*/
+  {
+    return ngfMapZ;
+  }
+  if ((src->rep==n_rep_gmp_float) && nCoeff_is_long_R(src))
   {
     return ndCopyMap; //ngfCopyMap;
   }
-  if (nCoeff_is_R(src))
+  if ((src->rep==n_rep_float) && nCoeff_is_R(src))
   {
     return ngfMapR;
   }
-  if (nCoeff_is_long_C(src))
+  if ((src->rep==n_rep_gmp_complex) && nCoeff_is_long_C(src))
   {
     return ngfMapC;
   }
-  if (nCoeff_is_Zp(src))
+  if ((src->rep==n_rep_int) && nCoeff_is_Zp(src))
   {
     return ngfMapP;
@@ -532 +557 @@
   return NULL;
 }
-
 
 void    ngfCoeffWrite  (const coeffs r, BOOLEAN /*details*/)

libpolys/coeffs/longrat.cc

@@ -144 +144 @@
   z=nlShort3(z);
   return z;
+}
+
+number nlMapZ(number from, const coeffs src, const coeffs dst)
+{
+  if (SR_HDL(from) & SR_INT)
+  {
+    return from;
+  }
+  return nlMapGMP(from,src,dst);
 }
 
@@ -1288 +1297 @@
 }
 
-// Map q \in QQ \to Zp
-// src = Q, dst = Zp (or an extension of Zp?)
+// Map q \in QQ or ZZ \to Zp or an extension of it
+// src = Q or Z, dst = Zp (or an extension of Zp)
 number nlModP(number q, const coeffs Q, const coeffs Zp)
 {
@@ -2168 +2177 @@
 nMapFunc nlSetMap(const coeffs src, const coeffs dst)
 {
-  if (getCoeffType(src)==n_Q /*nCoeff_is_Q(src) or coeffs_BIGINT*/)
+  if (src->rep==n_rep_gap_rat)  /*Q, coeffs_BIGINT */
   {
     return ndCopyMap;
   }
-  if (nCoeff_is_Zp(src))
+  if ((src->rep==n_rep_int) && nCoeff_is_Zp(src))
   {
     return nlMapP;
   }
-  if (nCoeff_is_R(src))
+  if ((src->rep==n_rep_float) && nCoeff_is_R(src))
   {
     return nlMapR;
   }
-  if (nCoeff_is_long_R(src))
+  if ((src->rep==n_rep_gmp_float) && nCoeff_is_long_R(src))
   {
     return nlMapLongR; /* long R -> Q */
   }
 #ifdef HAVE_RINGS
-  if (nCoeff_is_Ring_Z(src) || nCoeff_is_Ring_PtoM(src) || nCoeff_is_Ring_ModN(src))
+  if (src->rep==n_rep_gmp) // nCoeff_is_Ring_Z(src) || nCoeff_is_Ring_PtoM(src) || nCoeff_is_Ring_ModN(src))
   {
     return nlMapGMP;
   }
-  if (nCoeff_is_Ring_2toM(src))
+  if (src->rep==n_rep_gap_gmp)
+  {
+    return nlMapZ;
+  }
+  if ((src->rep==n_rep_int) && nCoeff_is_Ring_2toM(src))
   {
     return nlMapMachineInt;
@@ -3020 +3033 @@
 {
   r->is_domain=TRUE;
+  r->rep=n_rep_gap_rat;
 
   //const int ch = (int)(long)(p);
@@ -3083 +3097 @@
   r->cfInpMult=nlInpMult;
   r->cfInpAdd=nlInpAdd;
-  r->cfInit_bigint=nlCopyMap;
   r->cfCoeffWrite=nlCoeffWrite;
 

libpolys/coeffs/modulop.cc

@@ -457 +457 @@
   r->is_field=TRUE;
   r->is_domain=TRUE;
+  r->rep=n_rep_int;
 
   r->ch = c;
@@ -503 +504 @@
   //r->cfName = ndName;
   r->cfInpMult=ndInpMult;
-  r->cfInit_bigint= nlModP; // npMap0;
 #ifdef NV_OPS
   if (c>NV_MAX_PRIME)
@@ -690 +690 @@
 }
 
+number npMapZ(number from, const coeffs src, const coeffs dst)
+{
+  if (SR_HDL(from) & SR_INT)
+  {
+    long f_i=SR_TO_INT(from);
+    return npInit(f_i,dst);
+  }
+  return npMapGMP(from,src,dst);
+}
+
 /*2
 * convert from an machine long
@@ -710 +720 @@
 {
 #ifdef HAVE_RINGS
-  if (nCoeff_is_Ring_2toM(src))
+  if ((src->rep==n_rep_int) && nCoeff_is_Ring_2toM(src))
   {
     return npMapMachineInt;
   }
-  if (nCoeff_is_Ring_Z(src) || nCoeff_is_Ring_PtoM(src) || nCoeff_is_Ring_ModN(src))
+  if (src->rep==n_rep_gmp) //nCoeff_is_Ring_Z(src) || nCoeff_is_Ring_PtoM(src) || nCoeff_is_Ring_ModN(src))
   {
     return npMapGMP;
   }
-#endif
-  if (nCoeff_is_Q(src))
+  if (src->rep==n_rep_gap_gmp) //nCoeff_is_Ring_Z(src)
+  {
+    return npMapZ;
+  }
+#endif
+  if (src->rep==n_rep_gap_rat)  /* Q, Z */
   {
     return nlModP; // npMap0;
   }
-  if ( nCoeff_is_Zp(src) )
+  if ((src->rep==n_rep_int) &&  nCoeff_is_Zp(src) )
   {
     if (n_GetChar(src) == n_GetChar(dst))
@@ -734 +748 @@
     }
   }
-  if (nCoeff_is_long_R(src))
+  if ((src->rep==n_rep_gmp_float) && nCoeff_is_long_R(src))
   {
     return npMapLongR;

libpolys/coeffs/mpr_complex.cc

@@ -444 +444 @@
       if (SR_HDL(num) & SR_INT)
       {
-        int nn = SR_TO_INT(num);
-        if((long)nn == SR_TO_INT(num))
-            r = SR_TO_INT(num);
-        else
-            r = gmp_float(SR_TO_INT(num));
+        r = gmp_float(SR_TO_INT(num));
       }
       else
@@ -458 +454 @@
         if (SR_HDL(num) & SR_INT)
         {
-          int nn = SR_TO_INT(num);
-          if((long)nn == SR_TO_INT(num))
-            r = SR_TO_INT(num);
-          else
-            r = gmp_float(SR_TO_INT(num));
+          r = gmp_float(SR_TO_INT(num));
         }
         else

libpolys/coeffs/numbers.cc

@@ -79 +79 @@
 number ndFarey(number,number,const coeffs r)
 {
-  Werror("farey not implemented for (c=%d)",getCoeffType(r));
+  Werror("farey not implemented for %s (c=%d)",r->cfCoeffString(r),getCoeffType(r));
   return NULL;
 }
 number ndChineseRemainder(number *,number *,int,BOOLEAN,const coeffs r)
 {
-  Werror("ChineseRemainder not implemented for (c=%d)",getCoeffType(r));
+  Werror("ChineseRemainder not implemented for %s (c=%d)",r->cfCoeffString(r),getCoeffType(r));
   return n_Init(0,r); 
 }
@@ -243 +243 @@
 {
   Werror("no conversion from factory");
-  return NULL;
-}
-
-number  ndInit_bigint(number, const coeffs, const coeffs)
-{
-  Werror("no conversion from bigint to this field");
   return NULL;
 }
@@ -338 +332 @@
     n->cfGcd  = ndGcd;
     n->cfLcm  = ndGcd; /* tricky, isn't it ?*/
-    n->cfInit_bigint = ndInit_bigint;
     n->cfInitMPZ = ndInitMPZ;
     n->cfMPZ = ndMPZ;

libpolys/coeffs/rintegers.cc

@@ -3 +3 @@
 ****************************************/
 /*
-* ABSTRACT: numbers modulo n
+* ABSTRACT: numbers (integers)
 */
 
@@ -29 +29 @@
 omBin gmp_nrz_bin = omGetSpecBin(sizeof(mpz_t));
 
+#if SI_INTEGER_VARIANT == 2
 /*
  * Multiply two numbers
@@ -214 +215 @@
   mpz_init(r);
   mpz_tdiv_qr(erg, r, (int_number) a, (int_number) b);
-  if (!nrzIsZero((number) r, R))
-  {
-    WerrorS("Division by non divisible element.");
-    WerrorS("Result is without remainder.");
-  }
+  //if (!nrzIsZero((number) r, R))
+  //{
+  //  WerrorS("Division by non divisible element.");
+  //  WerrorS("Result is without remainder.");
+  //}
   mpz_clear(r);
   omFreeBin(r, gmp_nrz_bin);
@@ -408 +409 @@
   r->is_field=FALSE;
   r->is_domain=TRUE;
+  r->rep=n_rep_gmp;
 
   r->nCoeffIsEqual = ndCoeffIsEqual;
@@ -427 +429 @@
   r->cfExtGcd = nrzExtGcd; // only for ring stuff
   r->cfDivBy = nrzDivBy; // only for ring stuff
-  r->cfInit_bigint = nrzMapQ;
   //#endif
   r->cfInpNeg   = nrzNeg;
@@ -460 +461 @@
 }
 
-#endif
+#elif SI_INTEGER_VARIANT == 3
+
+//make sure that a small number is an immediate integer
+//bascially coped from longrat.cc nlShort3
+//TODO: is there any point in checking 0 first???
+//TODO: it is not clear that this works in 32/64 bit everywhere.
+//      too many hacks.
+#ifdef LDEBUG
+#define nrzTest(A) nrzDBTest(A,__FILE__,__LINE__,NULL)
+BOOLEAN nrzDBTest (number x, const char *f, const int l, const coeffs);
+#else
+#define nrzTest(A)
+#endif
+
+#define CF_DEBUG 0
+static inline number nrz_short(number x)
+{
+#if CF_DEBUG
+  StringAppendS("short(");
+  nrzWrite(x, NULL);
+#endif
+  if (mpz_cmp_ui((int_number) x,(long)0)==0)
+  {
+    mpz_clear((int_number)x);
+    omFreeBin(x, gmp_nrz_bin);
+#if CF_DEBUG
+    StringAppendS(")=0");
+#endif
+    return INT_TO_SR(0);
+  }
+  if (mpz_size1((int_number)x)<=MP_SMALL)
+  {
+    int ui=mpz_get_si((int_number)x);
+    if ((((ui<<3)>>3)==ui)
+    && (mpz_cmp_si((int_number)x,(long)ui)==0))
+    {
+      mpz_clear((int_number)x);
+      omFreeBin(x, gmp_nrz_bin);
+#if CF_DEBUG
+    StringAppendS(")=imm");
+#endif
+      return INT_TO_SR(ui);
+    }
+  }
+#if CF_DEBUG
+  StringAppendS(")");
+#endif
+  return x;
+}
+
+
+
+
+/*
+ * Multiply two numbers
+ * check for 0, 1, -1 maybe
+ */
+#if CF_DEBUG
+number _nrzMult(number, number, const coeffs);
+number nrzMult(number a, number b, const coeffs R)
+{
+  StringSetS("Mult: ");
+  nrzWrite(a, R);
+  StringAppendS(" by ");
+  nrzWrite(b, R);
+  number c = _nrzMult(a, b, R);
+  StringAppendS(" is ");
+  nrzWrite(c, R);
+  char * s = StringEndS();
+  Print("%s\n", s);
+  omFree(s);
+  return c;
+}
+number _nrzMult (number a, number b, const coeffs R)
+#else
+number nrzMult (number a, number b, const coeffs R)
+#endif
+{
+  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b)) {
+  //from longrat.cc
+    if (SR_TO_INT(a)==0)
+      return a;
+    if (SR_TO_INT(b)==0)
+      return b;
+    long r=(long)((unsigned long)(SR_HDL(a)-1L))*((unsigned long)(SR_HDL(b)>>1));
+    if ((r/(SR_HDL(b)>>1))==(SR_HDL(a)-1L))
+    {
+      number u=((number) ((r>>1)+SR_INT));
+    //  if (((((long)SR_HDL(u))<<1)>>1)==SR_HDL(u)) return (u);
+      return nrzInit(SR_HDL(u)>>2, R);
+    }
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(erg);
+    mpz_set_si(erg, SR_TO_INT(a));
+    mpz_mul_si(erg, erg, SR_TO_INT(b));
+    nrzTest((number)erg);
+    return (number) erg;
+  }
+  else if (n_Z_IS_SMALL(a))
+  {
+    if (SR_TO_INT(a)==0)
+      return a;
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init_set(erg, (int_number) b);
+    mpz_mul_si(erg, erg, SR_TO_INT(a));
+    nrzTest((number)erg);
+    return (number) erg;
+  }
+  else if (n_Z_IS_SMALL(b))
+  {
+    if (SR_TO_INT(b)==0)
+      return b;
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init_set(erg, (int_number) a);
+    mpz_mul_si(erg, erg, SR_TO_INT(b));
+    nrzTest((number)erg);
+    return (number) erg;
+  }
+  else
+  {
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(erg);
+    mpz_mul(erg, (int_number) a, (int_number) b);
+    nrzTest((number)erg);
+    return (number) erg;
+  }
+}
+
+
+static int int_gcd(int a, int b)
+{
+  int r;
+  a = ABS(a);
+  b = ABS(b);
+  if (!a) return b;
+  if (!b) return a;
+  do
+  {
+    r = a % b;
+    a = b;
+    b = r;
+  } while (b);
+  return ABS(a); // % in c doeas not imply a signn
+                 // it would be unlikely to see a negative here
+                 // but who knows
+}
+
+/*
+ * Give the smallest non unit k, such that a * x = k = b * y has a solution
+ */
+number nrzLcm (number a, number b, const coeffs R)
+{
+  PrintS("nrzLcm\n");
+  int_number erg;
+  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
+  {
+    int g = int_gcd(SR_TO_INT(a), SR_TO_INT(b));
+    return nrzMult(a, INT_TO_SR(SR_TO_INT(b)/g), R);
+  }
+  else if (n_Z_IS_SMALL(a))
+  {
+    erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init_set(erg, (int_number) b);
+    unsigned long g = mpz_gcd_ui(NULL, erg, (unsigned long) ABS(SR_TO_INT(a)));
+    mpz_mul_si(erg, erg, SR_TO_INT(a)/g);
+  }
+  else if (n_Z_IS_SMALL(b))
+  {
+    erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init_set(erg, (int_number) a);
+    unsigned long g = mpz_gcd_ui(NULL, erg, (unsigned long) ABS(SR_TO_INT(b)));
+    mpz_mul_si(erg, erg, SR_TO_INT(b)/g);
+  }
+  else
+  {
+    erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(erg);
+    mpz_lcm(erg, (int_number) a, (int_number) b);
+  }
+  return (number) erg;
+}
+
+/*
+ * Give the largest non unit k, such that a = x * k, b = y * k has
+ * a solution.
+ */
+number nrzGcd (number a,number b,const coeffs R)
+{
+  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
+  {
+    int g = int_gcd(SR_TO_INT(a), SR_TO_INT(b));
+    return INT_TO_SR(g);
+  }
+  else if (n_Z_IS_SMALL(a))
+  {
+    if (a==INT_TO_SR(0))
+      return nrzCopy(b, R);
+    unsigned long g = mpz_gcd_ui(NULL, (int_number)b, (unsigned long) ABS(SR_TO_INT(a)));
+    return INT_TO_SR( g);
+  }
+  else if (n_Z_IS_SMALL(b))
+  {
+    if (b==INT_TO_SR(0))
+      return nrzCopy(a, R);
+    unsigned long g = mpz_gcd_ui(NULL, (int_number)a, (unsigned long) ABS(SR_TO_INT(b)));
+    return INT_TO_SR(g);
+  }
+  else
+  {
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(erg);
+    mpz_gcd(erg, (int_number) a, (int_number) b);
+    return (number) erg;
+  }
+}
+
+/*
+ * Give the largest non unit k, such that a = x * k, b = y * k has
+ * a solution and r, s, s.t. k = s*a + t*b
+ */
+static int int_extgcd(int a, int b, int * u, int* x, int * v, int* y)
+{
+  int q, r;
+  if (!a)
+  {
+    *u = 0;
+    *v = 1;
+    *x = -1;
+    *y = 0;
+    return b;
+  }
+  if (!b)
+  {
+    *u = 1;
+    *v = 0;
+    *x = 0;
+    *y = 1;
+    return a;
+  }
+  *u=1;
+  *v=0;
+  *x=0;
+  *y=1;
+  do
+  {
+    q = a/b;
+    r = a%b;
+    assume (q*b+r == a);
+    a = b;
+    b = r;
+
+    r = -(*v)*q+(*u);
+    (*u) =(*v);
+    (*v) = r;
+
+    r = -(*y)*q+(*x);
+    (*x) = (*y);
+    (*y) = r;
+  } while (b);
+
+  return a;
+}
+
+number  nrzExtGcd (number a, number b, number *s, number *t, const coeffs)
+{
+  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
+  {
+    int u, v, x, y;
+    int g = int_extgcd(SR_TO_INT(a), SR_TO_INT(b), &u, &v, &x, &y);
+    *s = INT_TO_SR(u);
+    *t = INT_TO_SR(v);
+    return INT_TO_SR(g);
+  }
+  else
+  {
+    mpz_t aa, bb;
+    if (n_Z_IS_SMALL(a))
+    {
+      mpz_init_set_si(aa, SR_TO_INT(a));
+    }
+    else
+    {
+      mpz_init_set(aa, (int_number) a);
+    }
+    if (n_Z_IS_SMALL(b))
+    {
+      mpz_init_set_si(bb, SR_TO_INT(b));
+    }
+    else
+    {
+      mpz_init_set(bb, (int_number) b);
+    }
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    int_number bs = (int_number) omAllocBin(gmp_nrz_bin);
+    int_number bt = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(erg);
+    mpz_init(bs);
+    mpz_init(bt);
+    mpz_gcdext(erg, bs, bt, aa, bb);
+    *s = nrz_short((number) bs);
+    *t = nrz_short((number) bt);
+    mpz_clear(aa);
+    mpz_clear(bb);
+    return nrz_short((number) erg);
+  }
+}
+#if CF_DEBUG
+number _nrzXExtGcd(number, number, number *, number *, number *, number *, const coeffs);
+number nrzXExtGcd(number a, number b, number *x, number * y, number * u, number * v, const coeffs R)
+{
+  char * s;
+  StringSetS("XExtGcd: ");
+  nrzWrite(a, R);
+  StringAppendS(" by ");
+  nrzWrite(b, R);
+  number c = _nrzXExtGcd(a, b, x, y, u, v, R);
+  StringAppendS(" is ");
+  nrzWrite(c, R);
+  StringAppendS("[[");
+  nrzWrite(*x, R);
+  StringAppendS(", ");
+  nrzWrite(*y, R);
+  StringAppendS("], ");
+  nrzWrite(*u, R);
+  StringAppendS(", ");
+  nrzWrite(*v, R);
+  s=StringEndS();
+  Print("%s]]\n", s);
+  omFree(s);
+  return c;
+}
+number  _nrzXExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs )
+#else
+number  nrzXExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs )
+#endif
+{
+  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
+  {
+    int uu, vv, x, y;
+    int g = int_extgcd(SR_TO_INT(a), SR_TO_INT(b), &uu, &vv, &x, &y);
+    *s = INT_TO_SR(uu);
+    *t = INT_TO_SR(vv);
+    *u = INT_TO_SR(x);
+    *v = INT_TO_SR(y);
+    return INT_TO_SR(g);
+  }
+  else
+  {
+    mpz_t aa, bb;
+    if (n_Z_IS_SMALL(a))
+    {
+      mpz_init_set_si(aa, SR_TO_INT(a));
+    }
+    else
+    {
+      mpz_init_set(aa, (int_number) a);
+    }
+    if (n_Z_IS_SMALL(b))
+    {
+      mpz_init_set_si(bb, SR_TO_INT(b));
+    }
+    else
+    {
+      mpz_init_set(bb, (int_number) b);
+    }
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    int_number bs = (int_number) omAllocBin(gmp_nrz_bin);
+    int_number bt = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(erg);
+    mpz_init(bs);
+    mpz_init(bt);
+
+    mpz_gcdext(erg, bs, bt, aa, bb);
+
+    int_number bu = (int_number) omAllocBin(gmp_nrz_bin);
+    int_number bv = (int_number) omAllocBin(gmp_nrz_bin);
+
+    mpz_init_set(bu, (int_number) bb);
+    mpz_init_set(bv, (int_number) aa);
+
+    mpz_clear(aa);
+    mpz_clear(bb);
+    assume(mpz_cmp_si(erg, 0));
+
+    mpz_div(bu, bu, erg);
+    mpz_div(bv, bv, erg);
+
+    mpz_mul_si(bu, bu, -1);
+    *u = nrz_short((number) bu);
+    *v = nrz_short((number) bv);
+
+    *s = nrz_short((number) bs);
+    *t = nrz_short((number) bt);
+    return nrz_short((number) erg);
+  }
+}
+#if CF_DEBUG
+number _nrzQuotRem(number, number, number *, const coeffs);
+number nrzQuotRem(number a, number b, number * r, const coeffs R)
+{
+  StringSetS("QuotRem: ");
+  nrzWrite(a, R);
+  StringAppendS(" by ");
+  nrzWrite(b, R);
+  number c = _nrzQuotRem(a, b, r, R);
+  StringAppendS(" is ");
+  nrzWrite(c, R);
+  if (r) {
+    StringAppendS("+R(");
+    nrzWrite(*r, R);
+    StringAppendS(")");
+  }
+  char * s = StringEndS();
+  Print("%s\n", s);
+  omFree(s);
+  return c;
+}
+number _nrzQuotRem (number a, number b, number * r, const coeffs )
+#else
+number nrzQuotRem (number a, number b, number * r, const coeffs )
+#endif
+{
+  assume(SR_TO_INT(b));
+  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
+  {
+    if (r)
+      *r = INT_TO_SR(SR_TO_INT(a) % SR_TO_INT(b));
+    return INT_TO_SR(SR_TO_INT(a)/SR_TO_INT(b));
+  }
+  else if (n_Z_IS_SMALL(a))
+  {
+    //a is small, b is not, so q=0, r=a
+    if (r)
+      *r = a;
+    return INT_TO_SR(0);
+  }
+  else if (n_Z_IS_SMALL(b))
+  {
+    unsigned long rr;
+    int_number qq = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(qq);
+    mpz_t rrr;
+    mpz_init(rrr);
+    rr = mpz_divmod_ui(qq, rrr, (int_number) a, (unsigned long)ABS(SR_TO_INT(b)));
+    mpz_clear(rrr);
+
+    if (r)
+      *r = INT_TO_SR(rr);
+    if (SR_TO_INT(b)<0)
+    {
+      mpz_mul_si(qq, qq, -1);
+    }
+    return nrz_short((number)qq);
+  }
+  int_number qq = (int_number) omAllocBin(gmp_nrz_bin),
+             rr = (int_number) omAllocBin(gmp_nrz_bin);
+  mpz_init(qq);
+  mpz_init(rr);
+  mpz_divmod(qq, rr, (int_number)a, (int_number)b);
+  if (r)
+    *r = (number) rr;
+  else
+  {
+    mpz_clear(rr);
+  }
+  nrzTest((number)qq);
+  return (number) qq;
+}
+
+
+void nrzPower (number a, int i, number * result, const coeffs)
+{
+  int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+  mpz_init(erg);
+  mpz_t aa;
+  if (n_Z_IS_SMALL(a))
+    mpz_init_set_si(aa, SR_TO_INT(a));
+  else
+    mpz_init_set(aa, (int_number) a);
+  mpz_pow_ui(erg, aa, i);
+  *result = nrz_short((number) erg);
+}
+
+/*
+ * create a number from int
+ * TODO: do not create an mpz if not necessary
+ */
+number nrzInit (long i, const coeffs)
+{
+  int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+  mpz_init_set_si(erg, i);
+  return nrz_short((number) erg);
+}
+
+void nrzDelete(number *a, const coeffs)
+{
+  if (*a == NULL) return;
+  if (n_Z_IS_SMALL(*a)==0)
+  {
+    mpz_clear((int_number) *a);
+    omFreeBin((ADDRESS) *a, gmp_nrz_bin);
+  }
+  *a = NULL;
+}
+
+number nrzCopy(number a, const coeffs)
+{
+  if (n_Z_IS_SMALL(a)) return a;
+  int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+  mpz_init_set(erg, (int_number) a);
+  return (number) erg;
+}
+
+int nrzSize(number a, const coeffs)
+{
+  if (a == NULL) return 0;
+  if (n_Z_IS_SMALL(a)) return 1;
+  return mpz_size1((int_number)a)+1;
+}
+
+/*
+ * convert a number to int
+ */
+int nrzInt(number &n, const coeffs)
+{
+  if (n_Z_IS_SMALL(n)) return SR_TO_INT(n);
+  return (int) mpz_get_si( (int_number)n);
+}
+#if CF_DEBUG
+number _nrzAdd(number, number, const coeffs);
+number nrzAdd(number a, number b, const coeffs R)
+{
+  StringSetS("Add: ");
+  nrzWrite(a, R);
+  StringAppendS(" to ");
+  nrzWrite(b, R);
+  number c = _nrzAdd(a, b, R);
+  StringAppendS(" is ");
+  nrzWrite(c, R);
+  char * s = StringEndS();
+  Print("%s\n", s);
+  omFree(s);
+  return c;
+}
+number _nrzAdd (number a, number b, const coeffs R)
+#else
+number nrzAdd (number a, number b, const coeffs R)
+#endif
+{
+  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
+  {
+    int c = SR_TO_INT(a) + SR_TO_INT(b);
+    if (INT_IS_SMALL(c))
+      return INT_TO_SR(c);
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init_set_si(erg, c);
+
+    nrzTest((number)erg);
+    return (number) erg;
+  }
+  else if (n_Z_IS_SMALL(a))
+  {
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(erg);
+    if (SR_TO_INT(a)>0)
+      mpz_add_ui(erg, (int_number) b, (unsigned long)SR_TO_INT(a));
+    else
+      mpz_sub_ui(erg, (int_number) b, (unsigned long)-(SR_TO_INT(a)));
+    return nrz_short((number) erg);
+  }
+  else if (n_Z_IS_SMALL(b))
+  {
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(erg);
+    if (SR_TO_INT(b)>0)
+      mpz_add_ui(erg, (int_number) a, (unsigned long)SR_TO_INT(b));
+    else
+      mpz_sub_ui(erg, (int_number) a, (unsigned long)-(SR_TO_INT(b)));
+    return nrz_short((number) erg);
+  }
+  else
+  {
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(erg);
+    mpz_add(erg, (int_number) a, (int_number) b);
+    return nrz_short((number) erg);
+  }
+}
+
+number nrzSub (number a, number b, const coeffs)
+{
+  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
+  {
+    int c = SR_TO_INT(a) - SR_TO_INT(b);
+    if (INT_IS_SMALL(c))
+      return INT_TO_SR(c);
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init_set_si(erg, c);
+    nrzTest((number)erg);
+    return (number) erg;
+  }
+  else if (n_Z_IS_SMALL(a))
+  {
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(erg);
+
+    if (SR_TO_INT(a)>0)
+      mpz_ui_sub(erg, (unsigned long)SR_TO_INT(a), (int_number) b);
+    else
+    {
+      mpz_add_ui(erg, (int_number) b, (unsigned long)-SR_TO_INT(a));
+      mpz_neg(erg, erg);
+    }
+    return nrz_short((number) erg);
+  }
+  else if (n_Z_IS_SMALL(b))
+  {
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(erg);
+    if (INT_TO_SR(b)>0)
+      mpz_sub_ui(erg, (int_number) a, (unsigned long)SR_TO_INT(b));
+    else
+      mpz_add_ui(erg, (int_number) a, (unsigned long)-SR_TO_INT(b));
+    return nrz_short((number) erg);
+  }
+  else
+  {
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_init(erg);
+    mpz_sub(erg, (int_number) a, (int_number) b);
+    return nrz_short((number) erg);
+  }
+}
+
+number  nrzGetUnit (number n, const coeffs r)
+{
+  //if (n_Z_IS_SMALL(n))
+  //{
+  //  if (SR_TO_INT(n)<0)
+  //    return INT_TO_SR(-1);
+  //  else
+  //    return INT_TO_SR(1);
+  //}
+  if (nrzGreaterZero(n, r))
+    return INT_TO_SR(1);
+  else
+    return INT_TO_SR(-1);
+}
+
+number nrzAnn(number n, const coeffs)
+{
+  if (SR_TO_INT(n))  // in Z: the annihilator of !=0 is 0
+    return INT_TO_SR(0);
+  else
+    return INT_TO_SR(1);
+}
+
+BOOLEAN nrzIsUnit (number a, const coeffs)
+{
+  return ABS(SR_TO_INT(a))==1;
+}
+
+BOOLEAN nrzIsZero (number  a, const coeffs)
+{
+  return a==INT_TO_SR(0);
+}
+
+BOOLEAN nrzIsOne (number a, const coeffs)
+{
+  return a==INT_TO_SR(1);
+}
+
+BOOLEAN nrzIsMOne (number a, const coeffs)
+{
+  return a==INT_TO_SR(-1);
+}
+
+BOOLEAN nrzEqual (number a,number b, const coeffs)
+{
+  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
+    return a==b;
+  else if (n_Z_IS_SMALL(a) || n_Z_IS_SMALL(b))
+    return FALSE;
+  else
+    return 0 == mpz_cmp((int_number) a, (int_number) b);
+}
+
+BOOLEAN nrzGreater (number a,number b, const coeffs)
+{
+  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
+    return ((long)a)>((long)b);
+  else if (n_Z_IS_SMALL(a))
+    return 0 > mpz_cmp_si((int_number)b,SR_TO_INT(a));
+  else if (n_Z_IS_SMALL(b))
+    return 0 < mpz_cmp_si((int_number)a,SR_TO_INT(b));
+  return 0 < mpz_cmp((int_number) a, (int_number) b);
+}
+
+BOOLEAN nrzGreaterZero (number k, const coeffs C)
+{
+  return nrzGreater(k, INT_TO_SR(0), C);
+}
+
+int nrzDivComp(number a, number b, const coeffs r)
+{
+  if (nrzDivBy(a, b, r))
+  {
+    if (nrzDivBy(b, a, r)) return 2;
+    return -1;
+  }
+  if (nrzDivBy(b, a, r)) return 1;
+  return 0;
+}
+
+BOOLEAN nrzDivBy (number a,number b, const coeffs)
+{
+  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
+  {
+    return SR_TO_INT(a) %SR_TO_INT(b) ==0;
+  }
+  else if (n_Z_IS_SMALL(a))
+  {
+    return a==INT_TO_SR(0);
+  }
+  else if (n_Z_IS_SMALL(b))
+  {
+    return mpz_divisible_ui_p((int_number)a, (unsigned long)ABS(SR_TO_INT(b))) != 0;
+  }
+  else
+    return mpz_divisible_p((int_number) a, (int_number) b) != 0;
+}
+
+number nrzDiv (number a,number b, const coeffs R)
+{
+  assume(SR_TO_INT(b));
+  if (n_Z_IS_SMALL(a) && n_Z_IS_SMALL(b))
+  {
+    //if (SR_TO_INT(a) % SR_TO_INT(b))
+    //{
+    //  WerrorS("1:Division by non divisible element.");
+    //  WerrorS("Result is without remainder.");
+    //}
+    return INT_TO_SR(SR_TO_INT(a)/SR_TO_INT(b));
+  }
+  else if (n_Z_IS_SMALL(a))
+  {
+    //if (SR_TO_INT(a))
+    //{
+    //  WerrorS("2:Division by non divisible element.");
+    //  WerrorS("Result is without remainder.");
+    //}
+    return INT_TO_SR(0);
+  }
+  else if (n_Z_IS_SMALL(b))
+  {
+    int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+    mpz_t r;
+    mpz_init(r);
+    mpz_init(erg);
+    if (mpz_divmod_ui(erg, r, (int_number) a, (unsigned long)ABS(SR_TO_INT(b)))) {
+    //  WerrorS("3:Division by non divisible element.");
+    //  WerrorS("Result is without remainder.");
+    }
+    mpz_clear(r);
+    if (SR_TO_INT(b)<0)
+      mpz_neg(erg, erg);
+    return nrz_short((number) erg);
+  }
+  int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+  mpz_init(erg);
+  mpz_t r;
+  mpz_init(r);
+  mpz_tdiv_qr(erg, r, (int_number) a, (int_number) b);
+#if CF_DEBUG
+  StringSetS("division of");
+  nrzWrite(a, R);
+  StringAppendS(" by ");
+  nrzWrite(b, R);
+  StringAppendS(" is ");
+  number du;
+  nrzWrite(du = (number)erg, R);
+  StringAppendS(" rest ");
+  nrzWrite(du = (number)r, R);
+  char * s = StringEndS();
+  Print("%s\n", s);
+  omFree(s);
+#endif
+
+  if (mpz_cmp_si(r, 0)!=0)
+  {
+    //WerrorS("4:Division by non divisible element.");
+    //WerrorS("Result is without remainder.");
+  }
+  mpz_clear(r);
+  return nrz_short((number) erg);
+}
+
+number nrzExactDiv (number a,number b, const coeffs)
+{
+  assume(SR_TO_INT(b));
+  mpz_t aa, bb;
+  if (n_Z_IS_SMALL(a))
+    mpz_init_set_si(aa, SR_TO_INT(a));
+  else
+    mpz_init_set(aa, (int_number) a);
+  if (n_Z_IS_SMALL(b))
+    mpz_init_set_si(bb, SR_TO_INT(b));
+  else
+    mpz_init_set(bb, (int_number) b);
+  int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+  mpz_init(erg);
+  mpz_tdiv_q(erg, (int_number) aa, (int_number) bb);
+  mpz_clear(aa);
+  mpz_clear(bb);
+  nrzTest((number)erg);
+  return (number) erg;
+}
+
+number nrzIntMod (number a,number b, const coeffs)
+{
+  mpz_t aa, bb;
+  assume(SR_TO_INT(b));
+  if (n_Z_IS_SMALL(a))
+    mpz_init_set_si(aa, SR_TO_INT(a));
+  else
+    mpz_init_set(aa, (int_number) a);
+  if (n_Z_IS_SMALL(b))
+    mpz_init_set_si(bb, SR_TO_INT(b));
+  else
+    mpz_init_set(bb, (int_number) b);
+
+  mpz_t erg;
+  mpz_init(erg);
+  int_number r = (int_number) omAllocBin(gmp_nrz_bin);
+  mpz_init(r);
+  mpz_tdiv_qr(erg, r, (int_number) aa, (int_number) bb);
+  mpz_clear(erg);
+  mpz_clear(aa);
+  mpz_clear(bb);
+  
+  return nrz_short((number) r);
+}
+
+number  nrzInvers (number c, const coeffs r)
+{
+  if (!nrzIsUnit((number) c, r))
+  {
+    WerrorS("Non invertible element.");
+    return (number)0; //TODO
+  }
+  return c; // has to be 1 or -1....
+}
+
+number nrzNeg (number c, const coeffs)
+{
+// nNeg inplace !!!
+  if (n_Z_IS_SMALL(c))
+    return INT_TO_SR(-SR_TO_INT(c));
+  mpz_mul_si((int_number) c, (int_number) c, -1);
+  return c;
+}
+
+static number nrzFarey(number r, number N, const coeffs R)
+{
+  number a0 = nrzCopy(N, R);
+  number b0 = nrzInit(0, R);
+  number a1 = nrzCopy(r, R);
+  number b1 = nrzInit(1, R);
+  number two = nrzInit(2, R);
+#if 0
+  Print("Farey start with ");
+  n_Print(r, R);
+  Print(" mod ");
+  n_Print(N, R);
+  Print("\n");
+#endif
+  while (1)
+  {
+    number as = nrzMult(a1, a1, R);
+    n_InpMult(as, two, R);
+    if (nrzGreater(N, as, R))
+    {
+      nrzDelete(&as, R);
+      break;
+    }
+    nrzDelete(&as, R);
+    number q = nrzDiv(a0, a1, R);
+    number t = nrzMult(a1, q, R),
+           s = nrzSub(a0, t, R);
+    nrzDelete(&a0, R);
+    a0 = a1;
+    a1 = s;
+    nrzDelete(&t, R);
+
+    t = nrzMult(b1, q, R);
+    s = nrzSub(b0, t, R);
+    nrzDelete(&b0, R);
+    b0 = b1;
+    b1 = s;
+    nrzDelete(&t, R);
+    nrzDelete(&q, R);
+  }
+  number as = nrzMult(b1, b1, R);
+  n_InpMult(as, two, R);
+  nrzDelete(&two, R);
+  if (nrzGreater(as, N, R))
+  {
+    nrzDelete(&a0, R);
+    nrzDelete(&a1, R);
+    nrzDelete(&b0, R);
+    nrzDelete(&b1, R);
+    nrzDelete(&as, R);
+    return NULL;
+  }
+  nrzDelete(&as, R);
+  nrzDelete(&a0, R);
+  nrzDelete(&b0, R);
+
+  number a, b, ab;
+  coeffs Q = nInitChar(n_Q, 0);
+  nMapFunc f = n_SetMap(R, Q);
+  a = f(a1, R, Q);
+  b = f(b1, R, Q);
+  ab = n_Div(a, b, Q);
+  n_Delete(&a, Q);
+  n_Delete(&b, Q);
+  nKillChar(Q);
+
+  nrzDelete(&a1, R);
+  nrzDelete(&b1, R);
+  return ab;
+}
+
+number nrzMapMachineInt(number from, const coeffs /*src*/, const coeffs /*dst*/)
+{
+  int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+  mpz_init_set_ui(erg, (NATNUMBER) from);
+  return nrz_short((number) erg);
+}
+
+number nrzMapZp(number from, const coeffs /*src*/, const coeffs /*dst*/)
+{
+  int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+  mpz_init_set_si(erg, (long) from);
+  return nrz_short((number) erg);
+}
+
+number nrzModNMap(number from, const coeffs src, const coeffs /*dst*/)
+{
+  int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+  mpz_init_set(erg, (int_number) from);
+  return nrz_short((number) erg);
+}
+
+number nrzMapQ(number from, const coeffs src, const coeffs dst)
+{
+  if (SR_HDL(from) & SR_INT)
+    return nrzInit(SR_TO_INT(from),dst);
+  if (from->s!=3)
+  {
+    WerrorS("rational in map to integer");
+    return NULL;
+  }
+  int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
+  mpz_init_set(erg, from->z);
+  return nrz_short((number) erg);
+}
+
+nMapFunc nrzSetMap(const coeffs src, const coeffs /*dst*/)
+{
+  /* dst = rintegers */
+  if (src->rep==n_rep_gmp) //nCoeff_is_Ring_ModN(src) || nCoeff_is_Ring_PtoM(src))
+    return nrzModNMap;
+
+  if ((src->rep==n_rep_gap_gmp) && nCoeff_is_Ring_Z(src))
+  {
+    return ndCopyMap; //nrzCopyMap;
+  }
+  if (src->rep==n_rep_gap_rat) /*&& nCoeff_is_Ring_Z(src)) Q, bigint*/
+  {
+    return nrzMapQ;
+  }
+  if ((src->rep=n_rep_int) && nCoeff_is_Ring_2toM(src))
+  {
+    return nrzMapMachineInt;
+  }
+  if ((src->rep=n_rep_int) && nCoeff_is_Zp(src))
+  {
+    return nrzMapZp;
+  }
+  return NULL;      // default
+}
+
+
+/*
+ * set the exponent (allocate and init tables) (TODO)
+ */
+
+void nrzSetExp(int, coeffs)
+{
+}
+
+void nrzInitExp(int, coeffs)
+{
+}
+
+#ifdef LDEBUG
+BOOLEAN nrzDBTest (number x, const char *f, const int l, const coeffs)
+{
+  if (SR_HDL(x) & SR_INT) return TRUE;
+  if (mpz_cmp_ui((int_number) x,(long)0)==0)
+  {
+    Print("gmp-0 %s:%d\n",f,l);
+    return FALSE;
+  }
+  if (mpz_size1((int_number)x)<=MP_SMALL)
+  {
+    int ui=mpz_get_si((int_number)x);
+    if ((((ui<<3)>>3)==ui)
+    && (mpz_cmp_si((int_number)x,(long)ui)==0))
+    {
+      Print("gmp-small %s:%d\n",f,l);
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
+#endif
+
+void nrzWrite (number &a, const coeffs)
+{
+  char *s,*z;
+  if (a==NULL)
+  {
+    StringAppendS("o");
+  }
+  else
+  {
+    if (n_Z_IS_SMALL(a))
+    {
+      StringAppend("%d", SR_TO_INT(a));
+    }
+    else
+    {
+      int l=mpz_sizeinbase((int_number) a, 10) + 2;
+      s=(char*)omAlloc(l);
+      z=mpz_get_str(s,10,(int_number) a);
+      StringAppendS(z);
+      omFreeSize((ADDRESS)s,l);
+    }
+  }
+}
+
+/*2
+* extracts a long integer from s, returns the rest    (COPY FROM longrat0.cc)
+*/
+static const char * nlEatLongC(char *s, mpz_ptr i)
+{
+  const char * start=s;
+
+  if (*s<'0' || *s>'9')
+  {
+    mpz_set_si(i,1);
+    return s;
+  }
+  while (*s >= '0' && *s <= '9') s++;
+  if (*s=='\0')
+  {
+    mpz_set_str(i,start,10);
+  }
+  else
+  {
+    char c=*s;
+    *s='\0';
+    mpz_set_str(i,start,10);
+    *s=c;
+  }
+  return s;
+}
+
+const char * nrzRead (const char *s, number *a, const coeffs)
+{
+  int_number z = (int_number) omAllocBin(gmp_nrz_bin);
+  {
+    mpz_init(z);
+    s = nlEatLongC((char *) s, z);
+  }
+  *a = nrz_short((number) z);
+  return s;
+}
+
+void    nrzCoeffWrite  (const coeffs, BOOLEAN /*details*/)
+{
+  //PrintS("// ZZ\n");
+  PrintS("//   coeff. ring is : Integers\n");
+}
+
+static char* nrzCoeffString(const coeffs)
+{
+  return omStrDup("integer");
+}
+
+static CanonicalForm nrzConvSingNFactoryN( number n, BOOLEAN setChar, const coeffs /*r*/ )
+{
+  if (setChar) setCharacteristic( 0 );
+
+  CanonicalForm term;
+  if ( n_Z_IS_SMALL(n))
+  {
+    term = SR_TO_INT(n);
+  }
+  else
+  {
+    mpz_t dummy;
+    mpz_init_set( dummy,n->z );
+    term = make_cf( dummy );
+  }
+  return term;
+}
+
+static number nrzConvFactoryNSingN( const CanonicalForm n, const coeffs r)
+{
+  if (n.isImm())
+  {
+    return nrzInit(n.intval(),r);
+  }
+  else
+  {
+    if ( !n.den().isOne() )
+    {
+     WerrorS("rational in conversion to integer");
+     return NULL;
+    }
+    int_number z = (int_number) omAlloc0Bin(gmp_nrz_bin);
+    gmp_numerator( n,z);
+    return nrz_short((number)z);
+  }
+}
+
+static void nrzMPZ(mpz_t res, number &a, const coeffs)
+{
+  if (n_Z_IS_SMALL(a))
+    mpz_init_set_si(res, SR_TO_INT(a));
+  else
+    mpz_init_set(res, (int_number) a);
+}
+
+coeffs nrzQuot1(number c, const coeffs r)
+{
+    int_number dummy;
+    dummy = (int_number) omAlloc(sizeof(mpz_t));
+    if(n_Z_IS_SMALL(c))
+    {
+      int ch = r->cfInt(c, r);
+      mpz_init_set_ui(dummy, ch);
+    }
+    else
+    {
+      mpz_init_set(dummy, (int_number)c);
+    }
+    ZnmInfo info;
+    info.base = dummy;
+    info.exp = (unsigned long) 1;
+    coeffs rr = nInitChar(n_Zn, (void*)&info);
+    return(rr);
+}
+
+BOOLEAN nrzInitChar(coeffs r,  void *)
+{
+  assume( getCoeffType(r) == ID );
+
+  r->is_field=FALSE;
+  r->is_domain=TRUE;
+  r->rep=n_rep_gap_gmp;
+
+  r->nCoeffIsEqual = ndCoeffIsEqual;
+  r->cfCoeffString = nrzCoeffString;
+  r->cfKillChar = ndKillChar;
+  r->cfMult  = nrzMult;
+  r->cfSub   = nrzSub;
+  r->cfAdd   = nrzAdd;
+  r->cfDiv   = nrzDiv;
+  r->cfIntMod= nrzIntMod;
+  r->cfExactDiv= nrzExactDiv;
+  r->cfInit = nrzInit;
+  r->cfSize  = nrzSize;
+  r->cfInt  = nrzInt;
+  //#ifdef HAVE_RINGS
+  r->cfDivComp = nrzDivComp; // only for ring stuff
+  r->cfIsUnit = nrzIsUnit; // only for ring stuff
+  r->cfGetUnit = nrzGetUnit; // only for ring stuff
+  r->cfAnn = nrzAnn;
+  r->cfExtGcd = nrzExtGcd; // only for ring stuff
+  r->cfXExtGcd = nrzXExtGcd; // only for ring stuff
+  r->cfQuotRem = nrzQuotRem;
+  r->cfDivBy = nrzDivBy; // only for ring stuff
+  //#endif
+  r->cfInpNeg   = nrzNeg;
+  r->cfInvers= nrzInvers;
+  r->cfCopy  = nrzCopy;
+  r->cfWriteLong = nrzWrite;
+  r->cfRead = nrzRead;
+  r->cfGreater = nrzGreater;
+  r->cfEqual = nrzEqual;
+  r->cfIsZero = nrzIsZero;
+  r->cfIsOne = nrzIsOne;
+  r->cfIsMOne = nrzIsMOne;
+  r->cfGreaterZero = nrzGreaterZero;
+  r->cfPower = nrzPower;
+  r->cfGcd  = nrzGcd;
+  //r->cfLcm  = nrzLcm;
+  r->cfDelete= nrzDelete;
+  r->cfSetMap = nrzSetMap;
+  r->cfCoeffWrite = nrzCoeffWrite;
+  r->convSingNFactoryN = nrzConvSingNFactoryN;
+  r->convFactoryNSingN = nrzConvFactoryNSingN;
+  r->cfMPZ = nrzMPZ;
+  r->cfFarey = nrzFarey;
+
+  r->cfQuot1 = nrzQuot1;
+  // debug stuff
+
+#ifdef LDEBUG
+  r->cfDBTest=nrzDBTest;
+#endif
+
+  r->nNULL = 0;
+  r->ch = 0;
+  r->has_simple_Alloc=FALSE;
+  r->has_simple_Inverse=FALSE;
+  return FALSE;
+}
+
+#else
+#error set SI_INTEGER_VARIANT
+#endif
+#endif

libpolys/coeffs/rmodulo2m.cc

@@ -105 +105 @@
   r->is_field=FALSE;
   r->is_domain=FALSE;
+  r->rep=n_rep_int;
 
   r->cfKillChar    = ndKillChar; /* dummy*/
@@ -151 +152 @@
   r->cfName        = ndName;
   r->cfCoeffWrite  = nr2mCoeffWrite;
-  r->cfInit_bigint = nr2mMapQ;
   r->cfQuot1       = nr2mQuot1;
 #ifdef LDEBUG
@@ -682 +682 @@
 }
 
+number nr2mMapZ(number from, const coeffs src, const coeffs dst)
+{
+  if (SR_HDL(from) & SR_INT)
+  {
+    long f_i=SR_TO_INT(from);
+    return nr2mInit(f_i,dst);
+  }
+  return nr2mMapGMP(from,src,dst);
+}
+
 nMapFunc nr2mSetMap(const coeffs src, const coeffs dst)
 {
-  if (nCoeff_is_Ring_2toM(src)
+  if ((src->rep==n_rep_int) && nCoeff_is_Ring_2toM(src)
      && (src->mod2mMask == dst->mod2mMask))
   {
     return ndCopyMap;
   }
-  if (nCoeff_is_Ring_2toM(src)
+  if ((src->rep==n_rep_int) && nCoeff_is_Ring_2toM(src)
      && (src->mod2mMask < dst->mod2mMask))
   { /* i.e. map an integer mod 2^s into Z mod 2^t, where t < s */
     return nr2mMapMachineInt;
   }
-  if (nCoeff_is_Ring_2toM(src)
+  if ((src->rep==n_rep_int) && nCoeff_is_Ring_2toM(src)
      && (src->mod2mMask > dst->mod2mMask))
   { /* i.e. map an integer mod 2^s into Z mod 2^t, where t > s */
@@ -700 +710 @@
     return nr2mMapProject;
   }
-  if (nCoeff_is_Ring_Z(src))
+  if ((src->rep==n_rep_gmp) && nCoeff_is_Ring_Z(src))
   {
     return nr2mMapGMP;
   }
-  if (nCoeff_is_Q(src))
+  if ((src->rep==n_rep_gap_gmp) /*&& nCoeff_is_Ring_Z(src)*/)
+  {
+    return nr2mMapZ;
+  }
+  if ((src->rep==n_rep_gap_rat) && nCoeff_is_Q(src))
   {
     return nr2mMapQ;
   }
-  if (nCoeff_is_Zp(src) && (src->ch == 2))
+  if ((src->rep=n_rep_int) && nCoeff_is_Zp(src) && (src->ch == 2))
   {
     return nr2mMapZp;
   }
-  if (nCoeff_is_Ring_PtoM(src) || nCoeff_is_Ring_ModN(src))
+  if ((src->rep=n_rep_gmp) &&
+  (nCoeff_is_Ring_PtoM(src) || nCoeff_is_Ring_ModN(src)))
   {
     if (mpz_divisible_2exp_p(src->modNumber,dst->modExponent))

libpolys/coeffs/rmodulon.cc

@@ -120 +120 @@
   r->is_field=FALSE;
   r->is_domain=FALSE;
+  r->rep=n_rep_gmp;
 
 
@@ -159 +160 @@
   r->cfCoeffWrite  = nrnCoeffWrite;
   r->nCoeffIsEqual = nrnCoeffsEqual;
-  r->cfInit_bigint = nrnMapQ;
   r->cfKillChar    = ndKillChar;
   r->cfQuot1       = nrnQuot1;
@@ -554 +554 @@
 }
 
+number nrnMapZ(number from, const coeffs src, const coeffs dst)
+{
+  if (SR_HDL(from) & SR_INT)
+  {
+    long f_i=SR_TO_INT(from);
+    return nrnInit(f_i,dst);
+  }
+  return nrnMapGMP(from,src,dst);
+}
+
 number nrnMapQ(number from, const coeffs src, const coeffs dst)
 {
@@ -565 +575 @@
 nMapFunc nrnSetMap(const coeffs src, const coeffs dst)
 {
-  /* dst = currRing->cf */
-  if (nCoeff_is_Ring_Z(src))
+  /* dst = nrn */
+  if ((src->rep==n_rep_gmp) && nCoeff_is_Ring_Z(src))
   {
     return nrnMapGMP;
   }
-  if (nCoeff_is_Q(src))
+  if ((src->rep==n_rep_gap_gmp) /*&& nCoeff_is_Ring_Z(src)*/)
+  {
+    return nrnMapZ;
+  }
+  if ((src->rep==n_rep_gap_rat) && nCoeff_is_Q(src))
   {
     return nrnMapQ;

libpolys/coeffs/shortfl.cc

@@ -430 +430 @@
 
   assume( getCoeffType(r) == ID );
-  assume( getCoeffType(aRing) == n_Q );
+  assume( aRing->rep == n_rep_gap_rat );
 
   mpz_ptr z;
   mpz_ptr zz=NULL;
-  #if SIZEOF_LONG == 8
   if (IS_IMM(from))
   {
-    int ui=SR_TO_INT(from);
-     if ((long)ui==SR_TO_INT(from))
-       return nf((float)ui).N();
      zz=(mpz_ptr)omAlloc(sizeof(mpz_t));
      mpz_init_set_si(zz,SR_TO_INT(from));
      z=zz;
   }
-  #else
-  if (IS_IMM(from))
-    return nf((float)nlInt(from,aRing)).N();
-  #endif
   else
   {
@@ -461 +453 @@
   mpf_abs (e, e);
 
-  #if SIZEOF_LONG == 8
   if (zz!=NULL)
   {
@@ -467 +458 @@
     omFreeSize(zz,sizeof(mpz_t));
   }
-  #endif
   /* if number was an integer, we are done*/
   if(IS_IMM(from)|| IS_INT(from))
@@ -509 +499 @@
   mpf_clear(d);
   mpf_clear(q);
+  return nf(f).N();
+}
+
+number nrMapZ(number from, const coeffs aRing, const coeffs r)
+{
+  assume( getCoeffType(r) == ID );
+  assume( aRing->rep == n_rep_gap_gmp );
+
+  mpz_ptr z;
+  mpz_ptr zz=NULL;
+  if (IS_IMM(from))
+  {
+     zz=(mpz_ptr)omAlloc(sizeof(mpz_t));
+     mpz_init_set_si(zz,SR_TO_INT(from));
+     z=zz;
+  }
+  else
+  {
+    /* read out the enumerator */
+    z=(mpz_ptr)from;
+  }
+
+  int i = mpz_size1(z);
+  mpf_t e;
+  mpf_init(e);
+  mpf_set_z(e,z);
+  int sign= mpf_sgn(e);
+  mpf_abs (e, e);
+
+  if (zz!=NULL)
+  {
+    mpz_clear(zz);
+    omFreeSize(zz,sizeof(mpz_t));
+  }
+  if(i>4)
+  {
+    WerrorS("float overflow");
+    return nf(0.0).N();
+  }
+  double basis;
+  signed long int exp;
+  basis = mpf_get_d_2exp(&exp, e);
+  float f= sign*ldexp(basis,exp);
+  mpf_clear(e);
   return nf(f).N();
 }
@@ -631 +665 @@
   assume( getCoeffType(dst) == ID );
 
-  if (nCoeff_is_Q(src))
+  if (src->rep=n_rep_gap_rat) /*Q, Z */
   {
     return nrMapQ;
   }
-  if (nCoeff_is_long_R(src))
+  if (src->rep=n_rep_gap_gmp) /*Q, Z */
+  {
+    return nrMapZ;
+  }
+  if ((src->rep==n_rep_gmp_float) && nCoeff_is_long_R(src))
   {
     return nrMapLongR;
   }
-  if (nCoeff_is_R(src))
+  if ((src->rep==n_rep_float) && nCoeff_is_R(src))
   {
     return ndCopyMap;
   }
-  if(nCoeff_is_Zp(src))
+  if ((src->rep==n_rep_int) && nCoeff_is_Zp(src))
   {
     return nrMapP;
   }
-  if (nCoeff_is_long_C(src))
+  if ((src->rep==n_rep_gmp_complex) && nCoeff_is_long_C(src))
   {
     return nrMapC;
@@ -667 +705 @@
   n->is_field=TRUE;
   n->is_domain=TRUE;
+  n->rep=n_rep_float;
 
   n->cfKillChar = ndKillChar; /* dummy */
@@ -693 +732 @@
   n->cfSetMap = nrSetMap;
   n->cfCoeffWrite  = nrCoeffWrite;
-  n->cfInit_bigint = nrMapQ;
 
     /* nName= ndName; */

libpolys/misc/auxiliary.h.in

@@ -54 +54 @@
 #endif
 
-#ifdef HAVE_FACTORY
-
 #ifndef SINGULAR
 #undef SINGULAR
@@ -64 +62 @@
 #endif
 
-#endif
-// #ifdef HAVE_FACTORY
-
 // ----------------  end of parts/extensions
 
 // ---------------- Singular standard types etc.
-// BOOLEAN
+/* SI_INTEGER_VARIANT: 1: from longrat.cc
+ *                     2: GMP
+ *                     3: rintegers.cc */
+#define SI_INTEGER_VARIANT 2
+
+/* SI_BIGINT_VARIANT: 1: from longrat.cc
+ *                    2: given by SI_INTEGER_VARIANT */
+#define SI_BIGINT_VARIANT 1
+
 #ifndef SIZEOF_LONG
 

libpolys/polys/ext_fields/algext.cc

@@ -350 +350 @@
 }
 
-number naInit_bigint(number longratBigIntNumber, const coeffs src, const coeffs cf)
-{
-  assume( cf != NULL );
-
-  const ring A = cf->extRing;
-
-  assume( A != NULL );
-
-  const coeffs C = A->cf;
-
-  assume( C != NULL );
-
-  number n = n_Init_bigint(longratBigIntNumber, src, C);
-
-  if ( n_IsZero(n, C) )
-  {
-    n_Delete(&n, C);
-    return NULL;
-  }
-
-  return (number)p_NSet(n, A);
-}
-
-
-
 number naInit(long i, const coeffs cf)
 {
@@ -889 +864 @@
 }
 
-/* assumes that src = Q, dst = Q(a) */
+/* assumes that src = Q or Z, dst = Q(a) */
 number naMap00(number a, const coeffs src, const coeffs dst)
 {
   if (n_IsZero(a, src)) return NULL;
-  assume(src == dst->extRing->cf);
+  assume(src->rep == dst->extRing->cf->rep);
   poly result = p_One(dst->extRing);
   p_SetCoeff(result, n_Copy(a, src), dst->extRing);
+  return (number)result;
+}
+
+/* assumes that src = Z, dst = K(a) */
+number naMapZ0(number a, const coeffs src, const coeffs dst)
+{
+  if (n_IsZero(a, src)) return NULL;
+  poly result = p_One(dst->extRing);
+  nMapFunc nMap=n_SetMap(src,dst->extRing->cf);
+  p_SetCoeff(result, nMap(a, src, dst->extRing->cf), dst->extRing);
+  if (n_IsZero(pGetCoeff(result),dst->extRing->cf))
+    p_Delete(&result,dst->extRing);
   return (number)result;
 }
@@ -1061 +1048 @@
   if (h==0)
   {
-    if (nCoeff_is_Q(src) && nCoeff_is_Q(bDst))
-      return naMap00;                            /// Q     -->  Q(a)
+    if ((src->rep==n_rep_gap_rat) && nCoeff_is_Q(bDst))
+      return naMap00;                            /// Q or Z     -->  Q(a)
+    if ((src->rep==n_rep_gap_gmp) && nCoeff_is_Q(bDst))
+      return naMapZ0;                            /// Z     -->  Q(a)
     if (nCoeff_is_Zp(src) && nCoeff_is_Q(bDst))
       return naMapP0;                            /// Z/p   -->  Q(a)
     if (nCoeff_is_Q(src) && nCoeff_is_Zp(bDst))
       return naMap0P;                            /// Q      --> Z/p(a)
+    if ((src->rep==n_rep_gap_gmp) && nCoeff_is_Zp(bDst))
+      return naMapZ0;                            /// Z     -->  Z/p(a)
     if (nCoeff_is_Zp(src) && nCoeff_is_Zp(bDst))
     {
@@ -1423 +1414 @@
   cf->is_field=TRUE;
   cf->is_domain=TRUE;
+  cf->rep=n_rep_poly;
 
   #ifdef LDEBUG
@@ -1437 +1429 @@
   cf->cfIsMOne       = naIsMOne;
   cf->cfInit         = naInit;
-  cf->cfInit_bigint  = naInit_bigint;
   cf->cfFarey        = naFarey;
   cf->cfChineseRemainder= naChineseRemainder;
@@ -1617 +1608 @@
   cf->cfIsMOne       = naIsMOne;
   cf->cfInit         = naInit;
-  cf->cfInit_bigint  = naInit_bigint;
   cf->cfFarey        = naFarey;
   cf->cfChineseRemainder= naChineseRemainder;

libpolys/polys/ext_fields/transext.cc

@@ -565 +565 @@
 }
 
-number ntInit_bigint(number longratBigIntNumber, const coeffs src, const coeffs cf)
-{
-  assume( cf != NULL );
-
-  const ring A = cf->extRing;
-
-  assume( A != NULL );
-
-  const coeffs C = A->cf;
-
-  assume( C != NULL );
-
-  number n = n_Init_bigint(longratBigIntNumber, src, C);
-
-  if ( n_IsZero(n, C) )
-  {
-    n_Delete(&n, C);
-    return NULL;
-  }
-
-  fraction result = (fraction)omAlloc0Bin(fractionObjectBin);
-
-  number den = n_GetDenom(n, C);
-
-  assume( n_GreaterZero(den, C) );
-
-  if( n_IsOne(den, C) )
-  {
-     NUM(result) = p_NSet(n, A);
-     //DEN(result) = NULL; // done by ..Alloc0..
-     n_Delete(&den, C);
-  }
-  else
-  {
-     DEN(result) = p_NSet(den, A);
-     NUM(result) = p_NSet(n_GetNumerator(n, C), A);
-     n_Delete(&n, C);
-  }
-
-  //COM(result) = 0; // done by ..Alloc0..
-
-  ntTest((number)result);
-  //check_N((number)result,cf);
-
-  return (number)result;
-}
-
-
 number ntInit(long i, const coeffs cf)
 {
@@ -1804 +1756 @@
 }
 
-/* assumes that src = Q, dst = Q(t_1, ..., t_s) */
+/* assumes that src = Q or Z, dst = Q(t_1, ..., t_s) */
 number ntMap00(number a, const coeffs src, const coeffs dst)
 {
   if (n_IsZero(a, src)) return NULL;
   assume(n_Test(a, src));
-  assume(src == dst->extRing->cf);
+  assume(src->rep == dst->extRing->cf->rep);
   if ((SR_HDL(a) & SR_INT) || (a->s==3))
   {
@@ -1825 +1777 @@
   //check_N((number)ff,dst);
   return (number)ff;
+}
+
+number ntMapZ0(number a, const coeffs src, const coeffs dst)
+{
+  if (n_IsZero(a, src)) return NULL;
+  assume(n_Test(a, src));
+  nMapFunc nMap=n_SetMap(src,dst->extRing->cf);
+  poly p=p_NSet(nMap(a, src,dst->extRing->cf), dst->extRing);
+  if (n_IsZero(pGetCoeff(p),dst->extRing->cf))
+    p_Delete(&p,dst->extRing);
+  number res=ntInit(p, dst);
+  n_Test(res,dst);
+  return res;
 }
 
@@ -1992 +1957 @@
   if (h==0)
   {
-    if (nCoeff_is_Q(src) && nCoeff_is_Q(bDst))
-      return ntMap00;                                 /// Q       -->  Q(T)
+    if ((src->rep==n_rep_gap_rat) && nCoeff_is_Q(bDst))
+      return ntMap00;                                 /// Q or Z   -->  Q(T)
+    if (src->rep==n_rep_gap_gmp)
+      return ntMapZ0;                                 /// Z   -->  K(T)
     if (nCoeff_is_Zp(src) && nCoeff_is_Q(bDst))
       return ntMapP0;                                 /// Z/p     -->  Q(T)
@@ -2431 +2398 @@
   cf->is_field=TRUE;
   cf->is_domain=TRUE;
+  cf->rep=n_rep_rat_fct;
 
   cf->factoryVarOffset = R->cf->factoryVarOffset + rVar(R);
@@ -2443 +2411 @@
   cf->cfIsMOne       = ntIsMOne;
   cf->cfInit         = ntInit;
-  cf->cfInit_bigint  = ntInit_bigint;
   cf->cfFarey        = ntFarey;
   cf->cfChineseRemainder = ntChineseRemainder;