Changeset 7d90aa in git for coeffs/numbers.h


Ignore:
Timestamp:
Mar 8, 2011, 7:29:56 PM (13 years ago)
Author:
Oleksandr Motsak <motsak@…>
Branches:
(u'spielwiese', '73c62e0961bcfc8f1a00420b41eec2ea3c0ef6e9')
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
File:
1 edited

Legend:

Unmodified
Added
Removed

  • coeffs/numbers.h

    r634d93b r7d90aa  
    88* ABSTRACT: interface to coefficient aritmetics
    99*/
    10 #include <kernel/structs.h>
    11 
    12 #define n_Copy(n, r)          (r)->cf->cfCopy(n,r)
    13 #define n_Delete(n, r)        (r)->cf->cfDelete(n,r)
    14 #define n_Mult(n1, n2, r)     (r)->cf->nMult(n1, n2)
    15 #define n_Add(n1, n2, r)      (r)->cf->nAdd(n1, n2)
    16 #define n_IsZero(n, r)        (r)->cf->nIsZero(n)
    17 #define n_Equal(n1, n2, r)    (r)->cf->nEqual(n1, n2)
    18 #define n_Neg(n, r)           (r)->cf->nNeg(n)
    19 #define n_Sub(n1, n2, r)      (r)->cf->nSub(n1, n2)
    20 //#define n_GetChar(r)          ((r)->cf->nChar)
     10#include "coeffs.h"
     11
     12#define SHORT_REAL_LENGTH 6 // use short reals for real <= 6 digits
     13
     14#define n_Copy(n, r)          (r)->cfCopy(n,r)
     15#define n_Delete(n, r)        (r)->cfDelete(n,r)
     16#define n_Mult(n1, n2, r)     (r)->nMult(n1, n2,r)
     17#define n_Add(n1, n2, r)      (r)->nAdd(n1, n2,r)
     18#define n_IsZero(n, r)        (r)->nIsZero(n,r)
     19#define n_Equal(n1, n2, r)    (r)->nEqual(n1, n2,r)
     20#define n_Neg(n, r)           (r)->nNeg(n,r)
     21#define n_Sub(n1, n2, r)      (r)->nSub(n1, n2,r)
    2122#define n_GetChar(r)          ((r)->ch)
    22 #define n_Init(i, r)          (r)->cf->cfInit(i,r)
    23 #define n_IsOne(n, r)         (r)->cf->nIsOne(n)
    24 #define n_IsMOne(n, r)        (r)->cf->nIsMOne(n)
    25 #define n_GreaterZero(n, r)   (r)->cf->nGreaterZero(n)
    26 #define n_Write(n, r)         (r)->cf->cfWrite(n,r)
    27 #define n_Normalize(n, r)     (r)->cf->nNormalize(n)
    28 #define n_Gcd(a, b, r)        (r)->cf->nGcd(a,b,r)
    29 #define n_IntDiv(a, b, r)     (r)->cf->nIntDiv(a,b)
    30 #define n_Div(a, b, r)        (r)->cf->nDiv(a,b)
    31 #define n_Invers(a, r)     (r)->cf->nInvers(a)
    32 #define n_ExactDiv(a, b, r)   (r)->cf->nExactDiv(a,b)
    33 #define n_Test(a,r)           (r)->cf->nDBTest(a,__FILE__,__LINE__)
    34 
    35 #define n_InpMult(a, b, r)    (r)->cf->nInpMult(a,b,r)
    36 #define n_Power(a, b, res, r) (r)->cf->nPower(a,b,res)
    37 #define n_Size(n,r)           (r)->cf->nSize(n)
    38 #define n_GetDenom(N,r)       (r)->cf->cfGetDenom((N),r)
    39 #define n_GetNumerator(N,r)   (r)->cf->cfGetNumerator((N),r)
     23#define n_Init(i, r)          (r)->cfInit(i,r)
     24#define n_IsOne(n, r)         (r)->nIsOne(n,r)
     25#define n_IsMOne(n, r)        (r)->nIsMOne(n,r)
     26#define n_GreaterZero(n, r)   (r)->nGreaterZero(n,r)
     27#define n_Write(n, r)         (r)->cfWrite(n,r)
     28#define n_Normalize(n, r)     (r)->nNormalize(n,r)
     29#define n_Gcd(a, b, r)        (r)->nGcd(a,b,r)
     30#define n_IntDiv(a, b, r)     (r)->nIntDiv(a,b,r)
     31#define n_Div(a, b, r)        (r)->nDiv(a,b,r)
     32#define n_Invers(a, r)        (r)->nInvers(a,r)
     33#define n_ExactDiv(a, b, r)   (r)->nExactDiv(a,b,r)
     34#define n_Test(a,r)           (r)->nDBTest(a,r,__FILE__,__LINE__)
     35
     36#define n_InpMult(a, b, r)    (r)->nInpMult(a,b,r)
     37#define n_Power(a, b, res, r) (r)->nPower(a,b,res,r)
     38#define n_Size(n,r)           (r)->nSize(n,r)
     39#define n_GetDenom(N,r)       (r)->cfGetDenom((N),r)
     40#define n_GetNumerator(N,r)   (r)->cfGetNumerator((N),r)
    4041
    4142#define n_New(n, r)           nNew(n)
    … …  
    4546
    4647/* prototypes */
    47 extern numberfunc nMult, nSub ,nAdd ,nDiv, nIntDiv, nIntMod, nExactDiv;
    4848void           nNew(number * a);
    49 extern number  (*nInit_bigint)(number i);
    5049#define        nInit(i) n_Init(i,currRing)
    51 extern number  (*nPar)(int i);
    52 extern int     (*nParDeg)(number n);
    53 /* size: a measure for the complexity of the represented number n;
    54          zero should have size zero; larger size means more complex */
    55 extern int     (*nSize)(number n);
    56 extern int     (*n_Int)(number &n, const ring r);
    57 #ifdef HAVE_RINGS
    58 extern int     (*nDivComp)(number a,number b);
    59 extern BOOLEAN (*nIsUnit)(number a);
    60 extern number  (*nGetUnit)(number a);
    61 extern number  (*nExtGcd)(number a, number b, number *s, number *t);
    62 #endif
    63 // always use in the form    n=nNeg(n) !
    64 extern number  (*nNeg)(number a);
    65 extern number  (*nInvers)(number a);
    66 extern number  (*nCopy)(number a);
    67 extern number  (*nRePart)(number a);
    68 extern number  (*nImPart)(number a);
    6950#define nWrite(A) n_Write(A,currRing)
    70 extern const char *  (*nRead)(const char * s, number * a);
    71 extern void    (*nNormalize)(number &a);
    72 extern BOOLEAN (*nGreater)(number a,number b),
    73 #ifdef HAVE_RINGS
    74                (*nDivBy)(number a,number b),
    75 #endif
    76                (*nEqual)(number a,number b),
    77                (*nIsZero)(number a),
    78                (*nIsOne)(number a),
    79                (*nIsMOne)(number a),
    80                (*nGreaterZero)(number a);
    81 extern void    (*nPower)(number a, int i, number * result);
    82 extern number (*nGcd)(number a, number b, const ring r);
    83 extern number (*nLcm)(number a, number b, const ring r);
    84 
    85 extern number nNULL; /* the 0 as constant */
    8651
    8752#define nTest(a) (1)
    … …  
    9156
    9257#define nSetMap(R) (currRing->cf->cfSetMap(R,currRing))
    93 extern char *  (*nName)(number n);
    9458
    9559void nDummy1(number* d);
    96 void ndDelete(number* d, const ring r);
     60void ndDelete(number* d, const coeffs r);
    9761void nDummy2(number &d);
    98 number ndGcd(number a, number b, const ring);
    99 number ndCopy(number a);
    100 void   ndInpMult(number &a, number b, const ring r);
    101 number ndInpAdd(number &a, number b, const ring r);
     62number ndGcd(number a, number b, const coeffs);
     63number ndCopy(number a, const coeffs r);
     64void   ndInpMult(number &a, number b, const coeffs r);
     65number ndInpAdd(number &a, number b, const coeffs r);
    10266
    10367#ifdef LDEBUG
    … …  
    10670#define nGetChar() n_GetChar(currRing)
    10771
    108 void nInitChar(ring r);
    109 void nKillChar(ring r);
    110 void nSetChar(ring r);
     72void nInitChar(coeffs r);
     73void nKillChar(coeffs r);
     74void nSetChar(coeffs r);
    11175
    11276#define nDivBy0 "div by 0"
    … …  
    11478// dummy routines
    11579void   nDummy2(number& d); // nNormalize...
    116 #endif
     80
     81// Tests:
     82#ifdef HAVE_RINGS
     83static inline BOOLEAN nField_is_Ring_2toM(const coeffs r)
     84{ return (r->ringtype == 1); }
     85
     86static inline BOOLEAN nField_is_Ring_ModN(const coeffs r)
     87{ return (r->ringtype == 2); }
     88
     89static inline BOOLEAN nField_is_Ring_PtoM(const coeffs r)
     90{ return (r->ringtype == 3); }
     91
     92static inline BOOLEAN nField_is_Ring_Z(const coeffs r)
     93{ return (r->ringtype == 4); }
     94
     95static inline BOOLEAN nField_is_Ring(const coeffs r)
     96{ return (r->ringtype != 0); }
     97
     98static inline BOOLEAN nField_is_Domain(const coeffs r)
     99{ return (r->ringtype == 4 || r->ringtype == 0); }
     100
     101static inline BOOLEAN nField_has_Units(const coeffs r)
     102{ return ((r->ringtype == 1) || (r->ringtype == 2) || (r->ringtype == 3)); }
     103#else
     104#define nField_is_Ring(A) (0)
     105#endif
     106
     107#ifdef HAVE_RINGS
     108static inline BOOLEAN nField_is_Zp(const coeffs r)
     109{ return (r->ringtype == 0) && (r->ch > 1) && (r->parameter==NULL); }
     110
     111static inline BOOLEAN nField_is_Zp(const coeffs r, int p)
     112{ return (r->ringtype == 0) && (r->ch > 1 && r->ch == ABS(p) && r->parameter==NULL); }
     113
     114static inline BOOLEAN nField_is_Q(const coeffs r)
     115{ return (r->ringtype == 0) && (r->ch == 0) && (r->parameter==NULL); }
     116
     117static inline BOOLEAN nField_is_numeric(const coeffs r) /* R, long R, long C */
     118{ return (r->ringtype == 0) && (r->ch ==  -1); }
     119
     120static inline BOOLEAN nField_is_R(const coeffs r)
     121{
     122  if (nField_is_numeric(r) && (r->float_len <= (short)SHORT_REAL_LENGTH))
     123      return (r->ringtype == 0) && (r->parameter==NULL);
     124  return FALSE;
     125}
     126
     127static inline BOOLEAN nField_is_GF(const coeffs r)
     128{ return (r->ringtype == 0) && (r->ch > 1) && (r->parameter!=NULL); }
     129
     130static inline BOOLEAN nField_is_GF(const coeffs r, int q)
     131{ return (r->ringtype == 0) && (r->ch == q); }
     132
     133static inline BOOLEAN nField_is_Zp_a(const coeffs r)
     134{ return (r->ringtype == 0) && (r->ch < -1); }
     135
     136static inline BOOLEAN nField_is_Zp_a(const coeffs r, int p)
     137{ return (r->ringtype == 0) && (r->ch < -1 ) && (-(r->ch) == ABS(p)); }
     138
     139static inline BOOLEAN nField_is_Q_a(const coeffs r)
     140{ return (r->ringtype == 0) && (r->ch == 1); }
     141
     142static inline BOOLEAN nField_is_long_R(const coeffs r)
     143{
     144  if (nField_is_numeric(r) && (r->float_len >(short)SHORT_REAL_LENGTH))
     145    return (r->ringtype == 0) && (r->parameter==NULL);
     146  return FALSE;
     147}
     148
     149static inline BOOLEAN nField_is_long_C(const coeffs r)
     150{
     151  if (nField_is_numeric(r))
     152    return (r->ringtype == 0) && (r->parameter!=NULL);
     153  return FALSE;
     154}
     155#else
     156static inline BOOLEAN nField_is_Zp(const coeffs r)
     157{ return (r->ch > 1) && (r->parameter==NULL); }
     158
     159static inline BOOLEAN nField_is_Zp(const coeffs r, int p)
     160{ return (r->ch > 1 && r->ch == ABS(p) && r->parameter==NULL); }
     161
     162static inline BOOLEAN nField_is_Q(const coeffs r)
     163{ return (r->ch == 0) && (r->parameter==NULL); }
     164
     165static inline BOOLEAN nField_is_numeric(const coeffs r) /* R, long R, long C */
     166{ return (r->ch ==  -1); }
     167
     168static inline BOOLEAN nField_is_R(const coeffs r)
     169{
     170  if (nField_is_numeric(r) && (r->float_len <= (short)SHORT_REAL_LENGTH))
     171    return (r->parameter==NULL);
     172  return FALSE;
     173}
     174
     175static inline BOOLEAN nField_is_GF(const coeffs r)
     176{ return (r->ch > 1) && (r->parameter!=NULL); }
     177
     178static inline BOOLEAN nField_is_GF(const coeffs r, int q)
     179{ return (r->ch == q); }
     180
     181static inline BOOLEAN nField_is_Zp_a(const coeffs r)
     182{ return (r->ch < -1); }
     183
     184static inline BOOLEAN nField_is_Zp_a(const coeffs r, int p)
     185{ return (r->ch < -1 ) && (-(r->ch) == ABS(p)); }
     186
     187static inline BOOLEAN nField_is_Q_a(const coeffs r)
     188{ return (r->ch == 1); }
     189
     190static inline BOOLEAN nField_is_long_R(const coeffs r)
     191{
     192  if (nField_is_numeric(r) && (r->float_len >(short)SHORT_REAL_LENGTH))
     193    return (r->parameter==NULL);
     194  return FALSE;
     195}
     196
     197static inline BOOLEAN nField_is_long_C(const coeffs r)
     198{
     199  if (nField_is_numeric(r))
     200    return (r->parameter!=NULL);
     201  return FALSE;
     202}
     203#endif
     204
     205static inline BOOLEAN nField_has_simple_inverse(const coeffs r)
     206/* { return (r->ch>1) || (r->ch== -1); } *//* Z/p, GF(p,n), R, long_R, long_C*/
     207#ifdef HAVE_RINGS
     208{ 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*/
     209#else
     210{ return (r->ch>1) || ((r->ch== -1) && (r->float_len < 10)); } /* Z/p, GF(p,n), R, long_R, long_C*/
     211#endif
     212
     213static inline BOOLEAN nField_has_simple_Alloc(const coeffs r)
     214{ return (nField_is_Zp(r)
     215       || nField_is_GF(r)
     216#ifdef HAVE_RINGS
     217       || nField_is_Ring_2toM(r)
     218#endif
     219       || nField_is_R(r));
     220}
     221/* Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies*/
     222
     223static inline BOOLEAN nField_is_Extension(const coeffs r)
     224{ return (nField_is_Q_a(r)) || (nField_is_Zp_a(r)); } /* Z/p(a) and Q(a)*/
     225
     226#endif
Note: See TracChangeset for help on using the changeset viewer.