Changeset 6d0515d in git


Ignore:
Timestamp:
Aug 12, 2016, 11:02:18 AM (8 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '52dcfddee5ec87d404d5e0fb44f2d627608208f1')
Children:
16120ff86476199d17c69372277e4f74d645bad8
Parents:
75b12a8379e8fdc352f1ced846ad6cb2ee44ec22
Message:
chg: use real values for better readability in assume
Location:
libpolys
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • libpolys/coeffs/gnumpc.cc

    r75b12a r6d0515d  
    6868// number ngcMapQ(number from, const coeffs r, const coeffs aRing);
    6969
    70 /// Our Type!
    71 static const n_coeffType ID = n_long_C;
    72 
    73 
    7470#ifdef LDEBUG
    7571// not yet implemented
    7672BOOLEAN ngcDBTest(number, const char *, const int, const coeffs r)
    7773{
    78   assume( getCoeffType(r) == ID );
     74  assume( getCoeffType(r) == n_long_C );
    7975
    8076  return TRUE;
     
    8480number   ngcParameter(int i, const coeffs r)
    8581{
    86   assume( getCoeffType(r) == ID );
     82  assume( getCoeffType(r) == n_long_C );
    8783  assume(i==1);
    8884
     
    9894number ngcInit (long i, const coeffs r)
    9995{
    100   assume( getCoeffType(r) == ID );
     96  assume( getCoeffType(r) == n_long_C );
    10197
    10298  gmp_complex* n= new gmp_complex( (long)i, 0L );
     
    110106long ngcInt(number &i, const coeffs r)
    111107{
    112   assume( getCoeffType(r) == ID );
     108  assume( getCoeffType(r) == n_long_C );
    113109
    114110  return ((gmp_complex*)i)->real();
     
    135131void ngcDelete (number * a, const coeffs r)
    136132{
    137   assume( getCoeffType(r) == ID );
     133  assume( getCoeffType(r) == n_long_C );
    138134
    139135  if ( *a != NULL )
     
    149145number ngcCopy(number a, const coeffs r)
    150146{
    151   assume( getCoeffType(r) == ID );
     147  assume( getCoeffType(r) == n_long_C );
    152148
    153149  gmp_complex* b= new gmp_complex( *(gmp_complex*)a );
     
    161157number ngcNeg (number a, const coeffs R)
    162158{
    163   assume( getCoeffType(R) == ID );
     159  assume( getCoeffType(R) == n_long_C );
    164160
    165161  gmp_complex* r=(gmp_complex*)a;
     
    173169number ngcInvers(number a, const coeffs R)
    174170{
    175   assume( getCoeffType(R) == ID );
     171  assume( getCoeffType(R) == n_long_C );
    176172
    177173  gmp_complex* r = NULL;
     
    192188number ngcAdd (number a, number b, const coeffs R)
    193189{
    194   assume( getCoeffType(R) == ID );
     190  assume( getCoeffType(R) == n_long_C );
    195191
    196192  gmp_complex* r= new gmp_complex( (*(gmp_complex*)a) + (*(gmp_complex*)b) );
     
    203199number ngcSub (number a, number b, const coeffs R)
    204200{
    205   assume( getCoeffType(R) == ID );
     201  assume( getCoeffType(R) == n_long_C );
    206202
    207203  gmp_complex* r= new gmp_complex( (*(gmp_complex*)a) - (*(gmp_complex*)b) );
     
    214210number ngcMult (number a, number b, const coeffs R)
    215211{
    216   assume( getCoeffType(R) == ID );
     212  assume( getCoeffType(R) == n_long_C );
    217213
    218214  gmp_complex* r= new gmp_complex( (*(gmp_complex*)a) * (*(gmp_complex*)b) );
     
    225221number ngcDiv (number a, number b, const coeffs r)
    226222{
    227   assume( getCoeffType(r) == ID );
     223  assume( getCoeffType(r) == n_long_C );
    228224
    229225  if (((gmp_complex*)b)->isZero())
     
    242238void ngcPower ( number x, int exp, number * u, const coeffs r)
    243239{
    244   assume( getCoeffType(r) == ID );
     240  assume( getCoeffType(r) == n_long_C );
    245241
    246242  if ( exp == 0 )
     
    287283BOOLEAN ngcIsZero (number a, const coeffs r)
    288284{
    289   assume( getCoeffType(r) == ID );
     285  assume( getCoeffType(r) == n_long_C );
    290286
    291287  return ( ((gmp_complex*)a)->real().isZero() && ((gmp_complex*)a)->imag().isZero());
     
    294290number ngcRePart(number a, const coeffs r)
    295291{
    296   assume( getCoeffType(r) == ID );
     292  assume( getCoeffType(r) == n_long_C );
    297293
    298294  gmp_complex* n = new gmp_complex(((gmp_complex*)a)->real());
     
    302298number ngcImPart(number a, const coeffs r)
    303299{
    304   assume( getCoeffType(r) == ID );
     300  assume( getCoeffType(r) == n_long_C );
    305301
    306302  gmp_complex* n = new gmp_complex(((gmp_complex*)a)->imag());
     
    313309BOOLEAN ngcGreaterZero (number a, const coeffs r)
    314310{
    315   assume( getCoeffType(r) == ID );
     311  assume( getCoeffType(r) == n_long_C );
    316312
    317313  if ( ! ((gmp_complex*)a)->imag().isZero() )
     
    326322BOOLEAN ngcGreater (number a, number b, const coeffs r)
    327323{
    328   assume( getCoeffType(r) == ID );
     324  assume( getCoeffType(r) == n_long_C );
    329325
    330326  gmp_complex *aa=(gmp_complex*)a;
     
    338334BOOLEAN ngcEqual (number a, number b, const coeffs r)
    339335{
    340   assume( getCoeffType(r) == ID );
     336  assume( getCoeffType(r) == n_long_C );
    341337
    342338  gmp_complex *aa=(gmp_complex*)a;
     
    350346BOOLEAN ngcIsOne (number a, const coeffs r)
    351347{
    352   assume( getCoeffType(r) == ID );
     348  assume( getCoeffType(r) == n_long_C );
    353349
    354350  return (((gmp_complex*)a)->real().isOne() && ((gmp_complex*)a)->imag().isZero());
     
    361357BOOLEAN ngcIsMOne (number a, const coeffs r)
    362358{
    363   assume( getCoeffType(r) == ID );
     359  assume( getCoeffType(r) == n_long_C );
    364360
    365361  return (((gmp_complex*)a)->real().isMOne() && ((gmp_complex*)a)->imag().isZero());
     
    372368const char * ngcRead (const char * s, number * a, const coeffs r)
    373369{
    374   assume( getCoeffType(r) == ID );
     370  assume( getCoeffType(r) == n_long_C );
    375371  const char * const complex_parameter = n_ParameterNames(r)[0];
    376372  assume( complex_parameter != NULL );
     
    405401void ngcWrite (number a, const coeffs r)
    406402{
    407   assume( getCoeffType(r) == ID );
     403  assume( getCoeffType(r) == n_long_C );
    408404
    409405  if (a==NULL)
     
    421417BOOLEAN ngcCoeffIsEqual (const coeffs r, n_coeffType n, void * parameter)
    422418{
    423   if (n==ID)
     419  if (n==n_long_C)
    424420  {
    425421    LongComplexInfo* p = (LongComplexInfo *)(parameter);
     
    464460BOOLEAN ngcInitChar(coeffs n, void* parameter)
    465461{
    466   assume( getCoeffType(n) == ID );
     462  assume( getCoeffType(n) == n_long_C );
    467463  n->is_field=TRUE;
    468464  n->is_domain=TRUE;
     
    613609number ngcMapQ(number from, const coeffs aRing, const coeffs r)
    614610{
    615   assume( getCoeffType(r) == ID );
     611  assume( getCoeffType(r) == n_long_C );
    616612  assume( aRing->rep == n_rep_gap_rat);
    617613
     
    627623number ngcMapZ(number from, const coeffs aRing, const coeffs r)
    628624{
    629   assume( getCoeffType(r) == ID );
     625  assume( getCoeffType(r) == n_long_C );
    630626  assume( aRing->rep == n_rep_gap_gmp);
    631627
     
    648644static number ngcMapLongR(number from, const coeffs aRing, const coeffs r)
    649645{
    650   assume( getCoeffType(r) == ID );
     646  assume( getCoeffType(r) == n_long_C );
    651647  assume( getCoeffType(aRing) == n_long_R );
    652648
     
    662658static number ngcMapR(number from, const coeffs aRing, const coeffs r)
    663659{
    664   assume( getCoeffType(r) == ID );
     660  assume( getCoeffType(r) == n_long_C );
    665661  assume( getCoeffType(aRing) == n_R );
    666662
     
    676672static number ngcMapP(number from, const coeffs aRing, const coeffs r)
    677673{
    678   assume( getCoeffType(r) == ID );
     674  assume( getCoeffType(r) == n_long_C );
    679675  assume( getCoeffType(aRing) ==  n_Zp );
    680676
     
    687683static number ngcCopyMap(number from, const coeffs aRing, const coeffs r)
    688684{
    689   assume( getCoeffType(r) == ID );
    690   assume( getCoeffType(aRing) ==  ID );
     685  assume( getCoeffType(r) == n_long_C );
     686  assume( getCoeffType(aRing) ==  n_long_C );
    691687
    692688  gmp_complex* b = NULL;
     
    701697nMapFunc ngcSetMap(const coeffs src, const coeffs dst)
    702698{
    703   assume( getCoeffType(dst) == ID );
     699  assume( getCoeffType(dst) == n_long_C );
    704700
    705701  if (src->rep==n_rep_gap_rat) /* Q, Z*/
  • libpolys/coeffs/gnumpfl.cc

    r75b12a r6d0515d  
    2323
    2424//ring ngfMapRing; // to be used also in gnumpc.cc
    25 
    26 /// Our Type!
    27 static const n_coeffType ID = n_long_R;
    2825
    2926/// Get a mapping function from src into the domain of this type:
     
    7370number ngfInit (long i, const coeffs r)
    7471{
    75   assume( getCoeffType(r) == ID );
     72  assume( getCoeffType(r) == n_long_R );
    7673
    7774  gmp_float* n= new gmp_float( (double)i );
     
    8481long ngfInt(number &i, const coeffs r)
    8582{
    86   assume( getCoeffType(r) == ID );
     83  assume( getCoeffType(r) == n_long_R );
    8784
    8885  double d=(double)*(gmp_float*)i;
     
    109106void ngfDelete (number * a, const coeffs r)
    110107{
    111   assume( getCoeffType(r) == ID );
     108  assume( getCoeffType(r) == n_long_R );
    112109
    113110  if ( *a != NULL )
     
    123120number ngfCopy(number a, const coeffs r)
    124121{
    125   assume( getCoeffType(r) == ID );
     122  assume( getCoeffType(r) == n_long_R );
    126123
    127124  gmp_float* b= new gmp_float( *(gmp_float*)a );
     
    132129static number ngfCopyMap(number a, const coeffs r1, const coeffs r2)
    133130{
    134   assume( getCoeffType(r1) == ID );
    135   assume( getCoeffType(r2) == ID );
     131  assume( getCoeffType(r1) == n_long_R );
     132  assume( getCoeffType(r2) == n_long_R );
    136133
    137134  gmp_float* b= NULL;
     
    149146number ngfNeg (number a, const coeffs r)
    150147{
    151   assume( getCoeffType(r) == ID );
     148  assume( getCoeffType(r) == n_long_R );
    152149
    153150  *(gmp_float*)a= -(*(gmp_float*)a);
     
    160157number ngfInvers(number a, const coeffs r)
    161158{
    162   assume( getCoeffType(r) == ID );
     159  assume( getCoeffType(r) == n_long_R );
    163160
    164161  gmp_float* f= NULL;
     
    179176number ngfAdd (number a, number b, const coeffs R)
    180177{
    181   assume( getCoeffType(R) == ID );
     178  assume( getCoeffType(R) == n_long_R );
    182179
    183180  gmp_float* r= new gmp_float( (*(gmp_float*)a) + (*(gmp_float*)b) );
     
    190187number ngfSub (number a, number b, const coeffs R)
    191188{
    192   assume( getCoeffType(R) == ID );
     189  assume( getCoeffType(R) == n_long_R );
    193190
    194191  gmp_float* r= new gmp_float( (*(gmp_float*)a) - (*(gmp_float*)b) );
     
    201198number ngfMult (number a, number b, const coeffs R)
    202199{
    203   assume( getCoeffType(R) == ID );
     200  assume( getCoeffType(R) == n_long_R );
    204201
    205202  gmp_float* r= new gmp_float( (*(gmp_float*)a) * (*(gmp_float*)b) );
     
    212209number ngfDiv (number a, number b, const coeffs r)
    213210{
    214   assume( getCoeffType(r) == ID );
     211  assume( getCoeffType(r) == n_long_R );
    215212
    216213  if ( ((gmp_float*)b)->isZero() )
     
    229226number ngfPower (number x, int exp, const coeffs r)
    230227{
    231   assume( getCoeffType(r) == ID );
     228  assume( getCoeffType(r) == n_long_R );
    232229
    233230  if ( exp == 0 )
     
    255252BOOLEAN ngfIsZero (number a, const coeffs r)
    256253{
    257   assume( getCoeffType(r) == ID );
     254  assume( getCoeffType(r) == n_long_R );
    258255
    259256  return ( ((gmp_float*)a)->isZero() );
     
    265262BOOLEAN ngfGreaterZero (number a, const coeffs r)
    266263{
    267   assume( getCoeffType(r) == ID );
     264  assume( getCoeffType(r) == n_long_R );
    268265
    269266  return (((gmp_float*)a)->sign() > 0);
     
    275272BOOLEAN ngfGreater (number a, number b, const coeffs r)
    276273{
    277   assume( getCoeffType(r) == ID );
     274  assume( getCoeffType(r) == n_long_R );
    278275
    279276  return ( (*(gmp_float*)a) > (*(gmp_float*)b) );
     
    285282BOOLEAN ngfEqual (number a, number b, const coeffs r)
    286283{
    287   assume( getCoeffType(r) == ID );
     284  assume( getCoeffType(r) == n_long_R );
    288285
    289286  return ( (*(gmp_float*)a) == (*(gmp_float*)b) );
     
    295292BOOLEAN ngfIsOne (number a, const coeffs r)
    296293{
    297   assume( getCoeffType(r) == ID );
     294  assume( getCoeffType(r) == n_long_R );
    298295
    299296  return ((gmp_float*)a)->isOne();
     
    305302BOOLEAN ngfIsMOne (number a, const coeffs r)
    306303{
    307   assume( getCoeffType(r) == ID );
     304  assume( getCoeffType(r) == n_long_R );
    308305
    309306  return ((gmp_float*)a)->isMOne();
     
    341338const char * ngfRead (const char * start, number * a, const coeffs r)
    342339{
    343   assume( getCoeffType(r) == ID or getCoeffType(r) == n_long_C);
     340  assume( getCoeffType(r) == n_long_R or getCoeffType(r) == n_long_C);
    344341
    345342  char *s= (char *)start;
     
    400397void ngfWrite (number a, const coeffs r)
    401398{
    402   assume( getCoeffType(r) == ID );
     399  assume( getCoeffType(r) == n_long_R );
    403400
    404401  char *out;
     
    418415BOOLEAN ngfCoeffIsEqual (const coeffs r, n_coeffType n, void * parameter)
    419416{
    420   if (n==ID)
     417  if (n==n_long_R)
    421418  {
    422419    LongComplexInfo* p = (LongComplexInfo *)(parameter);
     
    443440BOOLEAN ngfInitChar(coeffs n, void *parameter)
    444441{
    445   assume( getCoeffType(n) == ID );
     442  assume( getCoeffType(n) == n_long_R );
    446443
    447444  n->is_field=TRUE;
     
    506503number ngfMapQ(number from, const coeffs src, const coeffs dst)
    507504{
    508   assume( getCoeffType(dst) == ID );
     505  assume( getCoeffType(dst) == n_long_R );
    509506  assume( src->rep == n_rep_gap_rat );
    510507
     
    514511number ngfMapZ(number from, const coeffs aRing, const coeffs r)
    515512{
    516   assume( getCoeffType(r) == ID );
     513  assume( getCoeffType(r) == n_long_R );
    517514  assume( aRing->rep == n_rep_gap_gmp);
    518515
     
    536533static number ngfMapR(number from, const coeffs src, const coeffs dst)
    537534{
    538   assume( getCoeffType(dst) == ID );
     535  assume( getCoeffType(dst) == n_long_R );
    539536  assume( getCoeffType(src) == n_R );
    540537
     
    545542static number ngfMapP(number from, const coeffs src, const coeffs dst)
    546543{
    547   assume( getCoeffType(dst) == ID );
     544  assume( getCoeffType(dst) == n_long_R );
    548545  assume( getCoeffType(src) ==  n_Zp );
    549546
     
    553550static number ngfMapC(number from, const coeffs src, const coeffs dst)
    554551{
    555   assume( getCoeffType(dst) == ID );
     552  assume( getCoeffType(dst) == n_long_R );
    556553  assume( getCoeffType(src) ==  n_long_C );
    557554
     
    562559nMapFunc ngfSetMap(const coeffs src, const coeffs dst)
    563560{
    564   assume( getCoeffType(dst) == ID );
     561  assume( getCoeffType(dst) == n_long_R );
    565562
    566563  if (src->rep==n_rep_gap_rat) /*Q, Z*/
  • libpolys/coeffs/modulop.cc

    r75b12a r6d0515d  
    2424
    2525#include <string.h>
    26 
    27 /// Our Type!
    28 static const n_coeffType ID = n_Zp;
    2926
    3027BOOLEAN npGreaterZero (number k, const coeffs r);
     
    7673static inline number nvMultM(number a, number b, const coeffs r)
    7774{
    78   assume( getCoeffType(r) == ID );
     75  assume( getCoeffType(r) == n_Zp );
    7976
    8077#if SIZEOF_LONG == 4
     
    498495BOOLEAN npInitChar(coeffs r, void* p)
    499496{
    500   assume( getCoeffType(r) == ID );
     497  assume( getCoeffType(r) == n_Zp );
    501498  const int c = (int) (long) p;
    502499
  • libpolys/coeffs/rintegers.cc

    r75b12a r6d0515d  
    2828#ifdef HAVE_RINGS
    2929
    30 
    31 /// Our Type!
    32 static const n_coeffType ID = n_Z;
    3330
    3431number  nrzCopy        (number a, const coeffs r);
     
    487484BOOLEAN nrzInitChar(coeffs r,  void *)
    488485{
    489   assume( getCoeffType(r) == ID );
     486  assume( getCoeffType(r) == n_Z );
    490487
    491488  r->is_field=FALSE;
     
    17101707BOOLEAN nrzInitChar(coeffs r,  void *)
    17111708{
    1712   assume( getCoeffType(r) == ID );
     1709  assume( getCoeffType(r) == n_Z );
    17131710
    17141711  r->is_field=FALSE;
  • libpolys/coeffs/rmodulo2m.cc

    r75b12a r6d0515d  
    2424
    2525#ifdef HAVE_RINGS
    26 
    27 /// Our Type!
    28 static const n_coeffType ID = n_Z2m;
    2926
    3027number  nr2mCopy        (number a, const coeffs r);
     
    160157BOOLEAN nr2mInitChar (coeffs r, void* p)
    161158{
    162   assume( getCoeffType(r) == ID );
     159  assume( getCoeffType(r) == n_Z2m );
    163160  nr2mInitExp((int)(long)(p), r);
    164161
  • libpolys/coeffs/rmodulon.cc

    r75b12a r6d0515d  
    2323
    2424#ifdef HAVE_RINGS
    25 
    26 /// Our Type!
    27 static const n_coeffType ID = n_Zn;
    28 static const n_coeffType ID2 = n_Znm;
    2925
    3026number  nrnCopy        (number a, const coeffs r);
     
    163159BOOLEAN nrnInitChar (coeffs r, void* p)
    164160{
    165   assume( (getCoeffType(r) == ID) || (getCoeffType (r) == ID2) );
     161  assume( (getCoeffType(r) == n_Zn) || (getCoeffType (r) == n_Znm) );
    166162  ZnmInfo * info= (ZnmInfo *) p;
    167163  r->modBase= (mpz_ptr)nrnCopy((number)info->base, r); //this circumvents the problem
  • libpolys/coeffs/shortfl.cc

    r75b12a r6d0515d  
    2323#include <string.h>
    2424#include <math.h>
    25 
    26 /// Our Type!
    27 static const n_coeffType ID = n_R;
    2825
    2926// Private interface should be hidden!!!
     
    8481void    nrCoeffWrite  (const coeffs r, BOOLEAN /*details*/)
    8582{
    86   assume( getCoeffType(r) == ID );
     83  assume( getCoeffType(r) == n_R );
    8784  PrintS("//   characteristic : 0 (real)\n");  /* R */
    8885}
     
    9188BOOLEAN nrGreaterZero (number k, const coeffs r)
    9289{
    93   assume( getCoeffType(r) == ID );
     90  assume( getCoeffType(r) == n_R );
    9491
    9592  return nf(k).F() >= 0.0;
     
    9895number nrMult (number a,number b, const coeffs r)
    9996{
    100   assume( getCoeffType(r) == ID );
     97  assume( getCoeffType(r) == n_R );
    10198
    10299  return nf(nf(a).F() * nf(b).F()).N();
     
    108105number nrInit (long i, const coeffs r)
    109106{
    110   assume( getCoeffType(r) == ID );
     107  assume( getCoeffType(r) == n_R );
    111108
    112109  float f = (float)i;
     
    119116long nrInt(number &n, const coeffs r)
    120117{
    121   assume( getCoeffType(r) == ID );
     118  assume( getCoeffType(r) == n_R );
    122119
    123120  long i;
     
    144141number nrAdd (number a, number b, const coeffs r)
    145142{
    146   assume( getCoeffType(r) == ID );
     143  assume( getCoeffType(r) == n_R );
    147144
    148145  float x = nf(a).F();
     
    176173number nrSub (number a, number b, const coeffs r)
    177174{
    178   assume( getCoeffType(r) == ID );
     175  assume( getCoeffType(r) == n_R );
    179176
    180177  float x = nf(a).F();
     
    208205BOOLEAN nrIsZero (number  a, const coeffs r)
    209206{
    210   assume( getCoeffType(r) == ID );
     207  assume( getCoeffType(r) == n_R );
    211208
    212209  return (0.0 == nf(a).F());
     
    215212BOOLEAN nrIsOne (number a, const coeffs r)
    216213{
    217   assume( getCoeffType(r) == ID );
     214  assume( getCoeffType(r) == n_R );
    218215
    219216  float aa=nf(a).F()-1.0;
     
    224221BOOLEAN nrIsMOne (number a, const coeffs r)
    225222{
    226   assume( getCoeffType(r) == ID );
     223  assume( getCoeffType(r) == n_R );
    227224
    228225  float aa=nf(a).F()+1.0;
     
    233230number nrDiv (number a,number b, const coeffs r)
    234231{
    235   assume( getCoeffType(r) == ID );
     232  assume( getCoeffType(r) == n_R );
    236233
    237234  float n = nf(b).F();
     
    247244number  nrInvers (number c, const coeffs r)
    248245{
    249   assume( getCoeffType(r) == ID );
     246  assume( getCoeffType(r) == n_R );
    250247
    251248  float n = nf(c).F();
     
    260257number nrNeg (number c, const coeffs r)
    261258{
    262   assume( getCoeffType(r) == ID );
     259  assume( getCoeffType(r) == n_R );
    263260
    264261  return nf(-nf(c).F()).N();
     
    267264BOOLEAN nrGreater (number a,number b, const coeffs r)
    268265{
    269   assume( getCoeffType(r) == ID );
     266  assume( getCoeffType(r) == n_R );
    270267
    271268  return nf(a).F() > nf(b).F();
     
    274271BOOLEAN nrEqual (number a,number b, const coeffs r)
    275272{
    276   assume( getCoeffType(r) == ID );
     273  assume( getCoeffType(r) == n_R );
    277274
    278275  number x = nrSub(a,b,r);
     
    282279void nrWrite (number a, const coeffs r)
    283280{
    284   assume( getCoeffType(r) == ID );
     281  assume( getCoeffType(r) == n_R );
    285282
    286283  char ch[11];
     
    304301void nrPower (number a, int i, number * result, const coeffs r)
    305302{
    306   assume( getCoeffType(r) == ID );
     303  assume( getCoeffType(r) == n_R );
    307304
    308305  if (i==0)
     
    345342{
    346343
    347   assume( getCoeffType(r) == ID );
     344  assume( getCoeffType(r) == n_R );
    348345
    349346  static const char *nIllegalChar="illegal character in number";
     
    415412BOOLEAN  nrDBTest(number a, const char *f, const int l, const coeffs r)
    416413{
    417   assume( getCoeffType(r) == ID );
     414  assume( getCoeffType(r) == n_R );
    418415
    419416  return TRUE;
     
    423420static number nrMapP(number from, const coeffs aRing, const coeffs r)
    424421{
    425   assume( getCoeffType(r) == ID );
     422  assume( getCoeffType(r) == n_R );
    426423  assume( getCoeffType(aRing) ==  n_Zp );
    427424
     
    433430static number nrMapLongR(number from, const coeffs aRing, const coeffs r)
    434431{
    435   assume( getCoeffType(r) == ID );
     432  assume( getCoeffType(r) == n_R );
    436433  assume( getCoeffType(aRing) == n_long_R );
    437434
     
    442439static number nrMapC(number from, const coeffs aRing, const coeffs r)
    443440{
    444   assume( getCoeffType(r) == ID );
     441  assume( getCoeffType(r) == n_R );
    445442  assume( getCoeffType(aRing) == n_long_C );
    446443
     
    463460#define GET_DENOM(A) ((A)->n)
    464461
    465   assume( getCoeffType(r) == ID );
     462  assume( getCoeffType(r) == n_R );
    466463  assume( aRing->rep == n_rep_gap_rat );
    467464
     
    538535number nrMapZ(number from, const coeffs aRing, const coeffs r)
    539536{
    540   assume( getCoeffType(r) == ID );
     537  assume( getCoeffType(r) == n_R );
    541538  assume( aRing->rep == n_rep_gap_gmp );
    542539
     
    599596// #define MPZ_CLEAR mpz_clear
    600597
    601 //   assume( getCoeffType(r) == ID );
     598//   assume( getCoeffType(r) == n_R );
    602599//   assume( getCoeffType(aRing) == n_Q );
    603600
     
    697694nMapFunc nrSetMap(const coeffs src, const coeffs dst)
    698695{
    699   assume( getCoeffType(dst) == ID );
     696  assume( getCoeffType(dst) == n_R );
    700697
    701698  if (src->rep==n_rep_gap_rat) /*Q, Z */
     
    733730BOOLEAN nrInitChar(coeffs n, void* p)
    734731{
    735   assume( getCoeffType(n) == ID );
     732  assume( getCoeffType(n) == n_R );
    736733
    737734  assume( p == NULL );
  • libpolys/polys/ext_fields/transext.cc

    r75b12a r6d0515d  
    7777#define ntTest(a) n_Test(a, cf)
    7878
    79 /// Our own type!
    80 static const n_coeffType ID = n_transExt;
    81 
    8279/* polynomial ring in which the numerators and denominators of our
    8380   numbers live */
     
    175172BOOLEAN ntDBTest(number a, const char *f, const int l, const coeffs cf)
    176173{
    177   assume(getCoeffType(cf) == ID);
     174  assume(getCoeffType(cf) == n_transExt);
    178175
    179176  if (IS0(a)) return TRUE;
     
    15941591static BOOLEAN ntCoeffIsEqual(const coeffs cf, n_coeffType n, void * param)
    15951592{
    1596   if (ID != n) return FALSE;
     1593  if (n_transExt != n) return FALSE;
    15971594  TransExtInfo *e = (TransExtInfo *)param;
    15981595  /* for rational function fields we expect the underlying
     
    21072104{
    21082105  /* dst is expected to be a rational function field */
    2109   assume(getCoeffType(dst) == ID);
     2106  assume(getCoeffType(dst) == n_transExt);
    21102107
    21112108  if( src == dst ) return ndCopyMap;
     
    22182215static number ntParameter(const int iParameter, const coeffs cf)
    22192216{
    2220   assume(getCoeffType(cf) == ID);
     2217  assume(getCoeffType(cf) == n_transExt);
    22212218
    22222219  const ring R = cf->extRing;
     
    22412238{
    22422239  ntTest(m);
    2243   assume(getCoeffType(cf) == ID);
     2240  assume(getCoeffType(cf) == n_transExt);
    22442241
    22452242  const ring R = cf->extRing;
     
    22672264{
    22682265  assume(cf != NULL);
    2269   assume(getCoeffType(cf) == ID);
     2266  assume(getCoeffType(cf) == n_transExt);
    22702267  // all coeffs are given by fractions of polynomails over integers!!!
    22712268  // without denominators!!!
     
    23562353{
    23572354  assume(cf != NULL);
    2358   assume(getCoeffType(cf) == ID); // both over Q(a) and Zp(a)!
     2355  assume(getCoeffType(cf) == n_transExt); // both over Q(a) and Zp(a)!
    23592356  // all coeffs are given by fractions of polynomails over integers!!!
    23602357
     
    25492546
    25502547  assume( cf != NULL );
    2551   assume(getCoeffType(cf) == ID);                // coeff type;
     2548  assume(getCoeffType(cf) == n_transExt);                // coeff type;
    25522549
    25532550  ring R = e->r;
Note: See TracChangeset for help on using the changeset viewer.