Ignore:
Timestamp:
Apr 20, 2011, 9:43:24 PM (13 years ago)
Author:
Oleksandr Motsak <motsak@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
03bf555de3ab718b020a7fd0a086b5c2e493dbd0
Parents:
1ddd044275ba5d4433a597ff9edee1abfce81a0e
git-author:
Oleksandr Motsak <motsak@mathematik.uni-kl.de>2011-04-20 21:43:24+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 12:31:23+01:00
Message:
FIX: we can link against libpolys
FIX: rField_*(r...) all should call corresponding nCoeff_*(r->cf...)
ADD: first tests of polynomial rings

TODO for Frank: change ring.* wrt ring-related variables (moved to coeffs &&& renamed!)
TODO: poly. algs. over rings are UNusable at the moment
File:
1 edited

Legend:

Unmodified
Added
Removed

  • libpolys/polys/monomials/ring.h

    r1ddd04 r17e473  
    222222  intvec * pModW;   /* std: module weights */
    223223  poly      ppNoether; /*  variables, set by procedures from hecke/kstd1:
     224
    224225                            the highest monomial below pHEdge */
    225 #ifdef HAVE_RINGS
    226   unsigned int  ringtype;  /* cring = 0 => coefficient field, cring = 1 => coeffs from Z/2^m */
    227   int_number    ringflaga; /* Z/(ringflag^ringflagb)=Z/nrnModul*/
    228   unsigned long ringflagb;
    229   unsigned long nr2mModul;  /* Z/nr2mModul */
    230   int_number    nrnModul;
    231 #endif
     226// #ifdef HAVE_RINGS
     227//   unsigned int  ringtype;  /* cring = 0 => coefficient field, cring = 1 => coeffs from Z/2^m */
     228//   int_number    ringflaga; /* Z/(ringflag^ringflagb)=Z/nrnModul*/
     229//   unsigned long ringflagb;
     230//   unsigned long nr2mModul;  /* Z/nr2mModul */
     231//   int_number    nrnModul;
     232// #endif
     233 
    232234  unsigned long options; /* ring dependent options */
    233235
    … …  
    347349static inline bool rIsPluralRing(const ring r)
    348350{
     351  assume(r != NULL);   
    349352#ifdef HAVE_PLURAL
    350353  nc_struct *n;
    … …  
    357360static inline bool rIsRatGRing(const ring r)
    358361{
     362  assume(r != NULL);
    359363#ifdef HAVE_PLURAL
    360364  /* nc_struct *n; */
    … …  
    413417
    414418#ifdef HAVE_RINGS
    415 static inline BOOLEAN rField_is_Ring_2toM(ring r)
    416 { return (getCoeffType(r->cf) == n_Z2m); }
    417 
    418 static inline BOOLEAN rField_is_Ring_ModN(ring r)
    419 { return (getCoeffType(r->cf) == n_Zn); }
    420 
    421 static inline BOOLEAN rField_is_Ring_PtoM(ring r)
    422 { return (getCoeffType(r->cf) == n_Zpn); }
    423 
    424 static inline BOOLEAN rField_is_Ring_Z(ring r)
    425 { return (getCoeffType(r->cf) == n_Z); }
    426 
    427 static inline BOOLEAN rField_is_Ring(ring r)
    428 { return (r->ringtype != 0); }
    429 
    430 static inline BOOLEAN rField_is_Domain(ring r)
    431 { return (r->ringtype == 4 || r->ringtype == 0); }
    432 
    433 static inline BOOLEAN rField_has_Units(ring r)
    434 { return ((r->ringtype == 1) || (r->ringtype == 2) || (r->ringtype == 3)); }
     419static inline BOOLEAN rField_is_Ring_2toM(const ring r)
     420{ assume(r != NULL); return ( getCoeffType(r->cf) == n_Z2m && nCoeff_is_Ring_2toM(r->cf) ); }
     421
     422static inline BOOLEAN rField_is_Ring_ModN(const ring r)
     423{ assume(r != NULL); return ( getCoeffType(r->cf) == n_Zn && nCoeff_is_Ring_ModN(r->cf) ); }
     424
     425static inline BOOLEAN rField_is_Ring_PtoM(const ring r)
     426{ assume(r != NULL); return (getCoeffType(r->cf) == n_Zpn && nCoeff_is_Ring_PtoM(r->cf) ); }
     427
     428static inline BOOLEAN rField_is_Ring_Z(const ring r)
     429{ assume(r != NULL); return (getCoeffType(r->cf) == n_Z && nCoeff_is_Ring_Z(r->cf) ); }
     430
     431static inline BOOLEAN rField_is_Ring(const ring r)
     432{ assume(r != NULL); return nCoeff_is_Ring(r->cf); }
     433
     434static inline BOOLEAN rField_is_Domain(const ring r)
     435{ assume(r != NULL); return nCoeff_is_Domain(r->cf); }
     436
     437static inline BOOLEAN rField_has_Units(const ring r)
     438{ assume(r != NULL); return nCoeff_has_Units(r->cf); }
    435439#else
    436440#define rField_is_Ring(A) (0)
    … …  
    443447#endif
    444448
    445 static inline BOOLEAN rField_is_Zp(ring r)
    446 { return (getCoeffType(r->cf) == n_Zp); }
    447 
    448 static inline BOOLEAN rField_is_Zp(ring r, int p)
    449 { return (getCoeffType(r->cf) == n_Zp) && (r->ch == p); }
    450 
    451 static inline BOOLEAN rField_is_Q(ring r)
    452 { return (getCoeffType(r->cf) == n_Q); }
    453 
    454 static inline BOOLEAN rField_is_numeric(ring r) /* R, long R, long C */
    455 { return (r->ringtype == 0) && (r->ch ==  -1); }
    456 
    457 static inline BOOLEAN rField_is_R(ring r)
    458 { return (getCoeffType(r->cf) == n_R); }
    459 
    460 static inline BOOLEAN rField_is_GF(ring r)
    461 { return (getCoeffType(r->cf) == n_GF); }
    462 
    463 static inline BOOLEAN rField_is_GF(ring r, int q)
    464 { return (getCoeffType(r->cf) == n_GF) && (r->ch == q); }
    465 
    466 static inline BOOLEAN rField_is_Zp_a(ring r)
    467 { return (r->ringtype == 0) && (r->ch < -1); }
    468 
    469 static inline BOOLEAN rField_is_Zp_a(ring r, int p)
    470 { return (r->ringtype == 0) && (r->ch < -1 ) && (-(r->ch) == ABS(p)); }
    471 
    472 static inline BOOLEAN rField_is_Q_a(ring r)
    473 { return (r->ringtype == 0) && (r->ch == 1); }
    474 
    475 static inline BOOLEAN rField_is_long_R(ring r)
    476 { return (getCoeffType(r->cf) == n_long_R); }
    477 
    478 static inline BOOLEAN rField_is_long_C(ring r)
    479 { return (getCoeffType(r->cf) == n_long_C); }
    480 
    481 static inline BOOLEAN rField_has_simple_inverse(ring r)
    482 /* { return (r->ch>1) || (r->ch== -1); } *//* Z/p, GF(p,n), R, long_R, long_C*/
    483 #ifdef HAVE_RINGS
    484 { 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*/
    485 #else
    486 { return (r->ch>1) || ((r->ch== -1) && (r->float_len < 10)); } /* Z/p, GF(p,n), R, long_R, long_C*/
    487 #endif
    488 
    489 static inline BOOLEAN rField_has_simple_Alloc(ring r)
    490 { return (rField_is_Zp(r)
    491        || rField_is_GF(r)
    492 #ifdef HAVE_RINGS
    493        || rField_is_Ring_2toM(r)
    494 #endif
    495        || rField_is_R(r)); }
     449static inline BOOLEAN rField_is_Zp(const ring r)
     450{ assume(r != NULL); return (getCoeffType(r->cf) == n_Zp); }
     451
     452static inline BOOLEAN rField_is_Zp(const ring r, int p)
     453{ assume(r != NULL); return (getCoeffType(r->cf) == n_Zp) && (r->ch == p); }
     454
     455static inline BOOLEAN rField_is_Q(const ring r)
     456{ assume(r != NULL); return nCoeff_is_Q(r->cf); }
     457
     458static inline BOOLEAN rField_is_numeric(const ring r) /* R, long R, long C */
     459{ assume(r != NULL); return nCoeff_is_numeric(r->cf); }
     460
     461static inline BOOLEAN rField_is_R(const ring r)
     462{ assume(r != NULL); return nCoeff_is_R(r->cf); }
     463
     464static inline BOOLEAN rField_is_GF(const ring r)
     465{ assume(r != NULL); return nCoeff_is_GF(r->cf); }
     466
     467static inline BOOLEAN rField_is_GF(const ring r, int q)
     468{ assume(r != NULL); return nCoeff_is_GF(r->cf, q); }
     469
     470static inline BOOLEAN rField_is_Zp_a(const ring r)
     471{ assume(r != NULL); return nCoeff_is_Zp_a(r->cf); }
     472
     473static inline BOOLEAN rField_is_Zp_a(const ring r, int p)
     474{ assume(r != NULL); return nCoeff_is_Zp_a(r->cf, p); }
     475
     476static inline BOOLEAN rField_is_Q_a(const ring r)
     477{ assume(r != NULL); return nCoeff_is_Q_a(r->cf); }
     478   
     479static inline BOOLEAN rField_is_long_R(const ring r)
     480{ assume(r != NULL); return nCoeff_is_long_R(r->cf); }
     481
     482static inline BOOLEAN rField_is_long_C(const ring r)
     483{ assume(r != NULL); return nCoeff_is_long_C(r->cf); }
     484
     485static inline BOOLEAN rField_has_simple_inverse(const ring r)
     486{ assume(r != NULL); return nCoeff_has_simple_inverse(r->cf); }
     487
     488static inline BOOLEAN rField_has_simple_Alloc(const ring r)
     489{ assume(r != NULL); return nCoeff_has_simple_Alloc(r->cf); }
    496490
    497491/* Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies*/
    498 static inline BOOLEAN rField_is_Extension(ring r)
    499 { return (rField_is_Q_a(r)) || (rField_is_Zp_a(r)); } /* Z/p(a) and Q(a)*/
    500 
    501 n_coeffType rFieldType(ring r);
     492static inline BOOLEAN rField_is_Extension(const ring r)
     493{ assume(r != NULL); return nCoeff_is_Extension(r->cf); } /* Z/p(a) and Q(a)*/
     494
     495n_coeffType rFieldType(const ring r);
    502496
    503497/// this needs to be called whenever a new ring is created: new fields
    … …  
    510504static inline int rBlocks(ring r)
    511505{
     506  assume(r != NULL);
    512507  int i=0;
    513508  while (r->order[i]!=0) i++;
    … …  
    518513static inline char* rRingVar(short i, const ring r)
    519514{
    520   return r->names[i];
     515  assume(r != NULL); return r->names[i];
    521516}
    522517static inline BOOLEAN rShortOut(const ring r)
    523518{
    524   return (r->ShortOut);
     519  assume(r != NULL); return (r->ShortOut);
    525520}
    526521
    … …  
    571566
    572567static inline BOOLEAN rIsSyzIndexRing(const ring r)
    573 { return r->order[0] == ringorder_s;}
     568{ assume(r != NULL); return r->order[0] == ringorder_s;}
    574569
    575570static inline int rGetCurrSyzLimit(const ring r)
    576 { return (rIsSyzIndexRing(r)? r->typ[0].data.syz.limit : 0);}
     571{ assume(r != NULL); return (rIsSyzIndexRing(r)? r->typ[0].data.syz.limit : 0);}
    577572
    578573// Ring Manipulations
    … …  
    619614static inline BOOLEAN rOrd_is_Comp_dp(ring r)
    620615{
     616  assume(r != NULL);
    621617  return ((r->order[0] == ringorder_c || r->order[0] == ringorder_C) &&
    622618          r->order[1] == ringorder_dp &&
Note: See TracChangeset for help on using the changeset viewer.