Changeset 7d90aa in git

Timestamp:

Mar 8, 2011, 7:29:56 PM (12 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')

Children:

655a2976d656bc7749e136dea00a5bb75c14a0b4

Parents:

634d93b52f3d7540be44b7c941a206dc38b1b1be

git-author:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2011-03-08 19:29:56+01:00

git-committer:

Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 11:49:00+01:00

Message:

initial changes to 'coeffs' + first build system

Location:

coeffs

Files:

• Makefile.in (added)
• coeffs.h (added)
• config.h.in (added)
• configure (added)
• configure.ac (added)
• ffields.h (modified) (2 diffs)
• gnumpc.cc (modified) (8 diffs)
• gnumpc.h (modified) (2 diffs)
• gnumpfl.cc (modified) (1 diff)
• gnumpfl.h (modified) (1 diff)
• longalg.cc (modified) (6 diffs)
• longrat.cc (modified) (7 diffs)
• longrat.h (modified) (5 diffs)
• longrat0.cc (modified) (1 diff)
• modulop.cc (modified) (39 diffs)
• modulop.h (modified) (7 diffs)
• mpr_base.cc (modified) (13 diffs)
• mpr_complex.cc (modified) (3 diffs)
• mpr_complex.h (modified) (2 diffs)
• mpr_numeric.cc (modified) (12 diffs)
• numbers.cc (modified) (21 diffs)
• numbers.h (modified) (5 diffs)
• rmodulo2m.cc (modified) (1 diff)
• rmodulo2m.h (modified) (1 diff)
• rmodulon.cc (modified) (1 diff)
• rmodulon.h (modified) (1 diff)
• shortfl.cc (modified) (17 diffs)
• shortfl.h (modified) (1 diff)
• si_gmp.h (added)

coeffs/ffields.h

@@ -8 +8 @@
 * ABSTRACT: finite fields with a none-prime number of elements (via tables)
 */
-#include <kernel/structs.h>
+#include "coeffs.h"
 
 
-BOOLEAN nfGreaterZero (number k);
-number  nfMult        (number a, number b);
-number  nfInit        (int i, const ring r);
-number  nfPar         (int i);
-int     nfParDeg      (number n);
-int     nfInt         (number &n, const ring r);
-number  nfAdd         (number a, number b);
-number  nfSub         (number a, number b);
-void    nfPower       (number a, int i, number * result);
-BOOLEAN nfIsZero      (number a);
-BOOLEAN nfIsOne       (number a);
-BOOLEAN nfIsMOne      (number a);
-number  nfDiv         (number a, number b);
-number  nfNeg         (number c);
-number  nfInvers      (number c);
-BOOLEAN nfGreater     (number a, number b);
-BOOLEAN nfEqual       (number a, number b);
-void    nfWrite       (number &a, const ring r);
-const char *  nfRead  (const char *s, number *a);
+BOOLEAN nfGreaterZero (number k, const coeffs r);
+number  nfMult        (number a, number b, const coeffs r);
+number  nfInit        (int i, const coeffs r);
+number  nfPar         (int i, const coeffs r);
+int     nfParDeg      (number n, const coeffs r);
+int     nfInt         (number &n, const coeffs r);
+number  nfAdd         (number a, number b, const coeffs r);
+number  nfSub         (number a, number b, const coeffs r);
+void    nfPower       (number a, int i, number * result, const coeffs r);
+BOOLEAN nfIsZero      (number a, const coeffs r);
+BOOLEAN nfIsOne       (number a, const coeffs r);
+BOOLEAN nfIsMOne      (number a, const coeffs r);
+number  nfDiv         (number a, number b, const coeffs r);
+number  nfNeg         (number c, const coeffs r);
+number  nfInvers      (number c, const coeffs r);
+BOOLEAN nfGreater     (number a, number b, const coeffs r);
+BOOLEAN nfEqual       (number a, number b, const coeffs r);
+void    nfWrite       (number &a, const coeffs r);
+const char *  nfRead  (const char *s, number *a, const coeffs r);
 #ifdef LDEBUG
 BOOLEAN nfDBTest      (number a, const char *f, const int l);
@@ -35 +35 @@
 void    nfSetChar     (int c, char ** param);
 
-nMapFunc nfSetMap     (const ring src, const ring dst);
-char *  nfName        (number n);
+nMapFunc nfSetMap     (const coeffs src, const coeffs dst);
+char *  nfName        (number n, const coeffs r);
 extern  int nfMinPoly[];
 extern  int nfCharP;  /* the characteristic: p*/

coeffs/gnumpc.cc

@@ -9 +9 @@
 */
 
-#include <kernel/mod2.h>
-#include <kernel/structs.h>
-#include <kernel/febase.h>
-#include <omalloc/omalloc.h>
-#include <kernel/numbers.h>
-#include <kernel/longrat.h>
-#include <kernel/modulop.h>
-#include <kernel/gnumpc.h>
-#include <kernel/gnumpfl.h>
-#include <kernel/mpr_complex.h>
+#include "coeffs.h"
+#include "numbers.h"
+#include "longrat.h"
+#include "modulop.h"
+#include "gnumpc.h"
+#include "gnumpfl.h"
+#include "mpr_complex.h"
 
 extern size_t gmp_output_digits;
@@ -71 +68 @@
 }
 
-nMapFunc ngcSetMap(const ring src,const ring dst)
+nMapFunc ngcSetMap(const coeffs src,const coeffs dst)
 {
   if(rField_is_Q(src))
@@ -106 +103 @@
 * n := i
 */
-number ngcInit (int i, const ring r)
+number ngcInit (int i, const coeffs r)
 {
   gmp_complex* n= new gmp_complex( (long)i, (long)0 );
@@ -115 +112 @@
 * convert number to int
 */
-int ngcInt(number &i, const ring r)
+int ngcInt(number &i, const coeffs r)
 {
   return (int)((gmp_complex*)i)->real();
@@ -138 +135 @@
 * delete a
 */
-void ngcDelete (number * a, const ring r)
+void ngcDelete (number * a, const coeffs r)
 {
   if ( *a != NULL )
@@ -155 +152 @@
   return (number)b;
 }
-number ngc_Copy(number a, ring r)
+number ngc_Copy(number a, const coeffs r)
 {
   gmp_complex* b=new gmp_complex( *(gmp_complex*)a );
@@ -373 +370 @@
 * write a floating point number
 */
-void ngcWrite (number &a, const ring r)
+void ngcWrite (number &a, const coeffs r)
 {
   if (a==NULL)
@@ -382 +379 @@
     out= complexToStr(*(gmp_complex*)a,gmp_output_digits);
     StringAppendS(out);
-    //    omFreeSize((ADDRESS)out, (strlen(out)+1)* sizeof(char) );
-    omFree( (ADDRESS)out );
+    //    omFreeSize((void *)out, (strlen(out)+1)* sizeof(char) );
+    omFree( (void *)out );
   }
 }

coeffs/gnumpc.h

@@ -8 +8 @@
 * ABSTRACT: computations with GMP floating-point numbers
 */
-#include <kernel/structs.h>
+#include "coeffs.h"
 
-BOOLEAN  ngcGreaterZero(number za);      // !!! MAY NOT WORK AS EXPECTED !!!
-BOOLEAN  ngcGreater(number a, number b);
-BOOLEAN  ngcEqual(number a, number b);
-BOOLEAN  ngcIsOne(number a);
-BOOLEAN  ngcIsMOne(number a);
-BOOLEAN  ngcIsZero(number za);
-number   ngcInit(int i, const ring r);
-int      ngcInt(number &n, const ring r);
-number   ngcNeg(number za);
-number   ngcInvers(number a);
-number   ngcPar(int i);
-number   ngcAdd(number la, number li);
-number   ngcSub(number la, number li);
-number   ngcMult(number a, number b);
-number   ngcDiv(number a, number b);
-int      ngcSize(number n);
-void     ngcPower(number x, int exp, number *lu);
+BOOLEAN  ngcGreaterZero(number za, const coeffs r); // !!! MAY NOT WORK AS EXPECTED !!!
+BOOLEAN  ngcGreater(number a, number b, const coeffs r);
+BOOLEAN  ngcEqual(number a, number b, const coeffs r);
+BOOLEAN  ngcIsOne(number a, const coeffs r);
+BOOLEAN  ngcIsMOne(number a, const coeffs r);
+BOOLEAN  ngcIsZero(number za, const coeffs r);
+number   ngcInit(int i, const coeffs r);
+int      ngcInt(number &n, const coeffs r);
+number   ngcNeg(number za, const coeffs r);
+number   ngcInvers(number a, const coeffs r);
+number   ngcPar(int i, const coeffs r);
+number   ngcAdd(number la, number li, const coeffs r);
+number   ngcSub(number la, number li, const coeffs r);
+number   ngcMult(number a, number b, const coeffs r);
+number   ngcDiv(number a, number b, const coeffs r);
+void     ngcPower(number x, int exp, number *lu, const coeffs r);
 number   ngcCopy(number a);
-number   ngc_Copy(number a, ring r);
-const char * ngcRead (const char *s, number *a);
-void     ngcWrite(number &a, const ring r);
-number   ngcRePart(number a);
-number   ngcImPart(number a);
+number   ngc_Copy(number a, coeffs r);
+const char * ngcRead (const char *s, number *a, const coeffs r);
+void     ngcWrite(number &a, const coeffs r);
+number   ngcRePart(number a, const coeffs r);
+number   ngcImPart(number a, const coeffs r);
 
 
@@ -38 +37 @@
 BOOLEAN  ngcDBTest(number a, const char *f, const int l);
 #endif
-void     ngcDelete(number *a, const ring r);
+void     ngcDelete(number *a, const coeffs r);
 
-nMapFunc  ngcSetMap(const ring src, const ring dst);
+nMapFunc  ngcSetMap(const coeffs src, const coeffs dst);
 
-number ngcMapQ(number from);
+number ngcMapQ(number from, const coeffs r);
 #endif
 

coeffs/gnumpfl.cc

@@ -382 +382 @@
     out= floatToStr(*(gmp_float*)a,gmp_output_digits);
     StringAppendS(out);
-    //omFreeSize((ADDRESS)out, (strlen(out)+1)* sizeof(char) );
-    omFree( (ADDRESS)out );
+    //omFreeSize((void *)out, (strlen(out)+1)* sizeof(char) );
+    omFree( (void *)out );
   }
   else

coeffs/gnumpfl.h

@@ -8 +8 @@
 * ABSTRACT: computations with GMP floating-point numbers
 */
-#include <kernel/structs.h>
+#include "coeffs.h"
 
-BOOLEAN  ngfGreaterZero(number za);
-BOOLEAN  ngfGreater(number a, number b);
-BOOLEAN  ngfEqual(number a, number b);
-BOOLEAN  ngfIsOne(number a);
-BOOLEAN  ngfIsMOne(number a);
-BOOLEAN  ngfIsZero(number za);
-number   ngfInit(int i, const ring r);
-int      ngfInt(number &n, const ring r);
-number   ngfNeg(number za);
-number   ngfInvers(number a);
-number   ngfAdd(number la, number li);
-number   ngfSub(number la, number li);
-number   ngfMult(number a, number b);
-int      ngfSize(number n);
-number   ngfDiv(number a, number b);
-void     ngfPower(number x, int exp, number *lu);
+BOOLEAN  ngfGreaterZero(number za, const coeffs r);
+BOOLEAN  ngfGreater(number a, number b, const coeffs r);
+BOOLEAN  ngfEqual(number a, number b, const coeffs r);
+BOOLEAN  ngfIsOne(number a, const coeffs r);
+BOOLEAN  ngfIsMOne(number a, const coeffs r);
+BOOLEAN  ngfIsZero(number za, const coeffs r);
+number   ngfInit(int i, const coeffs r);
+int      ngfInt(number &n, const coeffs r);
+number   ngfNeg(number za, const coeffs r);
+number   ngfInvers(number a, const coeffs r);
+number   ngfAdd(number la, number li, const coeffs r);
+number   ngfSub(number la, number li, const coeffs r);
+number   ngfMult(number a, number b, const coeffs r);
+number   ngfDiv(number a, number b, const coeffs r);
+void     ngfPower(number x, int exp, number *lu, const coeffs r);
 number   ngfCopy(number a);
-number   ngf_Copy(number a, ring r);
-const char *   ngfRead (const char *s, number *a);
-void     ngfWrite(number &a, const ring r);
+number   ngf_Copy(number a, coeffs r);
+const char *   ngfRead (const char *s, number *a, const coeffs r);
+void     ngfWrite(number &a, const coeffs r);
 
 #ifdef LDEBUG
 BOOLEAN  ngfDBTest(number a, const char *f, const int l);
 #endif
-void     ngfDelete(number *a, const ring r);
+void     ngfDelete(number *a, const coeffs r);
 
-nMapFunc  ngfSetMap(const ring src, const ring dst);
+nMapFunc  ngfSetMap(const coeffs src, const coeffs dst);
 
 void setGMPFloatDigits( size_t digits, size_t rest );
-number ngfMapQ(number from);
+number ngfMapQ(number from, const coeffs r);
 #endif

coeffs/longalg.cc

@@ -92 +92 @@
     for (j=naI->anz-1; j>=0; j--)
        p_Delete (&naI->liste[j],nacRing);
-    omFreeSize((ADDRESS)naI->liste,naI->anz*sizeof(napoly));
-    omFreeBin((ADDRESS)naI, snaIdeal_bin);
+    omFreeSize((void *)naI->liste,naI->anz*sizeof(napoly));
+    omFreeBin((void *)naI, snaIdeal_bin);
     naI=NULL;
   }
@@ -978 +978 @@
     p_Delete(&(l->z),r->algring);
     p_Delete(&(l->n),r->algring);
-    omFreeBin((ADDRESS)l,  rnumber_bin);
+    omFreeBin((void *)l,  rnumber_bin);
   }
   *p = NULL;
@@ -1198 +1198 @@
   if(lo->z==NULL)
   {
-    omFreeBin((ADDRESS)lo, rnumber_bin);
+    omFreeBin((void *)lo, rnumber_bin);
     lo=NULL;
   }
@@ -1484 +1484 @@
   if(a->z==NULL)
   {
-    omFreeBin((ADDRESS)*p, rnumber_bin);
+    omFreeBin((void *)*p, rnumber_bin);
     *p=NULL;
   }
@@ -1524 +1524 @@
     }
   }
-  omFreeSize((ADDRESS)t,8);
+  omFreeSize((void *)t,8);
   if (s[0]=='\0')
   {
-    omFree((ADDRESS)s);
+    omFree((void *)s);
     return NULL;
   }
@@ -2115 +2115 @@
     for (i=naI->anz-1; i>=0; i--)
       p_Delete(&naI->liste[i],nacRing);
-    omFreeBin((ADDRESS)naI, snaIdeal_bin);
+    omFreeBin((void *)naI, snaIdeal_bin);
     naI=NULL;
   }

coeffs/longrat.cc

@@ -45 +45 @@
 #include <string.h>
 #include <float.h>
-#include <omalloc/omalloc.h>
-#include <kernel/febase.h>
-#include <kernel/numbers.h>
-#include <kernel/modulop.h>
-#include <kernel/ring.h>
-#include <kernel/shortfl.h>
-#include <kernel/mpr_complex.h>
+#include "coeffs.h"
+#include "omalloc.h"
+#include "numbers.h"
+#include "modulop.h"
+#include "shortfl.h"
+#include "mpr_complex.h"
+#include "longrat.h"
 
 
@@ -660 +660 @@
     bb->debug=654324;
 #endif
-    FREE_RNUMBER(bb);
+    omFreeBin((void *)bb, rnumber_bin);
   }
   u=nlShort3(u);
@@ -726 +726 @@
     bb->debug=654324;
 #endif
-    FREE_RNUMBER(bb);
+    omFreeBin((void *)bb, rnumber_bin);
   }
   u=nlShort3(u);
@@ -803 +803 @@
     bb->debug=654324;
 #endif
-    FREE_RNUMBER(bb);
+    omFreeBin((void *)bb, rnumber_bin);
   }
   if (mpz_isNeg(u->z))
@@ -846 +846 @@
     if (r==0)
     {
-      FREE_RNUMBER(u);
+      omFreeBin((void *)u, rnumber_bin);
       return INT_TO_SR(i/j);
     }
@@ -1396 +1396 @@
 #endif
     }
-    FREE_RNUMBER(*a);
+    omFreeBin((void *) *a, rnumber_bin);
   }
 }
@@ -2462 +2462 @@
     {
       mpz_clear(&r->z);
-      FREE_RNUMBER(r);
+      omFreeBin((void *)r, rnumber_bin);
       r=INT_TO_SR(ui);
     }

coeffs/longrat.h

@@ -8 +8 @@
 * ABSTRACT: computation with long rational numbers
 */
-#include <kernel/structs.h>
+#include "coeffs.h"
 
-#include <kernel/si_gmp.h>
+#include "si_gmp.h"
+
+typedef MP_INT lint;
 
 #define SR_HDL(A) ((long)(A))
 
 #define SR_INT    1L
-#define INT_TO_SR(INT)  ((number) ((((long)INT) << 2) + SR_INT))
+#define INT_TO_SR(INT)  ((number) (((long)INT << 2) + SR_INT))
 #define SR_TO_INT(SR)   (((long)SR) >> 2)
-
 
 #define MP_SMALL 1
@@ -28 +29 @@
 struct snumber
 {
-  mpz_t z;
-  mpz_t n;
+  lint z;
+  lint n;
 #if defined(LDEBUG)
   int debug;
@@ -45 +46 @@
 #endif // DO_LINLINE
 
-LINLINE BOOLEAN  nlEqual(number a, number b);
-LINLINE number   nlInit(int i, const ring r);
-number nlRInit (long i);
-LINLINE BOOLEAN  nlIsOne(number a);
-LINLINE BOOLEAN  nlIsZero(number za);
+LINLINE BOOLEAN  nlEqual(number a, number b, const coeffs r);
+LINLINE number   nlInit(int i, const coeffs r);
+number nlRInit (int i);
+LINLINE BOOLEAN  nlIsOne(number a, const coeffs r);
+LINLINE BOOLEAN  nlIsZero(number za, const coeffs r);
 LINLINE number   nlCopy(number a);
-LINLINE void     nlDelete(number *a, const ring r);
-LINLINE number   nlNeg(number za);
-LINLINE number   nlAdd(number la, number li);
-LINLINE number   nlSub(number la, number li);
-LINLINE number   nlMult(number a, number b);
+LINLINE number   nl_Copy(number a, const coeffs r);
+LINLINE void     nlDelete(number *a, const coeffs r);
+LINLINE number   nlNeg(number za, const coeffs r);
+LINLINE number   nlAdd(number la, number li, const coeffs r);
+LINLINE number   nlSub(number la, number li, const coeffs r);
+LINLINE number   nlMult(number a, number b, const coeffs r);
 
 number   nlInit2 (int i, int j);
 number   nlInit2gmp (mpz_t i, mpz_t j);
-number   nlGcd(number a, number b, const ring r);
-number   nlLcm(number a, number b, const ring r);   /*special routine !*/
-BOOLEAN  nlGreater(number a, number b);
-BOOLEAN  nlIsMOne(number a);
-int      nlInt(number &n, const ring r);
+number   nlGcd(number a, number b, const coeffs r);
+number   nlLcm(number a, number b, const coeffs r);   /*special routine !*/
+BOOLEAN  nlGreater(number a, number b, const coeffs r);
+BOOLEAN  nlIsMOne(number a, const coeffs r);
+int      nlInt(number &n, const coeffs r);
 number   nlBigInt(number &n);
 #ifdef HAVE_RINGS
 void     nlGMP(number &i, number n);
 #endif
-BOOLEAN  nlGreaterZero(number za);
-number   nlInvers(number a);
-void     nlNormalize(number &x);
-number   nlDiv(number a, number b);
-number   nlExactDiv(number a, number b);
-number   nlIntDiv(number a, number b);
-number   nlIntMod(number a, number b);
-void     nlPower(number x, int exp, number *lu);
-const char *   nlRead (const char *s, number *a);
-void     nlWrite(number &a, const ring r);
+BOOLEAN  nlGreaterZero(number za, const coeffs r);
+number   nlInvers(number a, const coeffs r);
+void     nlNormalize(number &x, const coeffs r);
+number   nlDiv(number a, number b, const coeffs r);
+number   nlExactDiv(number a, number b, const coeffs r);
+number   nlIntDiv(number a, number b, const coeffs r);
+number   nlIntMod(number a, number b, const coeffs r);
+void     nlPower(number x, int exp, number *lu, const coeffs r);
+const char *   nlRead (const char *s, number *a, const coeffs r);
+void     nlWrite(number &a, const coeffs r);
 int      nlModP(number n, int p);
-int      nlSize(number n);
-number   nlGetDenom(number &n, const ring r);
-number   nlGetNumerator(number &n, const ring r);
+int      nlSize(number n, const coeffs r);
+number   nlGetDenom(number &n, const coeffs r);
+number   nlGetNumerator(number &n, const coeffs r);
 number   nlChineseRemainder(number *x, number *q,int rl);
 #ifdef LDEBUG
@@ -88 +90 @@
 extern number nlOne;
 
-nMapFunc nlSetMap(const ring src, const ring dst);
+nMapFunc nlSetMap(const coeffs src, const coeffs dst);
 #ifdef HAVE_RINGS
 number nlMapGMP(number from);
 #endif
 
-//#define SI_THREADS 1
-#ifdef SI_THREADS
-#define ALLOC_RNUMBER() (number)malloc(sizeof(snumber));
-static inline number ALLOC0_RNUMBER() { number n=(number)malloc(sizeof(snumber));memset(n,0,sizeof(snumber));return n; }
-#define FREE_RNUMBER(x) free(x)
-#else
-extern omBin rnumber_bin;
+#ifndef OM_ALLOC_H
+struct omBin_s;
+#endif
+extern omBin_s* rnumber_bin;
+
+
+#define FREE_RNUMBER(x) omFreeBin((void *)x, rnumber_bin)
 #define ALLOC_RNUMBER() (number)omAllocBin(rnumber_bin)
 #define ALLOC0_RNUMBER() (number)omAlloc0Bin(rnumber_bin)
-#define FREE_RNUMBER(x) omFreeBin((ADDRESS)x, rnumber_bin)
-#endif
 
 // in-place operations
-void nlInpGcd(number &a, number b, const ring r);
-void nlInpIntDiv(number &a, number b, const ring r);
-LINLINE number   nlInpAdd(number la, number li, const ring r);
-LINLINE void nlInpMult(number &a, number b, ring r);
+void nlInpGcd(number &a, number b, const coeffs r);
+void nlInpIntDiv(number &a, number b, const coeffs r);
+LINLINE number nlInpAdd(number la, number li, const coeffs r);
+LINLINE void nlInpMult(number &a, number b, const coeffs r);
 
 number nlFarey(number nP, number nN);
@@ -117 +117 @@
 BOOLEAN nlDBTest(number a, char *f,int l);
 #else
-#define nlTest(a) ((void)1)
+#define nlTest(a) ((void)0)
 #endif
 

coeffs/longrat0.cc

@@ -139 +139 @@
       StringAppendS(z);
     }
-    omFreeSize((ADDRESS)s,l);
+    omFreeSize((void *)s,l);
   }
 }

coeffs/modulop.cc

@@ -8 +8 @@
 
 #include <string.h>
-#include <kernel/mod2.h>
-#include <omalloc/mylimits.h>
-#include <kernel/structs.h>
-#include <kernel/febase.h>
-#include <omalloc/omalloc.h>
-#include <kernel/numbers.h>
-#include <kernel/longrat.h>
-#include <kernel/mpr_complex.h>
-#include <kernel/ring.h>
-#ifdef HAVE_RINGS
-#include <si_gmp.h>
-#endif
-#include <kernel/modulop.h>
-
-long npPrimeM=0;
+#include "coeffs.h"
+#include "numbers.h"
+#include "longrat.h"
+#include "mpr_complex.h"
+#include "modulop.h"
+
 int npGen=0;
-long npPminus1M=0;
 long npMapPrime;
 
@@ -37 +27 @@
 
 
-BOOLEAN npGreaterZero (number k)
+BOOLEAN npGreaterZero (number k, const coeffs r)
 {
   int h = (int)((long) k);
-  return ((int)h !=0) && (h <= (npPrimeM>>1));
+  return ((int)h !=0) && (h <= (r->npPrimeM>>1));
 }
 
@@ -51 +41 @@
 //}
 
-number npMult (number a,number b)
+number npMult (number a,number b, const coeffs r)
 {
   if (((long)a == 0) || ((long)b == 0))
     return (number)0;
   else
-    return npMultM(a,b);
+    return npMultM(a,b, r);
 }
 
@@ -62 +52 @@
 * create a number from int
 */
-number npInit (int i, const ring r)
+number npInit (int i, const coeffs r)
 {
   long ii=i;
@@ -74 +64 @@
 * convert a number to int (-p/2 .. p/2)
 */
-int npInt(number &n, const ring r)
+int npInt(number &n, const coeffs r)
 {
   if ((long)n > (((long)r->ch) >>1)) return (int)((long)n -((long)r->ch));
@@ -80 +70 @@
 }
 
-number npAdd (number a, number b)
-{
-  return npAddM(a,b);
-}
-
-number npSub (number a, number b)
-{
-  return npSubM(a,b);
-}
-
-BOOLEAN npIsZero (number  a)
+number npAdd (number a, number b, const coeffs r)
+{
+  return npAddM(a,b, r);
+}
+
+number npSub (number a, number b, const coeffs r)
+{
+  return npSubM(a,b,r);
+}
+
+BOOLEAN npIsZero (number  a, const coeffs r)
 {
   return 0 == (long)a;
 }
 
-BOOLEAN npIsOne (number a)
+BOOLEAN npIsOne (number a, const coeffs r)
 {
   return 1 == (long)a;
 }
 
-BOOLEAN npIsMOne (number a)
-{
-  return ((npPminus1M == (long)a)&&((long)1!=(long)a));
+BOOLEAN npIsMOne (number a, const coeffs r)
+{
+  return ((r->npPminus1M == (long)a)&&((long)1!=(long)a));
 }
 
@@ -115 +105 @@
 #endif
 
-long InvMod(long a)
+long InvMod(long a, const coeffs R)
 {
    long d, s, t;
 
 #ifdef USE_NTL_XGCD
-   XGCD(d, s, t, a, npPrimeM);
+   XGCD(d, s, t, a, R->npPrimeM);
    assume (d == 1);
 #else
@@ -127 +117 @@
    assume(a>0);
    u1=1; u2=0;
-   u = a; v = npPrimeM;
+   u = a; v = R->npPrimeM;
 
    while (v != 0)
@@ -144 +134 @@
 #endif
    if (s < 0)
-      return s + npPrimeM;
+      return s + R->npPrimeM;
    else
       return s;
@@ -150 +140 @@
 #endif
 
-static inline number npInversM (number c)
+inline number npInversM (number c, const coeffs r)
 {
 #ifndef HAVE_DIV_MOD
-  return (number)(long)npExpTable[npPminus1M - npLogTable[(long)c]];
+  return (number)(long)r->npExpTable[r->npPminus1M - r->npLogTable[(long)c]];
 #else
-  long inv=(long)npInvTable[(long)c];
+  long inv=(long)r->npInvTable[(long)c];
   if (inv==0)
   {
-    inv=InvMod((long)c);
-    npInvTable[(long)c]=inv;
+    inv=InvMod((long)c,r);
+    r->npInvTable[(long)c]=inv;
   }
   return (number)inv;
@@ -165 +155 @@
 }
 
-number npDiv (number a,number b)
+number npDiv (number a,number b, const coeffs r)
 {
 //#ifdef NV_OPS
@@ -181 +171 @@
   else
   {
-    int s = npLogTable[(long)a] - npLogTable[(long)b];
+    int s = r->npLogTable[(long)a] - r->npLogTable[(long)b];
     if (s < 0)
-      s += npPminus1M;
-    return (number)(long)npExpTable[s];
+      s += r->npPminus1M;
+    return (number)(long)r->npExpTable[s];
   }
 #else
-  number inv=npInversM(b);
-  return npMultM(a,inv);
-#endif
-}
-number  npInvers (number c)
+  number inv=npInversM(b,r);
+  return npMultM(a,inv,r);
+#endif
+}
+number  npInvers (number c, const coeffs r)
 {
   if ((long)c==0)
@@ -198 +188 @@
     return (number)0;
   }
-  return npInversM(c);
-}
-
-number npNeg (number c)
+  return npInversM(c,r);
+}
+
+number npNeg (number c, const coeffs r)
 {
   if ((long)c==0) return c;
-  return npNegM(c);
-}
-
-BOOLEAN npGreater (number a,number b)
+  return npNegM(c,r);
+}
+
+BOOLEAN npGreater (number a,number b, const coeffs r)
 {
   //return (long)a != (long)b;
@@ -213 +203 @@
 }
 
-BOOLEAN npEqual (number a,number b)
+BOOLEAN npEqual (number a,number b, const coeffs r)
 {
 //  return (long)a == (long)b;
-  return npEqualM(a,b);
-}
-
-void npWrite (number &a, const ring r)
+  return npEqualM(a,b,r);
+}
+
+void npWrite (number &a, const coeffs r)
 {
   if ((long)a>(((long)r->ch) >>1)) StringAppend("-%d",(int)(((long)r->ch)-((long)a)));
@@ -225 +215 @@
 }
 
-void npPower (number a, int i, number * result)
+void npPower (number a, int i, number * result, const coeffs r)
 {
   if (i==0)
@@ -238 +228 @@
   else
   {
-    npPower(a,i-1,result);
-    *result = npMultM(a,*result);
-  }
-}
-
-static const char* npEati(const char *s, int *i)
+    npPower(a,i-1,result,r);
+    *result = npMultM(a,*result,r);
+  }
+}
+
+static const char* npEati(const char *s, int *i, const coeffs r)
 {
 
@@ -253 +243 @@
       ii *= 10;
       ii += *s++ - '0';
-      if (ii >= (MAX_INT_VAL / 10)) ii = ii % npPrimeM;
+      if (ii >= (MAX_INT_VAL / 10)) ii = ii % r->npPrimeM;
     }
     while (((*s) >= '0') && ((*s) <= '9'));
-    if (ii >= npPrimeM) ii = ii % npPrimeM;
+    if (ii >= npPrimeM) ii = ii % r->npPrimeM;
     *i=(int)ii;
   }
@@ -263 +253 @@
 }
 
-const char * npRead (const char *s, number *a)
+const char * npRead (const char *s, number *a, const coeffs r)
 {
   int z;
   int n=1;
 
-  s = npEati(s, &z);
+  s = npEati(s, &z, r);
   if ((*s) == '/')
   {
     s++;
-    s = npEati(s, &n);
+    s = npEati(s, &n, r);
   }
   if (n == 1)
@@ -282 +272 @@
     {
 #ifdef NV_OPS
-      if (npPrimeM>NV_MAX_PRIME)
-        *a = nvDiv((number)z,(number)n);
+      if (r->npPrimeM>NV_MAX_PRIME)
+        *a = nvDiv((number)z,(number)n,r);
       else
 #endif
-        *a = npDiv((number)z,(number)n);
+        *a = npDiv((number)z,(number)n,r);
     }
   }
   return s;
 }
-
-/*2
-* the last used charcteristic
-*/
-//int npGetChar()
-//{
-//  return npPrimeM;
-//}
 
 /*2
@@ -304 +286 @@
 */
 
-void npSetChar(int c, ring r)
+void npSetChar(int c, coeffs r)
 {
 
@@ -310 +292 @@
   if ((c>1) || (c<(-1)))
   {
-    if (c>1) npPrimeM = c;
-    else     npPrimeM = -c;
-    npPminus1M = npPrimeM - 1;
+    if (c>1) r->npPrimeM = c;
+    else     r->npPrimeM = -c;
+    r->npPminus1M = r->npPrimeM - 1;
 #ifdef NV_OPS
-    if (r->cf->npPrimeM >NV_MAX_PRIME) return;
-#endif
-#ifdef HAVE_DIV_MOD
-    npInvTable=r->cf->npInvTable;
+    if (r->npPrimeM >NV_MAX_PRIME) return;
 #endif
 #if !defined(HAVE_DIV_MOD) || !defined(HAVE_MULT_MOD)
-    npExpTable=r->cf->npExpTable;
-    npLogTable=r->cf->npLogTable;
     npGen = npExpTable[1];
 #endif
   }
-  else
-  {
-    npPrimeM=0;
-#ifdef HAVE_DIV_MOD
-    npInvTable=NULL;
-#endif
-#if !defined(HAVE_DIV_MOD) || !defined(HAVE_MULT_MOD)
-    npExpTable=NULL;
-    npLogTable=NULL;
-#endif
-  }
-}
-
-void npInitChar(int c, ring r)
+}
+
+void npInitChar(int c, coeffs r)
 {
   int i, w;
@@ -344 +310 @@
   if ((c>1) || (c<(-1)))
   {
-    if (c>1) r->cf->npPrimeM = c;
-    else     r->cf->npPrimeM = -c;
-    r->cf->npPminus1M = r->cf->npPrimeM - 1;
+    if (c>1) r->npPrimeM = c;
+    else     r->npPrimeM = -c;
+    r->npPminus1M = r->npPrimeM - 1;
 #ifdef NV_OPS
-    if (r->cf->npPrimeM <=NV_MAX_PRIME)
+    if (r->npPrimeM <=NV_MAX_PRIME)
 #endif
     {
 #if !defined(HAVE_DIV_MOD) || !defined(HAVE_MULT_MOD)
-      r->cf->npExpTable=(unsigned short *)omAlloc( r->cf->npPrimeM*sizeof(unsigned short) );
-      r->cf->npLogTable=(unsigned short *)omAlloc( r->cf->npPrimeM*sizeof(unsigned short) );
-      r->cf->npExpTable[0] = 1;
-      r->cf->npLogTable[0] = 0;
-      if (r->cf->npPrimeM > 2)
+      r->npExpTable=(unsigned short *)omAlloc( r->npPrimeM*sizeof(unsigned short) );
+      r->npLogTable=(unsigned short *)omAlloc( r->npPrimeM*sizeof(unsigned short) );
+      r->npExpTable[0] = 1;
+      r->npLogTable[0] = 0;
+      if (r->npPrimeM > 2)
       {
         w = 1;
         loop
         {
-          r->cf->npLogTable[1] = 0;
+          r->npLogTable[1] = 0;
           w++;
           i = 0;
@@ -367 +333 @@
           {
             i++;
-            r->cf->npExpTable[i] =(int)(((long)w * (long)r->cf->npExpTable[i-1])
-                                 % r->cf->npPrimeM);
-            r->cf->npLogTable[r->cf->npExpTable[i]] = i;
-            if (/*(i == npPrimeM - 1 ) ||*/ (r->cf->npExpTable[i] == 1))
+            r->npExpTable[i] =(int)(((long)w * (long)r->npExpTable[i-1])
+                                 % r->npPrimeM);
+            r->npLogTable[r->npExpTable[i]] = i;
+            if (/*(i == npPrimeM - 1 ) ||*/ (r->npExpTable[i] == 1))
               break;
           }
-          if (i == r->cf->npPrimeM - 1)
+          if (i == r->npPrimeM - 1)
             break;
         }
@@ -379 +345 @@
       else
       {
-        r->cf->npExpTable[1] = 1;
-        r->cf->npLogTable[1] = 0;
+        r->npExpTable[1] = 1;
+        r->npLogTable[1] = 0;
       }
 #endif
 #ifdef HAVE_DIV_MOD
-      r->cf->npInvTable=(unsigned short*)omAlloc0( r->cf->npPrimeM*sizeof(unsigned short) );
+      r->npInvTable=(unsigned short*)omAlloc0( r->npPrimeM*sizeof(unsigned short) );
 #endif
     }
@@ -395 +361 @@
 
 #ifdef LDEBUG
-BOOLEAN npDBTest (number a, const char *f, const int l)
-{
-  if (((long)a<0) || ((long)a>npPrimeM))
+BOOLEAN npDBTest (number a, const coeffs r, const char *f, const int l)
+{
+  if (((long)a<0) || ((long)a>r->npPrimeM))
   {
     Print("wrong mod p number %ld at %s,%d\n",(long)a,f,l);
@@ -406 +372 @@
 #endif
 
-number npMap0(number from)
-{
-  return npInit(nlModP(from,npPrimeM),currRing);
-}
-
-number npMapP(number from)
+number npMap0(number from, const coeffs dst_r)
+{
+  return npInit(nlModP(from,dst_r->npPrimeM),dst_r);
+}
+
+number npMapP(number from, const coeffs dst_r)
 {
   long i = (long)from;
@@ -417 +383 @@
   {
     i-=npMapPrime;
-    while (i < 0) i+=npPrimeM;
-  }
-  i%=npPrimeM;
+    while (i < 0) i+=dst_r->npPrimeM;
+  }
+  i%=dst_r->npPrimeM;
   return (number)i;
 }
 
-static number npMapLongR(number from)
+static number npMapLongR(number from, const coeffs dst_r)
 {
   gmp_float *ff=(gmp_float*)from;
@@ -436 +402 @@
   size = (*f)[0]._mp_size;
   if (size == 0)
-    return npInit(0,currRing);
+    return npInit(0,dst_r);
   if(size<0)
     size = -size;
@@ -447 +413 @@
   }
 
-  if(npPrimeM>2)
+  if(dst_r->npPrimeM>2)
     e=(*f)[0]._mp_exp-size;
   else
@@ -490 +456 @@
   if(res->s==0)
     iz=(long)npDiv((number)iz,(number)in);
-  FREE_RNUMBER(res);
+  omFreeBin((void *)res, rnumber_bin);
   return (number)iz;
 }
@@ -507 +473 @@
 
   mpz_clear(erg);
-  omFree((ADDRESS) erg);
+  omFree((void *) erg);
   return (number) r;
 }
@@ -521 +487 @@
 #endif
 
-nMapFunc npSetMap(const ring src, const ring dst)
+nMapFunc npSetMap(const coeffs src, const coeffs dst)
 {
 #ifdef HAVE_RINGS
-  if (rField_is_Ring_2toM(src))
+  if (nField_is_Ring_2toM(src))
   {
     return npMapMachineInt;
   }
-  if (rField_is_Ring_Z(src) || rField_is_Ring_PtoM(src) || rField_is_Ring_ModN(src))
+  if (nField_is_Ring_Z(src) || nField_is_Ring_PtoM(src) || nField_is_Ring_ModN(src))
   {
     return npMapGMP;
   }
 #endif
-  if (rField_is_Q(src))
+  if (nField_is_Q(src))
   {
     return npMap0;
   }
-  if ( rField_is_Zp(src) )
-  {
-    if (rChar(src) == rChar(dst))
+  if ( nField_is_Zp(src) )
+  {
+    if (n_GetChar(src) == n_GetChar(dst))
     {
       return ndCopy;
@@ -545 +511 @@
     else
     {
-      npMapPrime=rChar(src);
+      npMapPrime=n_GetChar(src);
       return npMapP;
     }
   }
-  if (rField_is_long_R(src))
+  if (nField_is_long_R(src))
   {
     return npMapLongR;
@@ -561 +527 @@
 #ifdef NV_OPS
 
-number nvMult (number a,number b)
+number nvMult (number a,number b, const coeffs r)
 {
   //if (((long)a == 0) || ((long)b == 0))
@@ -584 +550 @@
    u1=1; v1=0;
    u2=0; v2=1;
-   u = a; v = npPrimeM;
+   u = a; v = R->npPrimeM;
 
    while (v != 0)
@@ -603 +569 @@
    //t = v1;
    if (s < 0)
-      return s + npPrimeM;
+      return s + R->npPrimeM;
    else
       return s;
 }
 
-static inline number nvInversM (number c)
-{
-  long inv=nvInvMod((long)c);
+inline number nvInversM (number c, const coeffs r)
+{
+  long inv=nvInvMod((long)c,r);
   return (number)inv;
 }
 
-number nvDiv (number a,number b)
+number nvDiv (number a,number b, const coeffs r)
 {
   if ((long)a==0)
@@ -625 +591 @@
   else
   {
-    number inv=nvInversM(b);
-    return nvMultM(a,inv);
-  }
-}
-number  nvInvers (number c)
+    number inv=nvInversM(b,r);
+    return nvMultM(a,inv,r);
+  }
+}
+number  nvInvers (number c, const coeffs r)
 {
   if ((long)c==0)
@@ -636 +602 @@
     return (number)0;
   }
-  return nvInversM(c);
-}
-void nvPower (number a, int i, number * result)
+  return nvInversM(c,r);
+}
+void nvPower (number a, int i, number * result, const coeffs r)
 {
   if (i==0)
@@ -651 +617 @@
   else
   {
-    nvPower(a,i-1,result);
-    *result = nvMultM(a,*result);
-  }
-}
-#endif
+    nvPower(a,i-1,result,r);
+    *result = nvMultM(a,*result,r);
+  }
+}
+#endif

coeffs/modulop.h

@@ -8 +8 @@
 * ABSTRACT: numbers modulo p (<=32003)
 */
-#include <kernel/structs.h>
+#include "coeffs.h"
 
 // defines are in struct.h
@@ -22 +22 @@
 #define NV_MAX_PRIME 32003
 
-extern long npPrimeM;
 extern int npGen;
 extern long npMapPrime;
 
-BOOLEAN npGreaterZero (number k);
-number  npMult        (number a, number b);
-number  npInit        (int i, const ring r);
-int     npInt         (number &n, const ring r);
-number  npAdd         (number a, number b);
-number  npSub         (number a, number b);
-void    npPower       (number a, int i, number * result);
-BOOLEAN npIsZero      (number a);
-BOOLEAN npIsOne       (number a);
-BOOLEAN npIsMOne       (number a);
-number  npDiv         (number a, number b);
-number  npNeg         (number c);
-number  npInvers      (number c);
-BOOLEAN npGreater     (number a, number b);
-BOOLEAN npEqual       (number a, number b);
-void    npWrite       (number &a, const ring r);
-const char *  npRead  (const char *s, number *a);
+BOOLEAN npGreaterZero (number k, const coeffs r);
+number  npMult        (number a, number b, const coeffs r);
+number  npInit        (int i, const coeffs r);
+int     npInt         (number &n, const coeffs r);
+number  npAdd         (number a, number b,const coeffs r);
+number  npSub         (number a, number b,const coeffs r);
+void    npPower       (number a, int i, number * result,const coeffs r);
+BOOLEAN npIsZero      (number a,const coeffs r);
+BOOLEAN npIsOne       (number a,const coeffs r);
+BOOLEAN npIsMOne       (number a,const coeffs r);
+number  npDiv         (number a, number b,const coeffs r);
+number  npNeg         (number c,const coeffs r);
+number  npInvers      (number c,const coeffs r);
+BOOLEAN npGreater     (number a, number b,const coeffs r);
+BOOLEAN npEqual       (number a, number b,const coeffs r);
+void    npWrite       (number &a, const coeffs r);
+const char *  npRead  (const char *s, number *a,const coeffs r);
 #ifdef LDEBUG
-BOOLEAN npDBTest      (number a, const char *f, const int l);
-#define npTest(A)     npDBTest(A,__FILE__,__LINE__)
+BOOLEAN npDBTest      (number a,const coeffs r, const char *f, const int l);
+#define npTest(A,r)     npDBTest(A,r,__FILE__,__LINE__)
 #else
-#define npTest(A)     (0)
+#define npTest(A,r)     (0)
 #endif
-void    npSetChar(int c, ring r);
-void    npInitChar(int c, ring r);
+void    npSetChar(int c, coeffs r);
+void    npInitChar(int c, coeffs r);
 
 //int     npGetChar();
 
-nMapFunc npSetMap(const ring src, const ring dst);
-number  npMapP(number from);
-number  npMap0(number from);
+nMapFunc npSetMap(const coeffs src, const coeffs dst);
+number  npMapP(number from, const coeffs r);
+number  npMap0(number from, const coeffs r);
 /*-------specials for spolys, do NOT use otherwise--------------------------*/
 /* for npMultM, npSubM, npNegM, npEqualM : */
@@ -86 +85 @@
 #endif
 #ifdef HAVE_MULT_MOD
-static inline number npMultM(number a, number b)
+static inline number npMultM(number a, number b, const coeffs r)
 {
   return (number) 
-    ((((unsigned long) a)*((unsigned long) b)) % ((unsigned long) npPrimeM));
+    ((((unsigned long) a)*((unsigned long) b)) % ((unsigned long) r->npPrimeM));
 }
 #else
-static inline number npMultM(number a, number b)
+static inline number npMultM(number a, number b, const coeffs r)
 {
-  long x = (long)npLogTable[(long)a]+npLogTable[(long)b];
-  return (number)(long)npExpTable[x<npPminus1M ? x : x-npPminus1M];
+  long x = (long)r->npLogTable[(long)a]+ r->npLogTable[(long)b];
+  return (number)(long)r->npExpTable[x<r->npPminus1M ? x : x- r->npPminus1M];
 }
 #endif
@@ -120 +119 @@
 #endif
 #ifdef HAVE_GENERIC_ADD
-static inline number npAddM(number a, number b)
+static inline number npAddM(number a, number b, const coeffs r)
 {
-  long r = (long)a + (long)b;
-  return (number)(r >= npPrimeM ? r - npPrimeM : r);
+  long R = (long)a + (long)b;
+  return (number)(R >= r->npPrimeM ? R - r->npPrimeM : R);
 }
-static inline number npSubM(number a, number b)
+static inline number npSubM(number a, number b, const coeffs r)
 {
   return (number)((long)a<(long)b ?
-                       npPrimeM-(long)b+(long)a : (long)a-(long)b);
+                       r->npPrimeM-(long)b+(long)a : (long)a-(long)b);
 }
 #else
-static inline number npAddM(number a, number b)
+static inline number npAddM(number a, number b, const coeffs r)
 {
    long res = ((long)a + (long)b);
-   res -= npPrimeM;
+   res -= r->npPrimeM;
 #if SIZEOF_LONG == 8
-   res += (res >> 63) & npPrimeM;
+   res += (res >> 63) & r->npPrimeM;
 #else
-   res += (res >> 31) & npPrimeM;
+   res += (res >> 31) & r->npPrimeM;
 #endif
    return (number)res;
 }
-static inline number npSubM(number a, number b)
+static inline number npSubM(number a, number b, const coeffs r)
 {
    long res = ((long)a - (long)b);
 #if SIZEOF_LONG == 8
-   res += (res >> 63) & npPrimeM;
+   res += (res >> 63) & r->npPrimeM;
 #else
-   res += (res >> 31) & npPrimeM;
+   res += (res >> 31) & r->npPrimeM;
 #endif
    return (number)res;
@@ -154 +153 @@
 #endif
 
-static inline BOOLEAN npIsZeroM (number  a)
+static inline BOOLEAN npIsZeroM (number  a, const coeffs r)
 {
   return 0 == (long)a;
@@ -166 +165 @@
 */
 
-#define npNegM(A)      (number)(npPrimeM-(long)(A))
-#define npEqualM(A,B)  ((A)==(B))
+#define npNegM(A,r)      (number)(r->npPrimeM-(long)(A))
+#define npEqualM(A,B,r)  ((A)==(B))
 
 
 #ifdef NV_OPS
-static inline number nvMultM(number a, number b)
+static inline number nvMultM(number a, number b, const coeffs r)
 {
 #if SIZEOF_LONG == 4
@@ -179 +178 @@
 #endif
   return (number) 
-    (unsigned long)((ULONG64 a)*(ULONG64 b) % (ULONG64 npPrimeM));
+    (unsigned long)((ULONG64 a)*(ULONG64 b) % (ULONG64 r->npPrimeM));
 }
-number  nvMult        (number a, number b);
-number  nvDiv         (number a, number b);
-number  nvInvers      (number c);
-void    nvPower       (number a, int i, number * result);
-void    nvInpMult     (number &a, number b, const ring r);
+number  nvMult        (number a, number b, const coeffs r);
+number  nvDiv         (number a, number b, const coeffs r);
+number  nvInvers      (number c, const coeffs r);
+void    nvPower       (number a, int i, number * result, const coeffs r);
 #endif
 

coeffs/mpr_base.cc

@@ -429 +429 @@
   for ( i= 0; i <= max; i++ )
   {
-    omFreeSize( (ADDRESS) points[i]->point, fdim * sizeof(Coord_t) );
-    omFreeSize( (ADDRESS) points[i], sizeof(onePoint) );
-  }
-  omFreeSize( (ADDRESS) points, (max+1) * sizeof(onePointP) );
+    omFreeSize( (void *) points[i]->point, fdim * sizeof(Coord_t) );
+    omFreeSize( (void *) points[i], sizeof(onePoint) );
+  }
+  omFreeSize( (void *) points, (max+1) * sizeof(onePointP) );
 }
 
@@ -573 +573 @@
     pIter( piter );
   }
-  omFreeSize( (ADDRESS) vert, (dim+1) * sizeof(int) );
+  omFreeSize( (void *) vert, (dim+1) * sizeof(int) );
 }
 
@@ -591 +591 @@
     if ( j > dim ) break;
   }
-  omFreeSize( (ADDRESS) vert, (dim+1) * sizeof(int) );
+  omFreeSize( (void *) vert, (dim+1) * sizeof(int) );
 
   if ( i > num ) return 0;
@@ -712 +712 @@
   lifted= true;
 
-  if ( !outerL ) omFreeSize( (ADDRESS) l, (dim+1) * sizeof(int) );
+  if ( !outerL ) omFreeSize( (void *) l, (dim+1) * sizeof(int) );
 }
 //<-
@@ -811 +811 @@
   } // i
 
-  omFreeSize( (ADDRESS) vert, (idelem+1) * sizeof(int) );
+  omFreeSize( (void *) vert, (idelem+1) * sizeof(int) );
 
 #ifdef mprDEBUG_PROT
@@ -875 +875 @@
   } // i
 
-  omFreeSize( (ADDRESS) vert, (idelem+1) * sizeof(int) );
+  omFreeSize( (void *) vert, (idelem+1) * sizeof(int) );
 
 #ifdef mprDEBUG_PROT
@@ -1399 +1399 @@
 
   // clean up
-  omFreeSize( (ADDRESS) optSum, (LP->m) * sizeof(struct setID) );
+  omFreeSize( (void *) optSum, (LP->m) * sizeof(struct setID) );
 
   mprSTICKYPROT(ST_SPARSE_RC);
@@ -1479 +1479 @@
 
   pDelete( &epp );
-  omFreeSize( (ADDRESS) epp_mon, (n+2) * sizeof(int) );
-  omFreeSize( (ADDRESS) eexp, (pVariables+1)*sizeof(int));
+  omFreeSize( (void *) epp_mon, (n+2) * sizeof(int) );
+  omFreeSize( (void *) eexp, (pVariables+1)*sizeof(int));
 
 #ifdef mprDEBUG_ALL
@@ -1542 +1542 @@
   }
 
-  omFreeSize( (ADDRESS) vert.point, (pVariables+2) * sizeof(Coord_t) );
+  omFreeSize( (void *) vert.point, (pVariables+2) * sizeof(Coord_t) );
 
   return vs;
@@ -1717 +1717 @@
     delete Qi[i];
   }
-  omFreeSize( (ADDRESS) Qi, idelem * sizeof(pointSet*) );
+  omFreeSize( (void *) Qi, idelem * sizeof(pointSet*) );
 
   delete E;
@@ -2097 +2097 @@
     }
     // OB: ????? (solve_s.tst)
-    omfreeSize( (ADDRESS)resVectorList[i].numColVector,
+    omfreeSize( (void *)resVectorList[i].numColVector,
                 numVectors * sizeof( number ) );
-    omfreeSize( (ADDRESS)resVectorList[i].numColParNr,
+    omfreeSize( (void *)resVectorList[i].numColParNr,
                 (pVariables+1) * sizeof(int) );
   }
 
-  omFreeSize( (ADDRESS)resVectorList, veclistmax*sizeof( resVector ) );
+  omFreeSize( (void *)resVectorList, veclistmax*sizeof( resVector ) );
 
   // free matrix m
@@ -3055 +3055 @@
   // free some stuff: pev, presult
   for ( i=0; i < n; i++ ) nDelete( pev + i );
-  omFreeSize( (ADDRESS)pev, n * sizeof( number ) );
+  omFreeSize( (void *)pev, n * sizeof( number ) );
 
   for ( i=0; i <= tdg; i++ ) nDelete( presults+i );
-  omFreeSize( (ADDRESS)presults, (tdg + 1) * sizeof( number ) );
+  omFreeSize( (void *)presults, (tdg + 1) * sizeof( number ) );
 
   return roots;
@@ -3172 +3172 @@
   // free some stuff: pev, presult
   for ( i=0; i < n; i++ ) nDelete( pevpoint + i );
-  omFreeSize( (ADDRESS)pevpoint, n * sizeof( number ) );
+  omFreeSize( (void *)pevpoint, n * sizeof( number ) );
 
   return roots;

coeffs/mpr_complex.cc

@@ -598 +598 @@
   && (strlen(in)-(in[0]=='-'?1:0) == oprec) )
   {
-    omFree( (ADDRESS) in );
+    omFree( (void *) in );
     insize= (exponent+oprec+2) * sizeof(char) + 10;
     in= (char*)omAlloc( insize );
@@ -605 +605 @@
   }
   nout= nicifyFloatStr( in, exponent, oprec, &size, SIGN_EMPTY );
-  omFree( (ADDRESS) in );
+  omFree( (void *) in );
   out= (char*)omAlloc( (strlen(nout)+1) * sizeof(char) );
   strcpy( out, nout );
-  omFree( (ADDRESS) nout );
+  omFree( (void *) nout );
 
   return out;
@@ -740 +740 @@
         sprintf(out,"(%s%s)",c.imag().sign()>=0?"I*":"-I*",in_imag);
     }
-    omFree( (ADDRESS) in_real );
-    omFree( (ADDRESS) in_imag );
+    omFree( (void *) in_real );
+    omFree( (void *) in_imag );
   }
   else

coeffs/mpr_complex.h

@@ -14 +14 @@
 //-> include & define stuff
 // must have gmp version >= 2
-#include <kernel/si_gmp.h>
-#include <kernel/numbers.h>
-#include <kernel/ring.h>
-#include <kernel/mpr_global.h>
+#include "si_gmp.h"
+#include "numbers.h"
+#include "mpr_global.h"
 
 #define ZTOF 1
@@ -302 +301 @@
 gmp_complex sqrt( const gmp_complex & x );
 
-inline gmp_complex numberToComplex( number num )
-{
-  if (rField_is_long_C()) {
+inline gmp_complex numberToComplex( number num, const coeffs r )
+{
+  if (nField_is_long_C(r))
+  {
     return *(gmp_complex*)num;
-  } else {
+  }
+  else
+  {
     return gmp_complex( numberToFloat(num) );
   }

coeffs/mpr_numeric.cc

@@ -55 +55 @@
   int j;
   for ( j= 0; j < cn; j++ ) nDelete( x+j );
-  omFreeSize( (ADDRESS)x, cn * sizeof( number ) );
+  omFreeSize( (void *)x, cn * sizeof( number ) );
 }
 
@@ -145 +145 @@
   }
 
-  omFreeSize( (ADDRESS) exp, (n+1) * sizeof(int) );
+  omFreeSize( (void *) exp, (n+1) * sizeof(int) );
 
   pSortAdd(pit);
@@ -242 +242 @@
   // free mem
   for ( j= 0; j < cn; j++ ) nDelete( c+j );
-  omFreeSize( (ADDRESS)c, cn * sizeof( number ) );
+  omFreeSize( (void *)c, cn * sizeof( number ) );
 
   nDelete( &tmp1 );
@@ -289 +289 @@
   {
     for ( i=0; i < anz+2; i++ ) nDelete( ievpoint + i );
-    omFreeSize( (ADDRESS)ievpoint, (anz+2) * sizeof( number ) );
+    omFreeSize( (void *)ievpoint, (anz+2) * sizeof( number ) );
   }
 
   for ( i=0; i <= tdg; i++ ) nDelete( coeffs + i );
-  omFreeSize( (ADDRESS)coeffs, (tdg+1) * sizeof( number ) );
+  omFreeSize( (void *)coeffs, (tdg+1) * sizeof( number ) );
 
   // theroots löschen
   for ( i=0; i < tdg; i++ ) delete theroots[i];
-  omFreeSize( (ADDRESS) theroots, (tdg)*sizeof(gmp_complex*) );
+  omFreeSize( (void *) theroots, (tdg)*sizeof(gmp_complex*) );
 
   //mprPROTnl("~rootContainer()");
@@ -464 +464 @@
   // free memory
   for ( i=0; i <= tdg; i++ ) delete ad[i];
-  omFreeSize( (ADDRESS) ad, (tdg+1)*sizeof(gmp_complex*) );
+  omFreeSize( (void *) ad, (tdg+1)*sizeof(gmp_complex*) );
 
   return found_roots;
@@ -547 +547 @@
   mprSTICKYPROT("\n");
   for ( i=0; i <= tdg; i++ ) delete ad[i];
-  omFreeSize( (ADDRESS) ad, (tdg+1)*sizeof( gmp_complex* ));
+  omFreeSize( (void *) ad, (tdg+1)*sizeof( gmp_complex* ));
 
   return ret;
@@ -1007 +1007 @@
   for( i= 0; i < LiPM_rows; i++ )
   {
-    omFreeSize( (ADDRESS) LiPM[i], LiPM_cols * sizeof(mprfloat) );
-  }
-  omFreeSize( (ADDRESS) LiPM, LiPM_rows * sizeof(mprfloat *) );
-
-  omFreeSize( (ADDRESS) iposv, 2*LiPM_rows*sizeof(int) );
-  omFreeSize( (ADDRESS) izrov, 2*LiPM_rows*sizeof(int) );
+    omFreeSize( (void *) LiPM[i], LiPM_cols * sizeof(mprfloat) );
+  }
+  omFreeSize( (void *) LiPM, LiPM_rows * sizeof(mprfloat *) );
+
+  omFreeSize( (void *) iposv, 2*LiPM_rows*sizeof(int) );
+  omFreeSize( (void *) izrov, 2*LiPM_rows*sizeof(int) );
 }
 
@@ -1129 +1129 @@
       icase=-2;
       // free mem l1,l2,l3;
-      omFreeSize( (ADDRESS) l3, (m+1) * sizeof(int) );
-      omFreeSize( (ADDRESS) l2, (m+1) * sizeof(int) );
-      omFreeSize( (ADDRESS) l1, (n+1) * sizeof(int) );
+      omFreeSize( (void *) l3, (m+1) * sizeof(int) );
+      omFreeSize( (void *) l2, (m+1) * sizeof(int) );
+      omFreeSize( (void *) l1, (n+1) * sizeof(int) );
       return;
     }
@@ -1156 +1156 @@
         icase= -1; // no solution found
         // free mem l1,l2,l3;
-        omFreeSize( (ADDRESS) l3, (m+1) * sizeof(int) );
-        omFreeSize( (ADDRESS) l2, (m+1) * sizeof(int) );
-        omFreeSize( (ADDRESS) l1, (n+1) * sizeof(int) );
+        omFreeSize( (void *) l3, (m+1) * sizeof(int) );
+        omFreeSize( (void *) l2, (m+1) * sizeof(int) );
+        omFreeSize( (void *) l1, (n+1) * sizeof(int) );
         return;
       }
@@ -1193 +1193 @@
         icase = -1; // no solution found
         // free mem l1,l2,l3;
-        omFreeSize( (ADDRESS) l3, (m+1) * sizeof(int) );
-        omFreeSize( (ADDRESS) l2, (m+1) * sizeof(int) );
-        omFreeSize( (ADDRESS) l1, (n+1) * sizeof(int) );
+        omFreeSize( (void *) l3, (m+1) * sizeof(int) );
+        omFreeSize( (void *) l2, (m+1) * sizeof(int) );
+        omFreeSize( (void *) l1, (n+1) * sizeof(int) );
         return;
       }
@@ -1241 +1241 @@
       icase=0; // finite solution found
       // free mem l1,l2,l3
-      omFreeSize( (ADDRESS) l3, (m+1) * sizeof(int) );
-      omFreeSize( (ADDRESS) l2, (m+1) * sizeof(int) );
-      omFreeSize( (ADDRESS) l1, (n+1) * sizeof(int) );
+      omFreeSize( (void *) l3, (m+1) * sizeof(int) );
+      omFreeSize( (void *) l2, (m+1) * sizeof(int) );
+      omFreeSize( (void *) l1, (n+1) * sizeof(int) );
       return;
     }
@@ -1255 +1255 @@
       icase=1;                /* unbounded */
       // free mem
-      omFreeSize( (ADDRESS) l3, (m+1) * sizeof(int) );
-      omFreeSize( (ADDRESS) l2, (m+1) * sizeof(int) );
-      omFreeSize( (ADDRESS) l1, (n+1) * sizeof(int) );
+      omFreeSize( (void *) l3, (m+1) * sizeof(int) );
+      omFreeSize( (void *) l2, (m+1) * sizeof(int) );
+      omFreeSize( (void *) l1, (n+1) * sizeof(int) );
       return;
     }

coeffs/numbers.cc

@@ -10 +10 @@
 #include <string.h>
 #include <stdlib.h>
-#include <kernel/mod2.h>
-#include <kernel/structs.h>
-#include <kernel/febase.h>
-#include <kernel/kstd1.h>
-#include <kernel/numbers.h>
-#include <kernel/longrat.h>
-#include <kernel/longalg.h>
-#include <kernel/longtrans.h>
-#include <kernel/modulop.h>
-#include <kernel/gnumpfl.h>
-#include <kernel/gnumpc.h>
-#include <kernel/ring.h>
-#include <kernel/ffields.h>
-#include <kernel/shortfl.h>
+#include "coeffs.h"
+#include "numbers.h"
+#include "longrat.h"
+#include "longalg.h"
+#include "modulop.h"
+#include "gnumpfl.h"
+#include "gnumpc.h"
+#include "ffields.h"
+#include "shortfl.h"
+#include "longtrans.h"
 #ifdef HAVE_RINGS
 #include <kernel/rmodulo2m.h>
@@ -35 +31 @@
 extern int IsPrime(int p);
 
-number  (*nInit_bigint)(number i);
-number (*nPar)(int i);
-int    (*nParDeg)(number n);
-int    (*nSize)(number n);
-int    (*n_Int)(number &n, const ring r);
-numberfunc nMult, nSub, nAdd, nDiv, nIntDiv, nIntMod, nExactDiv;
-number (*nNeg)(number a);
-number (*nInvers)(number a);
-void   (*nNormalize)(number &a);
-number (*nCopy)(number a);
-number (*nRePart)(number a);
-number (*nImPart)(number a);
-#ifdef HAVE_RINGS
-BOOLEAN (*nDivBy)(number a,number b);
-int     (*nDivComp)(number a,number b);
-BOOLEAN (*nIsUnit)(number a);
-number  (*nGetUnit)(number a);
-number  (*nExtGcd)(number a, number b, number *s, number *t);
-#endif
-BOOLEAN (*nGreater)(number a,number b);
-BOOLEAN (*nEqual)(number a,number b);
-BOOLEAN (*nIsZero)(number a);
-BOOLEAN (*nIsOne)(number a);
-BOOLEAN (*nIsMOne)(number a);
-BOOLEAN (*nGreaterZero)(number a);
-const char* (*nRead)(const char *s,number *a);
-void    (*nPower)(number a, int i, number * result);
-number  (*nGcd)(number a, number b, const ring r);
-number  (*nLcm)(number a, number b, const ring r);
-char * (*nName)(number n);
-
 /*0 implementation*/
 number nNULL; /* the 0 as constant */
@@ -72 +37 @@
 
 void   nNew(number* d) { *d=NULL; }
-void   ndDelete(number* d, const ring r) { *d=NULL; }
-void   ndInpMult(number &a, number b, const ring r)
+void   ndDelete(number* d, const coeffs r) { *d=NULL; }
+void   ndInpMult(number &a, number b, const coeffs r)
 {
   number n=n_Mult(a,b,r);
@@ -79 +44 @@
   a=n;
 }
-number ndInpAdd(number &a, number b, const ring r)
+number ndInpAdd(number &a, number b, const coeffs r)
 {
   number n=n_Add(a,b,r);
@@ -95 +60 @@
 #endif
 
-void   nDummy2(number& d) { }
-
-char * ndName(number n) { return NULL; }
-
-number ndPar(int i) { return nInit(0); }
-
-number ndReturn0(number n) { return nInit(0); }
-
-int    ndParDeg(number n) { return 0; }
-
-number ndGcd(number a, number b, const ring r) { return n_Init(1,r); }
-
-number ndIntMod(number a, number b) { return nInit(0); }
-
-number ndGetDenom(number &n, const ring r) { return n_Init(1,r); }
-number ndGetNumerator(number &a,const ring r) { return r->cf->nCopy(a); }
-
-int ndSize(number a) { return (int)nIsZero(a)==FALSE; }
+void   nDummy2(number& d, const coeffs r) { }
+
+char * ndName(number n, const coeffs r) { return NULL; }
+
+number ndPar(int i, const coeffs r) { return n_Init(0,r); }
+
+number ndReturn0(number n, const coeffs r) { return n_Init(0,r); }
+
+int    ndParDeg(number n, const coeffs r) { return 0; }
+
+number ndGcd(number a, number b, const coeffs r) { return n_Init(1,r); }
+
+number ndIntMod(number a, number b, const coeffs r) { return n_Init(0,r); }
+
+number ndGetDenom(number &n, const coeffs r) { return n_Init(1,r); }
+number ndGetNumerator(number &a,const coeffs r) { return n_Copy(a,r); }
+
+int ndSize(number a, const coeffs r) { return (int)n_IsZero(a,r)==FALSE; }
 
 number ndCopy(number a) { return a; }
-number nd_Copy(number a,const ring r) { return r->cf->nCopy(a); }
+number nd_Copy(number a,const coeffs r) { return r->nCopy(a); }
 
 #ifdef HAVE_RINGS
@@ -128 +93 @@
 * init nDelete    for characteristic c (complete==FALSE)
 */
-void nSetChar(ring r)
+void nSetChar(coeffs r)
 {
   int c=rInternalChar(r);
 
   /*--------------------- Q -----------------*/
-  if (rField_is_Q(r))
-  {
-    nInit_bigint=nlCopy;
+  if (nField_is_Q(r))
+  {
+    r->nInit_bigint=nl_Copy;
   }
   /*--------------------- Q_a/ Zp_a -----------------*/
-  else if (rField_is_Extension(r))
-  {
+  else if (nField_is_Extension(r))
+  {
+    if (r->minpoly != NULL)
+    {
       naSetChar(c,r);
-      if (rField_is_Q_a()) nInit_bigint=naMap00;
-      if (rField_is_Zp_a()) nInit_bigint=naMap0P;
+      if (rField_is_Q_a(r)) r->nInit_bigint=naMap00;
+      if (rField_is_Zp_a(r)) r->nInit_bigint=naMap0P;
+    }
+    else
+    {
+      ntSetChar(c,r);
+      if (rField_is_Q_a(r)) r->nInit_bigint=ntMap00;
+      if (rField_is_Zp_a(r)) r->nInit_bigint=ntMap0P;
+    }
   }
 #ifdef HAVE_RINGS
   /*----------------------ring Z / 2^m----------------*/
-  else if (rField_is_Ring_2toM(r))
+  else if (nField_is_Ring_2toM(r))
   {
     nr2mSetExp(c, r);
-    nInit_bigint=nr2mMapQ;
+    r->nInit_bigint=nr2mMapQ;
   }
   /*----------------------ring Z ----------------*/
-  else if (rField_is_Ring_Z(r))
+  else if (nField_is_Ring_Z(r))
   {
     nrzSetExp(c, r);
-    nInit_bigint=nrzMapQ;
+    r->nInit_bigint=nrzMapQ;
   }
   /*----------------------ring Z / n----------------*/
-  else if (rField_is_Ring_ModN(r))
+  else if (nField_is_Ring_ModN(r))
   {
     nrnSetExp(c, r);
-    nInit_bigint=nrnMapQ;
+    r->nInit_bigint=nrnMapQ;
   }
   /*----------------------ring Z / n----------------*/
-  else if (rField_is_Ring_PtoM(r))
+  else if (nField_is_Ring_PtoM(r))
   {
     nrnSetExp(c, r);
-    nInit_bigint=nrnMapQ;
-  }
-#endif
-  else if (rField_is_Zp(r))
+    r->nInit_bigint=nrnMapQ;
+  }
+#endif
+  else if (nField_is_Zp(r))
   /*----------------------char. p----------------*/
   {
     npSetChar(c, r);
-    nInit_bigint=npMap0;
+    r->nInit_bigint=npMap0;
   }
   /* -------------- GF(p^m) -----------------------*/
-  else if (rField_is_GF(r))
+  else if (nField_is_GF(r))
   {
     nfSetChar(c,r->parameter);
-    nInit_bigint=ndReturn0; // not impl.
+    r->nInit_bigint=ndReturn0; // not impl.
   }
   /* -------------- R -----------------------*/
   //if (c==(-1))
-  else if (rField_is_R(r))
-  {
-    nInit_bigint=nrMapQ;
+  else if (nField_is_R(r))
+  {
+    r->nInit_bigint=nrMapQ;
   }
   /* -------------- long R -----------------------*/
   /* -------------- long C -----------------------*/
-  else if ((rField_is_long_R(r))
-  || (rField_is_long_C(r)))
+  else if ((nField_is_long_R(r))
+  || (nField_is_long_C(r)))
   {
     setGMPFloatDigits(r->float_len,r->float_len2);
-    if (rField_is_long_R(r)) nInit_bigint=ngfMapQ;
-    else                     nInit_bigint=ngcMapQ;
+    if (nField_is_long_R(r)) r->nInit_bigint=ngfMapQ;
+    else                     r->nInit_bigint=ngcMapQ;
   }
 #ifdef TEST
   /* -------------- R -----------------------*/
   //if (c==(-1))
-  else if (!rField_is_R(r) && !rField_is_Q(r))
+  else if (!nField_is_R(r) && !nField_is_Q(r))
   {
     WerrorS("unknown field");
   }
 #endif
-  nNormalize=r->cf->nNormalize;
-  nPar   = r->cf->nPar;
-  nParDeg= r->cf->nParDeg;
-  n_Int  = r->cf->n_Int;
-  nAdd   = r->cf->nAdd;
-  nSub   = r->cf->nSub;
-  nMult  = r->cf->nMult;
-  nDiv   = r->cf->nDiv;
-  nExactDiv= r->cf->nExactDiv;
-  nIntDiv= r->cf->nIntDiv;
-  nIntMod= r->cf->nIntMod;
-  nNeg   = r->cf->nNeg;
-  nInvers= r->cf->nInvers;
-  nCopy  = r->cf->nCopy;
-#ifdef HAVE_RINGS
-  nDivComp  = r->cf->nDivComp;
-  nDivBy = r->cf->nDivBy;
-  nIsUnit = r->cf->nIsUnit;
-  nGetUnit = r->cf->nGetUnit;
-  nExtGcd = r->cf->nExtGcd;
-#endif
-  nGreater = r->cf->nGreater;
-  nEqual = r->cf->nEqual;
-  nIsZero = r->cf->nIsZero;
-  nIsOne = r->cf->nIsOne;
-  nIsMOne = r->cf->nIsMOne;
-  nGreaterZero = r->cf->nGreaterZero;
-  nRead = r->cf->nRead;
-  nPower = r->cf->nPower;
-  nGcd  = r->cf->nGcd;
-  nLcm  = r->cf->nLcm;
-  nName= r->cf->nName;
-  nSize  = r->cf->nSize;
-  nRePart = r->cf->nRePart;
-  nImPart = r->cf->nImPart;
-  nNULL=r->cf->nNULL;
 }
 
 /*2
-* init operations for ring r
+* init operations for coeffs r
 */
-void nInitChar(ring r)
+void nInitChar(coeffs r)
 {
-  int c=rInternalChar(r);
-
-  if (rField_is_Extension(r))
+  int c=nInternalChar(r);
+  n_coeffType t=nFieldType(r);
+
+  if (nField_is_Extension(r))
   {
     if (r->algring==NULL)
@@ -282 +221 @@
   {
     n->ref++;
-    r->cf=n;
+    r=n;
     return;
   }
@@ -290 +229 @@
     return;
   }
-  r->cf=n;
+  r=n;
   n->nChar = c;
   n->nPar  = ndPar;
@@ -313 +252 @@
   n->nGetUnit = (nMapFunc)NULL;
 #endif
-  if (rField_is_Extension(r))
+  if (nField_is_Extension(r))
   {
     //naInitChar(c,TRUE,r);
@@ -354 +293 @@
 #ifdef HAVE_RINGS
   /* -------------- Z/2^m ----------------------- */
-  else if (rField_is_Ring_2toM(r))
+  else if (nField_is_Ring_2toM(r))
   {
      nr2mInitExp(c,r);
@@ -393 +332 @@
   }
   /* -------------- Z/n ----------------------- */
-  else if (rField_is_Ring_ModN(r) || rField_is_Ring_PtoM(r)
+  else if (nField_is_Ring_ModN(r) || nField_is_Ring_PtoM(r)
   )
   {
@@ -436 +375 @@
   }
   /* -------------- Z ----------------------- */
-  else if (rField_is_Ring_Z(r))
+  else if (nField_is_Ring_Z(r))
   {
      n->cfInit  = nrzInit;
@@ -477 +416 @@
   }
 #endif
-  else if (rField_is_Q(r))
+  else if (nField_is_Q(r))
   {
     n->cfDelete= nlDelete;
@@ -513 +452 @@
 #endif
   }
-  else if (rField_is_Zp(r))
+  else if (nField_is_Zp(r))
   /*----------------------char. p----------------*/
   {
@@ -555 +494 @@
   }
   /* -------------- GF(p^m) -----------------------*/
-  else if (rField_is_GF(r))
+  else if (nField_is_GF(r))
   {
     //nfSetChar(c,r->parameter);
@@ -588 +527 @@
   /* -------------- R -----------------------*/
   //if (c==(-1))
-  else if (rField_is_R(r))
+  else if (nField_is_R(r))
   {
     n->cfInit = nrInit;
@@ -617 +556 @@
   }
   /* -------------- long R -----------------------*/
-  else if (rField_is_long_R(r))
+  else if (nField_is_long_R(r))
   {
     n->cfDelete= ngfDelete;
@@ -647 +586 @@
   }
   /* -------------- long C -----------------------*/
-  else if (rField_is_long_C(r))
+  else if (nField_is_long_C(r))
   {
     n->cfDelete= ngcDelete;
@@ -692 +631 @@
     n->nNULL=n->cfInit(0,r);
     if (n->nRePart==NULL)
-      n->nRePart=n->nCopy;
+      n->nRePart=n->cfCopy;
     if (n->nIntDiv==NULL)
       n->nIntDiv=n->nDiv;
@@ -698 +637 @@
 }
 
-void nKillChar(ring r)
+void nKillChar(coeffs r)
 {
   if (r!=NULL)
   {
-    if (r->cf!=NULL)
+    r->ref--;
+    if (r->ref<=0)
     {
-      r->cf->ref--;
-      if (r->cf->ref<=0)
+      n_Procs_s tmp;
+      n_Procs_s* n=&tmp;
+      tmp.next=cf_root;
+      while((n->next!=NULL) && (n->next!=r)) n=n->next;
+      if (n->next==r)
       {
-        n_Procs_s tmp;
-        n_Procs_s* n=&tmp;
-        tmp.next=cf_root;
-        while((n->next!=NULL) && (n->next!=r->cf)) n=n->next;
-        if (n->next==r->cf)
+        n->next=n->next->next;
+        if (cf_root==r) cf_root=n->next;
+        r->cfDelete(&(r->nNULL),r);
+        switch(r->type)
         {
-          n->next=n->next->next;
-          if (cf_root==r->cf) cf_root=n->next;
-          r->cf->cfDelete(&(r->cf->nNULL),r);
-          switch(r->cf->type)
-          {
-            case n_Zp:
-                 #ifdef HAVE_DIV_MOD
-                 if (r->cf->npInvTable!=NULL)
-                 omFreeSize( (ADDRESS)r->cf->npInvTable,
-                             r->cf->npPrimeM*sizeof(unsigned short) );
-                 #else
-                 if (r->cf->npExpTable!=NULL)
+          case n_Zp:
+               #ifdef HAVE_DIV_MOD
+               if (r->npInvTable!=NULL)
+               omFreeSize( (void *)r->npInvTable,
+                           r->npPrimeM*sizeof(unsigned short) );
+               #else
+               if (r->npExpTable!=NULL)
+               {
+                 omFreeSize( (void *)r->npExpTable,
+                             r->npPrimeM*sizeof(unsigned short) );
+                 omFreeSize( (void *)r->npLogTable,
+                             r->npPrimeM*sizeof(unsigned short) );
+               }
+               #endif
+               break;
+          case n_Zp_a:
+          case n_Q_a:
+               {
+                 number n=r->minpoly;
+                 if (n!=NULL)
                  {
-                   omFreeSize( (ADDRESS)r->cf->npExpTable,
-                               r->cf->npPrimeM*sizeof(unsigned short) );
-                   omFreeSize( (ADDRESS)r->cf->npLogTable,
-                               r->cf->npPrimeM*sizeof(unsigned short) );
+                   r->minpoly=NULL;
+                   naDelete(&n,r);
                  }
-                 #endif
-                 break;
-            case n_Zp_a:
-            case n_Q_a:
-                 {
-                   number n=r->minpoly;
-                   if (n!=NULL)
-                   {
-                     r->minpoly=NULL;
-                     if (r==currRing) naMinimalPoly=NULL;
-                     naDelete(&n,r);
-                   }
-                 }
-                 break;
+               }
+               break;
 
             default:
                  break;
           }
-          omFreeSize((ADDRESS)r->cf, sizeof(n_Procs_s));
-          r->cf=NULL;
+          omFreeSize((void *)r, sizeof(n_Procs_s));
+          r=NULL;
         }
         else
@@ -759 +695 @@
       r->cf=NULL;
     }
-    if (r->algring!=NULL)
-    {
-      rKill(r->algring);
-      r->algring=NULL;
-    }
+    //if (r->algring!=NULL)
+    //{
+    //  rKill(r->algring);
+    //  r->algring=NULL;
+    //}
   }
 }

coeffs/numbers.h

@@ -8 +8 @@
 * ABSTRACT: interface to coefficient aritmetics
 */
-#include <kernel/structs.h>
-
-#define n_Copy(n, r)          (r)->cf->cfCopy(n,r)
-#define n_Delete(n, r)        (r)->cf->cfDelete(n,r)
-#define n_Mult(n1, n2, r)     (r)->cf->nMult(n1, n2)
-#define n_Add(n1, n2, r)      (r)->cf->nAdd(n1, n2)
-#define n_IsZero(n, r)        (r)->cf->nIsZero(n)
-#define n_Equal(n1, n2, r)    (r)->cf->nEqual(n1, n2)
-#define n_Neg(n, r)           (r)->cf->nNeg(n)
-#define n_Sub(n1, n2, r)      (r)->cf->nSub(n1, n2)
-//#define n_GetChar(r)          ((r)->cf->nChar)
+#include "coeffs.h"
+
+#define SHORT_REAL_LENGTH 6 // use short reals for real <= 6 digits
+
+#define n_Copy(n, r)          (r)->cfCopy(n,r)
+#define n_Delete(n, r)        (r)->cfDelete(n,r)
+#define n_Mult(n1, n2, r)     (r)->nMult(n1, n2,r)
+#define n_Add(n1, n2, r)      (r)->nAdd(n1, n2,r)
+#define n_IsZero(n, r)        (r)->nIsZero(n,r)
+#define n_Equal(n1, n2, r)    (r)->nEqual(n1, n2,r)
+#define n_Neg(n, r)           (r)->nNeg(n,r)
+#define n_Sub(n1, n2, r)      (r)->nSub(n1, n2,r)
 #define n_GetChar(r)          ((r)->ch)
-#define n_Init(i, r)          (r)->cf->cfInit(i,r)
-#define n_IsOne(n, r)         (r)->cf->nIsOne(n)
-#define n_IsMOne(n, r)        (r)->cf->nIsMOne(n)
-#define n_GreaterZero(n, r)   (r)->cf->nGreaterZero(n)
-#define n_Write(n, r)         (r)->cf->cfWrite(n,r)
-#define n_Normalize(n, r)     (r)->cf->nNormalize(n)
-#define n_Gcd(a, b, r)        (r)->cf->nGcd(a,b,r)
-#define n_IntDiv(a, b, r)     (r)->cf->nIntDiv(a,b)
-#define n_Div(a, b, r)        (r)->cf->nDiv(a,b)
-#define n_Invers(a, r)     (r)->cf->nInvers(a)
-#define n_ExactDiv(a, b, r)   (r)->cf->nExactDiv(a,b)
-#define n_Test(a,r)           (r)->cf->nDBTest(a,__FILE__,__LINE__)
-
-#define n_InpMult(a, b, r)    (r)->cf->nInpMult(a,b,r)
-#define n_Power(a, b, res, r) (r)->cf->nPower(a,b,res)
-#define n_Size(n,r)           (r)->cf->nSize(n)
-#define n_GetDenom(N,r)       (r)->cf->cfGetDenom((N),r)
-#define n_GetNumerator(N,r)   (r)->cf->cfGetNumerator((N),r)
+#define n_Init(i, r)          (r)->cfInit(i,r)
+#define n_IsOne(n, r)         (r)->nIsOne(n,r)
+#define n_IsMOne(n, r)        (r)->nIsMOne(n,r)
+#define n_GreaterZero(n, r)   (r)->nGreaterZero(n,r)
+#define n_Write(n, r)         (r)->cfWrite(n,r)
+#define n_Normalize(n, r)     (r)->nNormalize(n,r)
+#define n_Gcd(a, b, r)        (r)->nGcd(a,b,r)
+#define n_IntDiv(a, b, r)     (r)->nIntDiv(a,b,r)
+#define n_Div(a, b, r)        (r)->nDiv(a,b,r)
+#define n_Invers(a, r)        (r)->nInvers(a,r)
+#define n_ExactDiv(a, b, r)   (r)->nExactDiv(a,b,r)
+#define n_Test(a,r)           (r)->nDBTest(a,r,__FILE__,__LINE__)
+
+#define n_InpMult(a, b, r)    (r)->nInpMult(a,b,r)
+#define n_Power(a, b, res, r) (r)->nPower(a,b,res,r)
+#define n_Size(n,r)           (r)->nSize(n,r)
+#define n_GetDenom(N,r)       (r)->cfGetDenom((N),r)
+#define n_GetNumerator(N,r)   (r)->cfGetNumerator((N),r)
 
 #define n_New(n, r)           nNew(n)
@@ -45 +46 @@
 
 /* prototypes */
-extern numberfunc nMult, nSub ,nAdd ,nDiv, nIntDiv, nIntMod, nExactDiv;
 void           nNew(number * a);
-extern number  (*nInit_bigint)(number i);
 #define        nInit(i) n_Init(i,currRing)
-extern number  (*nPar)(int i);
-extern int     (*nParDeg)(number n);
-/* size: a measure for the complexity of the represented number n;
-         zero should have size zero; larger size means more complex */
-extern int     (*nSize)(number n);
-extern int     (*n_Int)(number &n, const ring r);
-#ifdef HAVE_RINGS
-extern int     (*nDivComp)(number a,number b);
-extern BOOLEAN (*nIsUnit)(number a);
-extern number  (*nGetUnit)(number a);
-extern number  (*nExtGcd)(number a, number b, number *s, number *t);
-#endif
-// always use in the form    n=nNeg(n) !
-extern number  (*nNeg)(number a);
-extern number  (*nInvers)(number a);
-extern number  (*nCopy)(number a);
-extern number  (*nRePart)(number a);
-extern number  (*nImPart)(number a);
 #define nWrite(A) n_Write(A,currRing)
-extern const char *  (*nRead)(const char * s, number * a);
-extern void    (*nNormalize)(number &a);
-extern BOOLEAN (*nGreater)(number a,number b),
-#ifdef HAVE_RINGS
-               (*nDivBy)(number a,number b),
-#endif
-               (*nEqual)(number a,number b),
-               (*nIsZero)(number a),
-               (*nIsOne)(number a),
-               (*nIsMOne)(number a),
-               (*nGreaterZero)(number a);
-extern void    (*nPower)(number a, int i, number * result);
-extern number (*nGcd)(number a, number b, const ring r);
-extern number (*nLcm)(number a, number b, const ring r);
-
-extern number nNULL; /* the 0 as constant */
 
 #define nTest(a) (1)
@@ -91 +56 @@
 
 #define nSetMap(R) (currRing->cf->cfSetMap(R,currRing))
-extern char *  (*nName)(number n);
 
 void nDummy1(number* d);
-void ndDelete(number* d, const ring r);
+void ndDelete(number* d, const coeffs r);
 void nDummy2(number &d);
-number ndGcd(number a, number b, const ring);
-number ndCopy(number a);
-void   ndInpMult(number &a, number b, const ring r);
-number ndInpAdd(number &a, number b, const ring r);
+number ndGcd(number a, number b, const coeffs);
+number ndCopy(number a, const coeffs r);
+void   ndInpMult(number &a, number b, const coeffs r);
+number ndInpAdd(number &a, number b, const coeffs r);
 
 #ifdef LDEBUG
@@ -106 +70 @@
 #define nGetChar() n_GetChar(currRing)
 
-void nInitChar(ring r);
-void nKillChar(ring r);
-void nSetChar(ring r);
+void nInitChar(coeffs r);
+void nKillChar(coeffs r);
+void nSetChar(coeffs r);
 
 #define nDivBy0 "div by 0"
@@ -114 +78 @@
 // dummy routines
 void   nDummy2(number& d); // nNormalize...
-#endif
+
+// Tests:
+#ifdef HAVE_RINGS
+static inline BOOLEAN nField_is_Ring_2toM(const coeffs r)
+{ return (r->ringtype == 1); }
+
+static inline BOOLEAN nField_is_Ring_ModN(const coeffs r)
+{ return (r->ringtype == 2); }
+
+static inline BOOLEAN nField_is_Ring_PtoM(const coeffs r)
+{ return (r->ringtype == 3); }
+
+static inline BOOLEAN nField_is_Ring_Z(const coeffs r)
+{ return (r->ringtype == 4); }
+
+static inline BOOLEAN nField_is_Ring(const coeffs r)
+{ return (r->ringtype != 0); }
+
+static inline BOOLEAN nField_is_Domain(const coeffs r)
+{ return (r->ringtype == 4 || r->ringtype == 0); }
+
+static inline BOOLEAN nField_has_Units(const coeffs r)
+{ return ((r->ringtype == 1) || (r->ringtype == 2) || (r->ringtype == 3)); }
+#else
+#define nField_is_Ring(A) (0)
+#endif
+
+#ifdef HAVE_RINGS
+static inline BOOLEAN nField_is_Zp(const coeffs r)
+{ return (r->ringtype == 0) && (r->ch > 1) && (r->parameter==NULL); }
+
+static inline BOOLEAN nField_is_Zp(const coeffs r, int p)
+{ return (r->ringtype == 0) && (r->ch > 1 && r->ch == ABS(p) && r->parameter==NULL); }
+
+static inline BOOLEAN nField_is_Q(const coeffs r)
+{ return (r->ringtype == 0) && (r->ch == 0) && (r->parameter==NULL); }
+
+static inline BOOLEAN nField_is_numeric(const coeffs r) /* R, long R, long C */
+{ return (r->ringtype == 0) && (r->ch ==  -1); }
+
+static inline BOOLEAN nField_is_R(const coeffs r)
+{
+  if (nField_is_numeric(r) && (r->float_len <= (short)SHORT_REAL_LENGTH))
+      return (r->ringtype == 0) && (r->parameter==NULL);
+  return FALSE;
+}
+
+static inline BOOLEAN nField_is_GF(const coeffs r)
+{ return (r->ringtype == 0) && (r->ch > 1) && (r->parameter!=NULL); }
+
+static inline BOOLEAN nField_is_GF(const coeffs r, int q)
+{ return (r->ringtype == 0) && (r->ch == q); }
+
+static inline BOOLEAN nField_is_Zp_a(const coeffs r)
+{ return (r->ringtype == 0) && (r->ch < -1); }
+
+static inline BOOLEAN nField_is_Zp_a(const coeffs r, int p)
+{ return (r->ringtype == 0) && (r->ch < -1 ) && (-(r->ch) == ABS(p)); }
+
+static inline BOOLEAN nField_is_Q_a(const coeffs r)
+{ return (r->ringtype == 0) && (r->ch == 1); }
+
+static inline BOOLEAN nField_is_long_R(const coeffs r)
+{
+  if (nField_is_numeric(r) && (r->float_len >(short)SHORT_REAL_LENGTH))
+    return (r->ringtype == 0) && (r->parameter==NULL);
+  return FALSE;
+}
+
+static inline BOOLEAN nField_is_long_C(const coeffs r)
+{
+  if (nField_is_numeric(r))
+    return (r->ringtype == 0) && (r->parameter!=NULL);
+  return FALSE;
+}
+#else
+static inline BOOLEAN nField_is_Zp(const coeffs r)
+{ return (r->ch > 1) && (r->parameter==NULL); }
+
+static inline BOOLEAN nField_is_Zp(const coeffs r, int p)
+{ return (r->ch > 1 && r->ch == ABS(p) && r->parameter==NULL); }
+
+static inline BOOLEAN nField_is_Q(const coeffs r)
+{ return (r->ch == 0) && (r->parameter==NULL); }
+
+static inline BOOLEAN nField_is_numeric(const coeffs r) /* R, long R, long C */
+{ return (r->ch ==  -1); }
+
+static inline BOOLEAN nField_is_R(const coeffs r)
+{
+  if (nField_is_numeric(r) && (r->float_len <= (short)SHORT_REAL_LENGTH))
+    return (r->parameter==NULL);
+  return FALSE;
+}
+
+static inline BOOLEAN nField_is_GF(const coeffs r)
+{ return (r->ch > 1) && (r->parameter!=NULL); }
+
+static inline BOOLEAN nField_is_GF(const coeffs r, int q)
+{ return (r->ch == q); }
+
+static inline BOOLEAN nField_is_Zp_a(const coeffs r)
+{ return (r->ch < -1); }
+
+static inline BOOLEAN nField_is_Zp_a(const coeffs r, int p)
+{ return (r->ch < -1 ) && (-(r->ch) == ABS(p)); }
+
+static inline BOOLEAN nField_is_Q_a(const coeffs r)
+{ return (r->ch == 1); }
+
+static inline BOOLEAN nField_is_long_R(const coeffs r)
+{
+  if (nField_is_numeric(r) && (r->float_len >(short)SHORT_REAL_LENGTH))
+    return (r->parameter==NULL);
+  return FALSE;
+}
+
+static inline BOOLEAN nField_is_long_C(const coeffs r)
+{
+  if (nField_is_numeric(r))
+    return (r->parameter!=NULL);
+  return FALSE;
+}
+#endif
+
+static inline BOOLEAN nField_has_simple_inverse(const coeffs r)
+/* { return (r->ch>1) || (r->ch== -1); } *//* Z/p, GF(p,n), R, long_R, long_C*/
+#ifdef HAVE_RINGS
+{ return (r->ringtype > 0) || (r->ch>1) || ((r->ch== -1) && (r->float_len < 10)); } /* Z/2^n, Z/p, GF(p,n), R, long_R, long_C*/
+#else
+{ return (r->ch>1) || ((r->ch== -1) && (r->float_len < 10)); } /* Z/p, GF(p,n), R, long_R, long_C*/
+#endif
+
+static inline BOOLEAN nField_has_simple_Alloc(const coeffs r)
+{ return (nField_is_Zp(r)
+       || nField_is_GF(r)
+#ifdef HAVE_RINGS
+       || nField_is_Ring_2toM(r)
+#endif
+       || nField_is_R(r));
+}
+/* Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies*/
+
+static inline BOOLEAN nField_is_Extension(const coeffs r)
+{ return (nField_is_Q_a(r)) || (nField_is_Zp_a(r)); } /* Z/p(a) and Q(a)*/
+
+#endif

coeffs/rmodulo2m.cc

@@ -556 +556 @@
     {
       mpz_clear(modul);
-      omFree((ADDRESS) modul);
+      omFree((void *) modul);
       return nr2mMapGMP;
     }
     mpz_clear(modul);
-    omFree((ADDRESS) modul);
+    omFree((void *) modul);
   }
   return NULL;      // default

coeffs/rmodulo2m.h

@@ -9 +9 @@
 */
 #ifdef HAVE_RINGS
-#include <kernel/structs.h>
+#include "coeffs.h"
 
 extern int nr2mExp;

coeffs/rmodulon.cc

@@ -41 +41 @@
   if (*a == NULL) return;
   mpz_clear((int_number) *a);
-  omFreeBin((ADDRESS) *a, gmp_nrz_bin);
+  omFreeBin((void *) *a, gmp_nrz_bin);
   *a = NULL;
 }

coeffs/rmodulon.h

@@ -9 +9 @@
 */
 #ifdef HAVE_RINGS
-#include <kernel/structs.h>
+#include "coeffs.h"
 
 #ifndef NATNUMBER

coeffs/shortfl.cc

@@ -9 +9 @@
 
 #include <string.h>
-#include <kernel/mod2.h>
-#include <omalloc/mylimits.h>
-#include <kernel/structs.h>
-#include <kernel/febase.h>
-#include <kernel/numbers.h>
-#include <kernel/longrat.h>
-#include <kernel/mpr_complex.h>
-#include <kernel/ring.h>
-#include <kernel/shortfl.h>
+#include "coeffs.h"
+#include <mylimits.h>
+#include "febase.h"
+#include "numbers.h"
+#include "longrat.h"
+#include "mpr_complex.h"
+#include "shortfl.h"
 
 static float nrEps = 1.0e-3;
@@ -35 +33 @@
 }
 
-BOOLEAN nrGreaterZero (number k)
+BOOLEAN nrGreaterZero (number k, const coeffs r)
 {
   return nf(k).F() >= 0.0;
 }
 
-number nrMult (number a,number b)
+number nrMult (number a,number b, const coeffs r)
 {
   return nf(nf(a).F() * nf(b).F()).N();
@@ -48 +46 @@
 * create a number from int
 */
-number nrInit (int i, const ring R)
+number nrInit (int i, const coeffs R)
 {
   float r = (float)i;
@@ -57 +55 @@
 * convert a number to int
 */
-int nrInt(number &n, const ring R)
+int nrInt(number &n, const coeffs R)
 {
   int i;
@@ -68 +66 @@
 }
 
-int nrSize(number n)
+int nrSize(number n, const coeffs R)
 {
   float f = nf(n).F();
@@ -80 +78 @@
 }
 
-number nrAdd (number a, number b)
+number nrAdd (number a, number b, const coeffs R)
 {
   float x = nf(a).F();
@@ -110 +108 @@
 }
 
-number nrSub (number a, number b)
+number nrSub (number a, number b, const coeffs R)
 {
   float x = nf(a).F();
@@ -140 +138 @@
 }
 
-BOOLEAN nrIsZero (number  a)
+BOOLEAN nrIsZero (number  a, const coeffs r)
 {
   return (0.0 == nf(a).F());
 }
 
-BOOLEAN nrIsOne (number a)
+BOOLEAN nrIsOne (number a, const coeffs r)
 {
   float aa=nf(a).F()-1.0;
@@ -152 +150 @@
 }
 
-BOOLEAN nrIsMOne (number a)
+BOOLEAN nrIsMOne (number a, const coeffs r)
 {
   float aa=nf(a).F()+1.0;
@@ -159 +157 @@
 }
 
-number nrDiv (number a,number b)
+number nrDiv (number a,number b, const coeffs r)
 {
   float n = nf(b).F();
@@ -171 +169 @@
 }
 
-number  nrInvers (number c)
+number  nrInvers (number c, const coeffs r)
 {
   float n = nf(c).F();
@@ -182 +180 @@
 }
 
-number nrNeg (number c)
+number nrNeg (number c, const coeffs r)
 {
   return nf(-nf(c).F()).N();
 }
 
-BOOLEAN nrGreater (number a,number b)
+BOOLEAN nrGreater (number a,number b, const coeffs r)
 {
   return nf(a).F() > nf(b).F();
 }
 
-BOOLEAN nrEqual (number a,number b)
-{
-  number x = nrSub(a,b);
+BOOLEAN nrEqual (number a,number b, const coeffs r)
+{
+  number x = nrSub(a,b,r);
   return nf(x).F() == nf((float)0.0).F();
 }
 
-void nrWrite (number &a, const ring r)
+void nrWrite (number &a, const coeffs r)
 {
   StringAppend("%9.3e", nf(a).F());
 }
 
-void nrPower (number a, int i, number * result)
+void nrPower (number a, int i, number * result, const coeffs r)
 {
   if (i==0)
@@ -215 +213 @@
     return;
   }
-  nrPower(a,i-1,result);
+  nrPower(a,i-1,result,r);
   *result = nf(nf(a).F() * nf(*result).F()).N();
 }
@@ -240 +238 @@
 const char *nIllegalChar="illegal character in number";
 
-const char * nrRead (const char *s, number *a)
+const char * nrRead (const char *s, number *a, const coeffs r)
 {
   const char *t;
@@ -425 +423 @@
 }
 
-static number nrMapP(number from)
+static number nrMapP(number from, const coeffs R)
 {
   int i = (int)((long)from);
@@ -432 +430 @@
 }
 
-static number nrMapLongR(number from)
+static number nrMapLongR(number from, const coeffs R)
 {
   float t =(float)mpf_get_d((mpf_srcptr)from);
   return nf(t).N();
 }
-static number nrMapC(number from)
+static number nrMapC(number from, const coeffs r)
 {
   gmp_float h = ((gmp_complex*)from)->real();
@@ -444 +442 @@
 }
 
-nMapFunc nrSetMap(const ring src, const ring dst)
-{
-  if (rField_is_Q(src))
+nMapFunc nrSetMap(const coeffs src, const coeffs dst)
+{
+  if (nField_is_Q(src))
   {
     return nrMapQ;
   }
-  if (rField_is_long_R(src))
+  if (nField_is_long_R(src))
   {
     return nrMapLongR;
   }
-  if (rField_is_R(src))
+  if (nField_is_R(src))
   {
     return ndCopy;
   }
-  if(rField_is_Zp(src))
+  if(nField_is_Zp(src))
   {
     return nrMapP;
   }
-  if (rField_is_long_C(src))
+  if (nField_is_long_C(src))
   {
     return nrMapC;

coeffs/shortfl.h

@@ -8 +8 @@
 */
 /* $Id$ */
-#include <kernel/structs.h>
+#include "coeffs.h"
 
-BOOLEAN nrGreaterZero (number k);
-number  nrMult        (number a, number b);
-number  nrInit        (int i, const ring r);
-int     nrInt         (number &n, const ring r);
-number  nrAdd         (number a, number b);
-number  nrSub         (number a, number b);
-void    nrPower       (number a, int i, number * result);
-BOOLEAN nrIsZero      (number a);
-BOOLEAN nrIsOne       (number a);
-BOOLEAN nrIsMOne      (number a);
-number  nrDiv         (number a, number b);
-number  nrNeg         (number c);
-number  nrInvers      (number c);
-int     nrSize        (number n);
-BOOLEAN nrGreater     (number a, number b);
-BOOLEAN nrEqual       (number a, number b);
-void    nrWrite       (number &a, const ring r);
-const char *  nrRead  (const char *s, number *a);
+BOOLEAN nrGreaterZero (number k, const coeffs r);
+number  nrMult        (number a, number b, const coeffs r);
+number  nrInit        (int i, const coeffs r);
+int     nrInt         (number &n, const coeffs r);
+number  nrAdd         (number a, number b, const coeffs r);
+number  nrSub         (number a, number b, const coeffs r);
+void    nrPower       (number a, int i, number * result, const coeffs r);
+BOOLEAN nrIsZero      (number a, const coeffs r);
+BOOLEAN nrIsOne       (number a, const coeffs r);
+BOOLEAN nrIsMOne      (number a, const coeffs r);
+number  nrDiv         (number a, number b, const coeffs r);
+number  nrNeg         (number c, const coeffs r);
+number  nrInvers      (number c, const coeffs r);
+BOOLEAN nrGreater     (number a, number b, const coeffs r);
+BOOLEAN nrEqual       (number a, number b, const coeffs r);
+void    nrWrite       (number &a, const coeffs r);
+const char *  nrRead  (const char *s, number *a, const coeffs r);
 int     nrGetChar();
 #ifdef LDEBUG
-BOOLEAN nrDBTest(number a, const char *f, const int l);
+BOOLEAN nrDBTest(number a, const coeffs, rconst char *f, const int l);
 #endif
 
-nMapFunc nrSetMap(const ring src, const ring dst);
+nMapFunc nrSetMap(const coeffs src, const coeffs dst);
 
 float   nrFloat(number n);
-number nrMapQ(number from);
+number nrMapQ(number from, const coeffs r);
 #endif