Changeset 7bbbef in git

Timestamp:

May 31, 2010, 3:09:00 PM (13 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

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

Children:

a98f56d0b08e7bf18c6536ebf73eecb1db4bc4eb

Parents:

b695dd84dfeeea2e9ac126f42fc4eb453f454056

git-author:

Hans Schoenemann <hannes@mathematik.uni-kl.de>2010-05-31 15:09:00+02:00

git-committer:

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

Message:

access macros -> coeffs.h, internal proc renamed (n.. -> cf...)

Location:

coeffs

Files:

• coeffs.h (modified) (2 diffs)
• gnumpc.cc (modified) (2 diffs)
• gnumpfl.cc (modified) (1 diff)
• longrat.cc (modified) (1 diff)
• modulop.cc (modified) (1 diff)
• numbers.cc (modified) (2 diffs)
• numbers.h (modified) (2 diffs)
• shortfl.cc (modified) (1 diff)

coeffs/coeffs.h

@@ -78 +78 @@
                                 // or NULL
    // general stuff
-   numberfunc nMult, nSub ,nAdd ,nDiv, nIntDiv, nIntMod, nExactDiv;
+   numberfunc cfMult, cfSub ,cfAdd ,cfDiv, cfIntDiv, cfIntMod, cfExactDiv;
    /// init with an integer
    number  (*cfInit)(int i,const coeffs r);
-   number  (*nPar)(int i, const coeffs r);
-   int     (*nParDeg)(number n, const coeffs r);
+   number  (*cfPar)(int i, const coeffs r);
+   int     (*cfParDeg)(number n, const coeffs r);
    /// how complicated, (0) => 0, or positive
-   int     (*nSize)(number n, const coeffs r);
+   int     (*cfSize)(number n, const coeffs r);
    /// convertion, 0 if impossible
-   int     (*n_Int)(number &n, const coeffs r);
+   int     (*cfInt)(number &n, const coeffs r);
 #ifdef HAVE_RINGS
-   int     (*nDivComp)(number a,number b,const coeffs r);
-   BOOLEAN (*nIsUnit)(number a,const coeffs r);
-   number  (*nGetUnit)(number a,const coeffs r);
-   number  (*nExtGcd)(number a, number b, number *s, number *t,const coeffs r);
+   int     (*cfDivComp)(number a,number b,const coeffs r);
+   BOOLEAN (*cfIsUnit)(number a,const coeffs r);
+   number  (*cfGetUnit)(number a,const coeffs r);
+   number  (*cfExtGcd)(number a, number b, number *s, number *t,const coeffs r);
 #endif
    /// changes argument  inline: a:= -a
-   number  (*nNeg)(number a, const coeffs r);
+   number  (*cfNeg)(number a, const coeffs r);
    /// return 1/a
-   number  (*nInvers)(number a, const coeffs r);
+   number  (*cfInvers)(number a, const coeffs r);
    /// return a copy of a
    number  (*cfCopy)(number a, const coeffs r);
-   number  (*nRePart)(number a, const coeffs r);
-   number  (*nImPart)(number a, const coeffs r);
+   number  (*cfRePart)(number a, const coeffs r);
+   number  (*cfImPart)(number a, const coeffs r);
    void    (*cfWrite)(number &a, const coeffs r);
-   const char *  (*nRead)(const char * s, number * a, const coeffs r);
-   void    (*nNormalize)(number &a, const coeffs r);
-   BOOLEAN (*nGreater)(number a,number b, const coeffs r),
+   const char *  (*cfRead)(const char * s, number * a, const coeffs r);
+   void    (*cfNormalize)(number &a, const coeffs r);
+   BOOLEAN (*cfGreater)(number a,number b, const coeffs r),
 #ifdef HAVE_RINGS
-           (*nDivBy)(number a, number b, const coeffs r),
+           (*cfDivBy)(number a, number b, const coeffs r),
 #endif
             /// tests
-           (*nEqual)(number a,number b, const coeffs r),
-           (*nIsZero)(number a, const coeffs r),
-           (*nIsOne)(number a, const coeffs r),
-           (*nIsMOne)(number a, const coeffs r),
-           (*nGreaterZero)(number a, const coeffs r);
-   void    (*nPower)(number a, int i, number * result, const coeffs r);
+           (*cfEqual)(number a,number b, const coeffs r),
+           (*cfIsZero)(number a, const coeffs r),
+           (*cfIsOne)(number a, const coeffs r),
+           (*cfIsMOne)(number a, const coeffs r),
+           (*cfGreaterZero)(number a, const coeffs r);
+   void    (*cfPower)(number a, int i, number * result, const coeffs r);
    number  (*cfGetDenom)(number &n, const coeffs r);
    number  (*cfGetNumerator)(number &n, const coeffs r);
-   number  (*nGcd)(number a, number b, const coeffs r);
-   number  (*nLcm)(number a, number b, const coeffs r);
+   number  (*cfGcd)(number a, number b, const coeffs r);
+   number  (*cfLcm)(number a, number b, const coeffs r);
    void    (*cfDelete)(number * a, const coeffs r);
    nMapFunc (*cfSetMap)(const coeffs src, const coeffs dst);
 
    /// For extensions (writes into global string buffer)
-   char *  (*nName)(number n, const coeffs r);
+   char *  (*cfName)(number n, const coeffs r);
 
    /// Inline: a := b
-   void    (*nInpMult)(number &a, number b, const coeffs r);
+   void    (*cfInpMult)(number &a, number b, const coeffs r);
    /// maps the bigint i (from dummy) into the coeffs dst
-   number  (*nInit_bigint)(number i, const coeffs dummy, const coeffs dst);
+   number  (*cfInit_bigint)(number i, const coeffs dummy, const coeffs dst);
 
 #ifdef LDEBUG
    /// Test: is "a" a correct number?
-   BOOLEAN (*nDBTest)(number a, const char *f,const int l,const coeffs r);
+   BOOLEAN (*cfDBTest)(number a, const char *f,const int l,const coeffs r);
 #endif
 
@@ -157 +157 @@
 
 };
-
-#endif
-
+//
+// test properties and type
+/// Returns the type of coeffs domain
+static inline n_coeffType getCoeffType(const coeffs r)
+{
+  return r->type;
+}
+
+static inline int nInternalChar(const coeffs r)
+{
+  return r->ch;
+}
+
+/// one-time initialisations for new coeffs
+coeffs nInitChar(n_coeffType t, void * parameter);
+/// undo all initialisations
+void nKillChar(coeffs r);
+/// initialisations after each ring change
+inline void nSetChar(coeffs r)
+{
+  if ((r!=NULL) && (r->cfSetChar!=NULL)) r->cfSetChar(r);
+}
+
+//
+// the access macros:
+
+#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)->cfMult(n1, n2,r)
+#define n_Add(n1, n2, r)      (r)->cfAdd(n1, n2,r)
+#define n_IsZero(n, r)        (r)->cfIsZero(n,r)
+#define n_Equal(n1, n2, r)    (r)->cfEqual(n1, n2,r)
+#define n_Neg(n, r)           (r)->cfNeg(n,r)
+#define n_Sub(n1, n2, r)      (r)->cfSub(n1, n2,r)
+#define n_GetChar(r)          nInternalChar(r)
+#define n_Init(i, r)          (r)->cfInit(i,r)
+#define n_IsOne(n, r)         (r)->cfIsOne(n,r)
+#define n_IsMOne(n, r)        (r)->cfIsMOne(n,r)
+#define n_GreaterZero(n, r)   (r)->cfGreaterZero(n,r)
+#define n_Write(n, r)         (r)->cfWrite(n,r)
+#define n_Normalize(n, r)     (r)->cfNormalize(n,r)
+#define n_Gcd(a, b, r)        (r)->cfGcd(a,b,r)
+#define n_IntDiv(a, b, r)     (r)->cfIntDiv(a,b,r)
+#define n_Div(a, b, r)        (r)->cfDiv(a,b,r)
+#define n_Invers(a, r)        (r)->cfInvers(a,r)
+#define n_ExactDiv(a, b, r)   (r)->cfExactDiv(a,b,r)
+#define n_Test(a,r)           (r)->cfDBTest(a,r,__FILE__,__LINE__)
+
+#define n_InpMult(a, b, r)    (r)->cfInpMult(a,b,r)
+#define n_Power(a, b, res, r) (r)->cfPower(a,b,res,r)
+#define n_Size(n,r)           (r)->cfSize(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)
+
+
+// and the routines w.r.t. currRing:
+// (should only be used in the context of currRing, i.e. in the interpreter)
+void           nNew(number * a);
+#define nCopy(n)          (currRing->cf)->cfCopy(n,currRing->cf)
+#define nDelete(n)        (currRing->cf)->cfDelete(n,currRing->cf)
+#define nMult(n1, n2)     (currRing->cf)->nMult(n1, n2,currRing->cf)
+#define nAdd(n1, n2)      (currRing->cf)->nAdd(n1, n2,currRing->cf)
+#define nIsZero(n)        (currRing->cf)->nIsZero(n,currRing->cf)
+#define nEqual(n1, n2)    (currRing->cf)->nEqual(n1, n2,currRing->cf)
+#define nNeg(n)           (currRing->cf)->nNeg(n,currRing->cf)
+#define nSub(n1, n2)      (currRing->cf)->nSub(n1, n2,currRing->cf)
+#define nGetChar()        nInternalChar(currRing->cf)
+#define nInit(i)          (currRing->cf)->cfInit(i,currRing->cf)
+#define nIsOne(n)         (currRing->cf)->nIsOne(n,currRing->cf)
+#define nIsMOne(n)        (currRing->cf)->nIsMOne(n,currRing->cf)
+#define nGreaterZero(n)   (currRing->cf)->nGreaterZero(n,currRing->cf)
+#define nWrite(n)         (currRing->cf)->cfWrite(n,currRing->cf)
+#define nNormalize(n)     (currRing->cf)->nNormalize(n,currRing->cf)
+#define nGcd(a, b)        (currRing->cf)->nGcd(a,b,currRing->cf)
+#define nIntDiv(a, b)     (currRing->cf)->nIntDiv(a,b,currRing->cf)
+#define nDiv(a, b)        (currRing->cf)->nDiv(a,b,currRing->cf)
+#define nInvers(a)        (currRing->cf)->nInvers(a,currRing->cf)
+#define nExactDiv(a, b)   (currRing->cf)->nExactDiv(a,b,currRing->cf)
+#define nTest(a)          (currRing->cf)->nDBTest(a,currRing->cf,__FILE__,__LINE__)
+
+#define nInpMult(a, b)    (currRing->cf)->nInpMult(a,b,currRing->cf)
+#define nPower(a, b, res) (currRing->cf)->nPower(a,b,res,currRing->cf)
+#define nSize(n)          (currRing->cf)->nSize(n,currRing->cf)
+#define nGetDenom(N)      (currRing->cf)->cfGetDenom((N),currRing->cf)
+#define nGetNumerator(N)  (currRing->cf)->cfGetNumerator((N),currRing->cf)
+
+#define nSetMap(R) (currRing->cf->cfSetMap(R,currRing))
+
+#endif
+

coeffs/gnumpc.cc

@@ -385 +385 @@
 
   n->cfDelete  = ngcDelete;
-  n->nNormalize=ndNormalize;
+  n->cfNormalize=ndNormalize;
   n->cfInit   = ngcInit;
-  n->n_Int    = ngcInt;
-  n->nAdd     = ngcAdd;
-  n->nSub     = ngcSub;
-  n->nMult    = ngcMult;
-  n->nDiv     = ngcDiv;
-  n->nExactDiv= ngcDiv;
-  n->nNeg     = ngcNeg;
-  n->nInvers  = ngcInvers;
+  n->cfInt    = ngcInt;
+  n->cfAdd     = ngcAdd;
+  n->cfSub     = ngcSub;
+  n->cfMult    = ngcMult;
+  n->cfDiv     = ngcDiv;
+  n->cfExactDiv= ngcDiv;
+  n->cfNeg     = ngcNeg;
+  n->cfInvers  = ngcInvers;
   n->cfCopy   = ngcCopy;
-  n->nGreater = ngcGreater;
-  n->nEqual   = ngcEqual;
-  n->nIsZero  = ngcIsZero;
-  n->nIsOne   = ngcIsOne;
-  n->nIsMOne  = ngcIsMOne;
-  n->nGreaterZero = ngcGreaterZero;
+  n->cfGreater = ngcGreater;
+  n->cfEqual   = ngcEqual;
+  n->cfIsZero  = ngcIsZero;
+  n->cfIsOne   = ngcIsOne;
+  n->cfIsMOne  = ngcIsMOne;
+  n->cfGreaterZero = ngcGreaterZero;
   n->cfWrite  = ngcWrite;
-  n->nRead    = ngcRead;
-  n->nPower   = ngcPower;
+  n->cfRead    = ngcRead;
+  n->cfPower   = ngcPower;
   n->cfSetMap = ngcSetMap;
-  n->nPar     = ngcPar;
-  n->nRePart  = ngcRePart;
-  n->nImPart  = ngcImPart;
-    // nSize  = ndSize;
+  n->cfPar     = ngcPar;
+  n->cfRePart  = ngcRePart;
+  n->cfImPart  = ngcImPart;
+    // cfSize  = ndSize;
 #ifdef LDEBUG
-  n->nDBTest  = ndDBTest; // not yet implemented: ngcDBTest
+  n->cfDBTest  = ndDBTest; // not yet implemented: ngcDBTest
 #endif
 
@@ -422 +422 @@
   r->nCoeffIsEqual=nlCoeffsEqual;
 
-  r->nMult  = nlMult;
-  r->nSub   = nlSub;
-  r->nAdd   = nlAdd;
-  r->nDiv   = nlDiv;
-  r->nIntDiv= nlIntDiv;
-  r->nIntMod= nlIntMod;
-  r->nExactDiv= nlExactDiv;
+  r->cfMult  = nlMult;
+  r->cfSub   = nlSub;
+  r->cfAdd   = nlAdd;
+  r->cfDiv   = nlDiv;
+  r->cfIntDiv= nlIntDiv;
+  r->cfIntMod= nlIntMod;
+  r->cfExactDiv= nlExactDiv;
   r->cfInit = nlInit;
-  r->nPar = ndPar;
-  r->nParDeg = ndParDeg;
-  r->nSize  = nlSize;
-  r->n_Int  = nlInt;
+  r->cfPar = ndPar;
+  r->cfParDeg = ndParDeg;
+  r->cfSize  = nlSize;
+  r->cfInt  = nlInt;
 #ifdef HAVE_RINGS
-  r->nDivComp = NULL; // only for ring stuff
-  r->nIsUnit = NULL; // only for ring stuff
-  r->nGetUnit = NULL; // only for ring stuff
-  r->nExtGcd = NULL; // only for ring stuff
+  r->cfDivComp = NULL; // only for ring stuff
+  r->cfIsUnit = NULL; // only for ring stuff
+  r->cfGetUnit = NULL; // only for ring stuff
+  r->cfExtGcd = NULL; // only for ring stuff
 #endif
-  r->nNeg   = nlNeg;
-  r->nInvers= nlInvers;
+  r->cfNeg   = nlNeg;
+  r->cfInvers= nlInvers;
   r->cfCopy  = nl_Copy;
-  r->nRePart = nl_Copy;
-  r->nImPart = ndReturn0;
+  r->cfRePart = nl_Copy;
+  r->cfImPart = ndReturn0;
   r->cfWrite = nlWrite;
-  r->nRead = nlRead;
-  r->nNormalize=nlNormalize;
-  r->nGreater = nlGreater;
+  r->cfRead = nlRead;
+  r->cfNormalize=nlNormalize;
+  r->cfGreater = nlGreater;
 #ifdef HAVE_RINGS
-  r->nDivBy = NULL; // only for ring stuff
+  r->cfDivBy = NULL; // only for ring stuff
 #endif
-  r->nEqual = nlEqual;
-  r->nIsZero = nlIsZero;
-  r->nIsOne = nlIsOne;
-  r->nIsMOne = nlIsMOne;
-  r->nGreaterZero = nlGreaterZero;
-  r->nPower = nlPower;
+  r->cfEqual = nlEqual;
+  r->cfIsZero = nlIsZero;
+  r->cfIsOne = nlIsOne;
+  r->cfIsMOne = nlIsMOne;
+  r->cfGreaterZero = nlGreaterZero;
+  r->cfPower = nlPower;
   r->cfGetDenom = nlGetDenom;
   r->cfGetNumerator = nlGetNumerator;
-  r->nGcd  = nlGcd;
-  r->nLcm  = nlLcm;
+  r->cfGcd  = nlGcd;
+  r->cfLcm  = nlLcm;
   r->cfDelete= nlDelete;
   r->cfSetMap = nlSetMap;
-  r->nName = ndName;
-  r->nInpMult=nlInpMult;
-  r->nInit_bigint=nlCopyMap;
+  r->cfName = ndName;
+  r->cfInpMult=nlInpMult;
+  r->cfInit_bigint=nlCopyMap;
 #ifdef LDEBUG
   // debug stuff
-  r->nDBTest=nlDBTest;
+  r->cfDBTest=nlDBTest;
 #endif
 

coeffs/gnumpfl.cc

@@ -418 +418 @@
 
   n->cfDelete  = ngfDelete;
-  n->nNormalize=ndNormalize;
+  n->cfNormalize=ndNormalize;
   n->cfInit   = ngfInit;
-  n->n_Int    = ngfInt;
-  n->nAdd     = ngfAdd;
-  n->nSub     = ngfSub;
-  n->nMult    = ngfMult;
-  n->nDiv     = ngfDiv;
-  n->nExactDiv= ngfDiv;
-  n->nNeg     = ngfNeg;
-  n->nInvers  = ngfInvers;
+  n->cfInt    = ngfInt;
+  n->cfAdd     = ngfAdd;
+  n->cfSub     = ngfSub;
+  n->cfMult    = ngfMult;
+  n->cfDiv     = ngfDiv;
+  n->cfExactDiv= ngfDiv;
+  n->cfNeg     = ngfNeg;
+  n->cfInvers  = ngfInvers;
   n->cfCopy   = ngfCopy;
-  n->nGreater = ngfGreater;
-  n->nEqual   = ngfEqual;
-  n->nIsZero  = ngfIsZero;
-  n->nIsOne   = ngfIsOne;
-  n->nIsMOne  = ngfIsMOne;
-  n->nGreaterZero = ngfGreaterZero;
+  n->cfGreater = ngfGreater;
+  n->cfEqual   = ngfEqual;
+  n->cfIsZero  = ngfIsZero;
+  n->cfIsOne   = ngfIsOne;
+  n->cfIsMOne  = ngfIsMOne;
+  n->cfGreaterZero = ngfGreaterZero;
   n->cfWrite  = ngfWrite;
-  n->nRead    = ngfRead;
-  n->nPower   = ngfPower;
+  n->cfRead    = ngfRead;
+  n->cfPower   = ngfPower;
   n->cfSetMap = ngfSetMap;
 #ifdef LDEBUG
-  n->nDBTest  = ndDBTest; // not yet implemented: ngfDBTest
+  n->cfDBTest  = ndDBTest; // not yet implemented: ngfDBTest
 #endif
 }

coeffs/longrat.cc

@@ -2469 +2469 @@
   r->nCoeffIsEqual=nlCoeffsEqual;
 
-  r->nMult  = nlMult;
-  r->nSub   = nlSub;
-  r->nAdd   = nlAdd;
-  r->nDiv   = nlDiv;
-  r->nIntDiv= nlIntDiv;
-  r->nIntMod= nlIntMod;
-  r->nExactDiv= nlExactDiv;
+  r->cfMult  = nlMult;
+  r->cfSub   = nlSub;
+  r->cfAdd   = nlAdd;
+  r->cfDiv   = nlDiv;
+  r->cfIntDiv= nlIntDiv;
+  r->cfIntMod= nlIntMod;
+  r->cfExactDiv= nlExactDiv;
   r->cfInit = nlInit;
-  //r->nPar = ndPar;
-  //r->nParDeg = ndParDeg;
-  r->nSize  = nlSize;
-  r->n_Int  = nlInt;
+  //r->cfPar = ndPar;
+  //r->cfParDeg = ndParDeg;
+  r->cfSize  = nlSize;
+  r->cfInt  = nlInt;
   #ifdef HAVE_RINGS
-  //r->nDivComp = NULL; // only for ring stuff
-  //r->nIsUnit = NULL; // only for ring stuff
-  //r->nGetUnit = NULL; // only for ring stuff
-  //r->nExtGcd = NULL; // only for ring stuff
+  //r->cfDivComp = NULL; // only for ring stuff
+  //r->cfIsUnit = NULL; // only for ring stuff
+  //r->cfGetUnit = NULL; // only for ring stuff
+  //r->cfExtGcd = NULL; // only for ring stuff
+  //r->cfDivBy = NULL; // only for ring stuff
   #endif
-  r->nNeg   = nlNeg;
-  r->nInvers= nlInvers;
+  r->cfNeg   = nlNeg;
+  r->cfInvers= nlInvers;
   r->cfCopy  = nl_Copy;
-  r->nRePart = nl_Copy;
-  //r->nImPart = ndReturn0;
+  r->cfRePart = nl_Copy;
+  //r->cfImPart = ndReturn0;
   r->cfWrite = nlWrite;
-  r->nRead = nlRead;
-  r->nNormalize=nlNormalize;
-  r->nGreater = nlGreater;
-  #ifdef HAVE_RINGS
-  //r->nDivBy = NULL; // only for ring stuff
-  #endif
-  r->nEqual = nlEqual;
-  r->nIsZero = nlIsZero;
-  r->nIsOne = nlIsOne;
-  r->nIsMOne = nlIsMOne;
-  r->nGreaterZero = nlGreaterZero;
-  r->nPower = nlPower;
+  r->cfRead = nlRead;
+  r->cfNormalize=nlNormalize;
+  r->cfGreater = nlGreater;
+  r->cfEqual = nlEqual;
+  r->cfIsZero = nlIsZero;
+  r->cfIsOne = nlIsOne;
+  r->cfIsMOne = nlIsMOne;
+  r->cfGreaterZero = nlGreaterZero;
+  r->cfPower = nlPower;
   r->cfGetDenom = nlGetDenom;
   r->cfGetNumerator = nlGetNumerator;
-  r->nGcd  = nlGcd;
-  r->nLcm  = nlLcm;
+  r->cfGcd  = nlGcd;
+  r->cfLcm  = nlLcm;
   r->cfDelete= nlDelete;
   r->cfSetMap = nlSetMap;
-  //r->nName = ndName;
-  r->nInpMult=nlInpMult;
-  r->nInit_bigint=nlCopyMap;
+  //r->cfName = ndName;
+  r->cfInpMult=nlInpMult;
+  r->cfInit_bigint=nlCopyMap;
 #ifdef LDEBUG
   // debug stuff
-  r->nDBTest=nlDBTest;
+  r->cfDBTest=nlDBTest;
 #endif
   

coeffs/modulop.cc

@@ -330 +330 @@
   r->nCoeffIsEqual=npCoeffsEqual;
 
-  r->nMult  = npMult;
-  r->nSub   = npSub;
-  r->nAdd   = npAdd;
-  r->nDiv   = npDiv;
-  r->nIntDiv= npDiv;
-  //r->nIntMod= ndIntMod;
-  r->nExactDiv= npDiv;
+  r->cfMult  = npMult;
+  r->cfSub   = npSub;
+  r->cfAdd   = npAdd;
+  r->cfDiv   = npDiv;
+  r->cfIntDiv= npDiv;
+  //r->cfIntMod= ndIntMod;
+  r->cfExactDiv= npDiv;
   r->cfInit = npInit;
-  //r->nPar = ndPar;
-  //r->nParDeg = ndParDeg;
-  //r->nSize  = ndSize;
-  r->n_Int  = npInt;
+  //r->cfPar = ndPar;
+  //r->cfParDeg = ndParDeg;
+  //r->cfSize  = ndSize;
+  r->cfInt  = npInt;
   #ifdef HAVE_RINGS
-  //r->nDivComp = NULL; // only for ring stuff
-  //r->nIsUnit = NULL; // only for ring stuff
-  //r->nGetUnit = NULL; // only for ring stuff
-  //r->nExtGcd = NULL; // only for ring stuff
+  //r->cfDivComp = NULL; // only for ring stuff
+  //r->cfIsUnit = NULL; // only for ring stuff
+  //r->cfGetUnit = NULL; // only for ring stuff
+  //r->cfExtGcd = NULL; // only for ring stuff
+  // r->cfDivBy = NULL; // only for ring stuff
   #endif
-  r->nNeg   = npNeg;
-  r->nInvers= npInvers;
+  r->cfNeg   = npNeg;
+  r->cfInvers= npInvers;
   //r->cfCopy  = ndCopy;
-  //r->nRePart = ndCopy;
-  //r->nImPart = ndReturn0;
+  //r->cfRePart = ndCopy;
+  //r->cfImPart = ndReturn0;
   r->cfWrite = npWrite;
-  r->nRead = npRead;
-  //r->nNormalize=ndNormalize;
-  r->nGreater = npGreater;
-  #ifdef HAVE_RINGS
-  r->nDivBy = NULL; // only for ring stuff
-  #endif
-  r->nEqual = npEqual;
-  r->nIsZero = npIsZero;
-  r->nIsOne = npIsOne;
-  r->nIsMOne = npIsMOne;
-  r->nGreaterZero = npGreaterZero;
-  r->nPower = npPower;
+  r->cfRead = npRead;
+  //r->cfNormalize=ndNormalize;
+  r->cfGreater = npGreater;
+  r->cfEqual = npEqual;
+  r->cfIsZero = npIsZero;
+  r->cfIsOne = npIsOne;
+  r->cfIsMOne = npIsMOne;
+  r->cfGreaterZero = npGreaterZero;
+  r->cfPower = npPower;
   r->cfGetDenom = ndGetDenom;
   r->cfGetNumerator = ndGetNumerator;
-  //r->nGcd  = ndGcd;
-  //r->nLcm  = ndGcd;
+  //r->cfGcd  = ndGcd;
+  //r->cfLcm  = ndGcd;
   //r->cfDelete= ndDelete;
   r->cfSetMap = npSetMap;
-  //r->nName = ndName;
-  r->nInpMult=ndInpMult;
-  r->nInit_bigint= npMap0;
+  //r->cfName = ndName;
+  r->cfInpMult=ndInpMult;
+  r->cfInit_bigint= npMap0;
 #ifdef NV_OPS
   if (c>NV_MAX_PRIME)
   {
-    r->nMult  = nvMult;
-    r->nDiv   = nvDiv;
-    r->nExactDiv= nvDiv;
-    r->nInvers= nvInvers;
-    r->nPower= nvPower;
+    r->cfMult  = nvMult;
+    r->cfDiv   = nvDiv;
+    r->cfExactDiv= nvDiv;
+    r->cfInvers= nvInvers;
+    r->cfPower= nvPower;
   }
 #endif
 #ifdef LDEBUG
   // debug stuff
-  r->nDBTest=npDBTest;
+  r->cfDBTest=npDBTest;
 #endif
   

coeffs/numbers.cc

@@ -121 +121 @@
 
     // default entries (different from NULL) for some routines:
-    n->nPar  = ndPar;
-    n->nParDeg=ndParDeg;
-    n->nSize = ndSize;
+    n->cfPar  = ndPar;
+    n->cfParDeg=ndParDeg;
+    n->cfSize = ndSize;
     n->cfGetDenom= ndGetDenom;
     n->cfGetNumerator= ndGetNumerator;
-    n->nName =  ndName;
-    n->nImPart=ndReturn0;
+    n->cfName =  ndName;
+    n->cfImPart=ndReturn0;
     n->cfDelete= ndDelete;
-    n->nInpMult=ndInpMult;
+    n->cfInpMult=ndInpMult;
     n->cfCopy=nd_Copy;
-    n->nIntMod=ndIntMod; /* dummy !! */
-    n->nNormalize=ndNormalize;
-    n->nGcd  = ndGcd;
-    n->nLcm  = ndGcd; /* tricky, isn't it ?*/
-#ifdef HAVE_RINGS
-    n->nDivComp = ndDivComp;
-    n->nDivBy = ndDivBy;
-    n->nIsUnit = ndIsUnit;
-    n->nExtGcd = ndExtGcd;
-    //n->nGetUnit = (nMapFunc)NULL;
+    n->cfIntMod=ndIntMod; /* dummy !! */
+    n->cfNormalize=ndNormalize;
+    n->cfGcd  = ndGcd;
+    n->cfLcm  = ndGcd; /* tricky, isn't it ?*/
+#ifdef HAVE_RINGS
+    n->cfDivComp = ndDivComp;
+    n->cfDivBy = ndDivBy;
+    n->cfIsUnit = ndIsUnit;
+    n->cfExtGcd = ndExtGcd;
+    //n->cfGetUnit = (nMapFunc)NULL;
 #endif
   #if 0 /*vertagt*/
@@ -190 +190 @@
        Werror("coeff init missing for %d",(int)t);
     // post init settings:
-    if (n->nRePart==NULL) n->nRePart=n->cfCopy;
-    if (n->nIntDiv==NULL) n->nIntDiv=n->nDiv;
-#ifdef HAVE_RINGS
-   if (n->nGetUnit==(nMapFunc)NULL) n->nGetUnit=n->cfCopy;
+    if (n->cfRePart==NULL) n->cfRePart=n->cfCopy;
+    if (n->cfIntDiv==NULL) n->cfIntDiv=n->cfDiv;
+#ifdef HAVE_RINGS
+   if (n->cfGetUnit==(nMapFunc)NULL) n->cfGetUnit=n->cfCopy;
 #endif
   }

coeffs/numbers.h

@@ -10 +10 @@
 #include "coeffs.h"
 
-/// Returns the type of coeffs domain
-static inline n_coeffType getCoeffType(const coeffs r)
-{
-  return r->type;
-}
-
-static inline int nInternalChar(const coeffs r)
-{
-  return r->ch;
-}
-
 #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)->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)
-
-/* prototypes */
-void           nNew(number * a);
-
-#define nTest(a) (1)
-
-// please use n_* counterparts instead!!!
-// #define nDelete(A) (currRing)->cf->cfDelete(A,currRing)
-// #define nGetDenom(N) (currRing->cf->cfGetDenom((N),currRing))
-// #define nGetNumerator(N) (currRing->cf->cfGetNumerator((N),currRing))
-
-
-#define nSetMap(R) (currRing->cf->cfSetMap(R,currRing))
 
 /* the dummy routines: */
@@ -87 +33 @@
 void nDBDummy1(number* d,char *f, int l);
 #endif
-#define nGetChar() n_GetChar(currRing)
-
-/// one-time initialisations for new coeffs
-coeffs nInitChar(n_coeffType t, void * parameter);
-/// undo all initialisations
-void nKillChar(coeffs r);
-/// initialisations after each ring change
-inline void nSetChar(coeffs r)
-{
-  if ((r!=NULL) && (r->cfSetChar!=NULL)) r->cfSetChar(r);
-}
 
 #define nDivBy0 "div by 0"

coeffs/shortfl.cc

@@ -552 +552 @@
 
   n->cfInit = nrInit;
-  n->n_Int  = nrInt;
-  n->nAdd   = nrAdd;
-  n->nSub   = nrSub;
-  n->nMult  = nrMult;
-  n->nDiv   = nrDiv;
-  n->nExactDiv= nrDiv;
-  n->nNeg   = nrNeg;
-  n->nInvers= nrInvers;
+  n->cfInt  = nrInt;
+  n->cfAdd   = nrAdd;
+  n->cfSub   = nrSub;
+  n->cfMult  = nrMult;
+  n->cfDiv   = nrDiv;
+  n->cfExactDiv= nrDiv;
+  n->cfNeg   = nrNeg;
+  n->cfInvers= nrInvers;
   n->cfCopy  = ndCopy;
-  n->nGreater = nrGreater;
-  n->nEqual = nrEqual;
-  n->nIsZero = nrIsZero;
-  n->nIsOne = nrIsOne;
-  n->nIsMOne = nrIsMOne;
-  n->nGreaterZero = nrGreaterZero;
+  n->cfGreater = nrGreater;
+  n->cfEqual = nrEqual;
+  n->cfIsZero = nrIsZero;
+  n->cfIsOne = nrIsOne;
+  n->cfIsMOne = nrIsMOne;
+  n->cfGreaterZero = nrGreaterZero;
   n->cfWrite = nrWrite;
-  n->nRead = nrRead;
-  n->nPower = nrPower;
+  n->cfRead = nrRead;
+  n->cfPower = nrPower;
   n->cfSetMap=nrSetMap;
     /* nName= ndName; */
     /*nSize  = ndSize;*/
 #ifdef LDEBUG
-  n->nDBTest=ndDBTest; // not yet implemented: nrDBTest;
+  n->cfDBTest=ndDBTest; // not yet implemented: nrDBTest;
 #endif