Changeset 925a43c in git


Ignore:
Timestamp:
Jun 21, 2010, 7:12:01 PM (13 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'f875bbaccd0831e36aaed09ff6adeb3eb45aeb94')
Children:
4d1ae5af2805ed797a6a992f88a4bb83fbc625f8
Parents:
37d3186ad34a5dcbcd56103bd58674b22a5b236b
git-author:
Hans Schoenemann <hannes@mathematik.uni-kl.de>2010-06-21 19:12:01+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 11:55:15+01:00
Message:
fixes for rmodulo2m
Location:
coeffs
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • coeffs/rmodulo2m.cc

    r37d318 r925a43c  
    2424int nr2mExp;
    2525
     26extern omBin gmp_nrz_bin; /* init in rintegers*/
     27
    2628/* for initializing function pointers */
    2729void nr2mInitChar (coeffs r, void*)
    2830{
    29      nr2mInitExp(c, r);
    30      n->cfInit       = nr2mInit;
    31      n->cfCopy       = nr2mCopy;
    32      n->n_Int        = nr2mInt;
    33      n->nAdd         = nr2mAdd;
    34      n->nSub         = nr2mSub;
    35      n->nMult        = nr2mMult;
    36      n->nDiv         = nr2mDiv;
    37      n->nIntDiv      = nr2mIntDiv;
    38      n->nIntMod      = nr2mMod;
    39      n->nExactDiv    = nr2mDiv;
    40      n->nNeg         = nr2mNeg;
    41      n->nInvers      = nr2mInvers;
    42      n->nDivBy       = nr2mDivBy;
    43      n->nDivComp     = nr2mDivComp;
    44      n->nGreater     = nr2mGreater;
    45      n->nEqual       = nr2mEqual;
    46      n->nIsZero      = nr2mIsZero;
    47      n->nIsOne       = nr2mIsOne;
    48      n->nIsMOne      = nr2mIsMOne;
    49      n->nGreaterZero = nr2mGreaterZero;
    50      n->cfWrite      = nr2mWrite;
    51      n->nRead        = nr2mRead;
    52      n->nPower       = nr2mPower;
    53      n->cfSetMap     = nr2mSetMap;
    54      n->nNormalize   = ndNormalize;
    55      n->nLcm         = nr2mLcm;
    56      n->nGcd         = nr2mGcd;
    57      n->nIsUnit      = nr2mIsUnit;
    58      n->nGetUnit     = nr2mGetUnit;
    59      n->nExtGcd      = nr2mExtGcd;
    60      n->nName        = ndName;
     31     nr2mInitExp(r->ch, r);
     32     r->cfInit       = nr2mInit;
     33     r->cfCopy       = ndCopy;
     34     r->cfInt        = nr2mInt;
     35     r->cfAdd         = nr2mAdd;
     36     r->cfSub         = nr2mSub;
     37     r->cfMult        = nr2mMult;
     38     r->cfDiv         = nr2mDiv;
     39     r->cfIntDiv      = nr2mIntDiv;
     40     r->cfIntMod      = nr2mMod;
     41     r->cfExactDiv    = nr2mDiv;
     42     r->cfNeg         = nr2mNeg;
     43     r->cfInvers      = nr2mInvers;
     44     r->cfDivBy       = nr2mDivBy;
     45     r->cfDivComp     = nr2mDivComp;
     46     r->cfGreater     = nr2mGreater;
     47     r->cfEqual       = nr2mEqual;
     48     r->cfIsZero      = nr2mIsZero;
     49     r->cfIsOne       = nr2mIsOne;
     50     r->cfIsMOne      = nr2mIsMOne;
     51     r->cfGreaterZero = nr2mGreaterZero;
     52     r->cfWrite      = nr2mWrite;
     53     r->cfRead        = nr2mRead;
     54     r->cfPower       = nr2mPower;
     55     r->cfSetMap     = nr2mSetMap;
     56     r->cfNormalize   = ndNormalize;
     57     r->cfLcm         = nr2mLcm;
     58     r->cfGcd         = nr2mGcd;
     59     r->cfIsUnit      = nr2mIsUnit;
     60     r->cfGetUnit     = nr2mGetUnit;
     61     r->cfExtGcd      = nr2mExtGcd;
     62     r->cfName        = ndName;
    6163#ifdef LDEBUG
    62      n->nDBTest      = nr2mDBTest;
     64     r->cfDBTest      = nr2mDBTest;
    6365#endif
    6466}
    … …  
    7274    return (number)0;
    7375  else
    74     return nr2mMultM(a,b);
     76    return nr2mMultM(a,b,r);
    7577}
    7678
    … …  
    138140  {
    139141    *t = NULL;
    140     *s = nr2mInvers(a);
     142    *s = nr2mInvers(a,r);
    141143    return (number) ((1L << res));// * (NATNUMBER) a);  // (2**res)*a    a ist Einheit
    142144  }
    … …  
    144146  {
    145147    *s = NULL;
    146     *t = nr2mInvers(b);
     148    *t = nr2mInvers(b,r);
    147149    return (number) ((1L << res));// * (NATNUMBER) b);  // (2**res)*b    b ist Einheit
    148150  }
    … …  
    161163  else
    162164  {
    163     nr2mPower(a,i-1,result);
    164     *result = nr2mMultM(a,*result);
     165    nr2mPower(a,i-1,result,r);
     166    *result = nr2mMultM(a,*result,r);
    165167  }
    166168}
    … …  
    200202number nr2mAdd (number a, number b, const coeffs r)
    201203{
    202   return nr2mAddM(a,b);
     204  return nr2mAddM(a,b,r);
    203205}
    204206
    205207number nr2mSub (number a, number b, const coeffs r)
    206208{
    207   return nr2mSubM(a,b);
     209  return nr2mSubM(a,b,r);
    208210}
    209211
    … …  
    241243BOOLEAN nr2mEqual (number a, number b, const coeffs r)
    242244{
    243   return nr2mEqualM(a,b);
     245  return a==b;
    244246}
    245247
    246248BOOLEAN nr2mGreater (number a, number b, const coeffs r)
    247249{
    248   return nr2mDivBy(a, b);
     250  return nr2mDivBy(a, b,r);
    249251}
    250252
    … …  
    390392{
    391393  assume((NATNUMBER)c % 2 != 0);
    392   return (number)InvMod((NATNUMBER)c);
     394  // Table !!!
     395  NATNUMBER inv;
     396  inv = InvMod((NATNUMBER)c,r);
     397  return (number) inv;
    393398}
    394399
    … …  
    414419    }
    415420  }
    416   return (number) nr2mMult(a, nr2mInversM(b));
     421  return (number) nr2mMult(a, nr2mInversM(b,r),r);
    417422}
    418423
    … …  
    492497    return (number)0;
    493498  }
    494   return nr2mInversM(c);
     499  return nr2mInversM(c,r);
    495500}
    496501
    … …  
    498503{
    499504  if ((NATNUMBER)c==0) return c;
    500   return nr2mNegM(c);
    501 }
    502 
    503 number nr2mMapMachineInt(number from, const coeffs r)
    504 {
    505   NATNUMBER i = ((NATNUMBER) from) % r->nr2mModul ;
     505  return nr2mNegM(c,r);
     506}
     507
     508number nr2mMapMachineInt(number from, const coeffs src, const coeffs dst)
     509{
     510  NATNUMBER i = ((NATNUMBER) from) % dst->nr2mModul ;
    506511  return (number) i;
    507512}
    508513
    509 number nr2mCopy(number a, const coeffs)
    510 {
    511   return a;
    512 }
    513 
    514 number nr2mMapZp(number from, const coeffs r)
    515 {
    516   long ii = (long)from;
     514number nr2mMapZp(number from, const coeffs src, const coeffs dst)
     515{
    517516  NATNUMBER j = (NATNUMBER)1;
    518   if (ii < 0) { j = r->nr2mModul; ii = -ii; }
     517  long ii = (long) from;
     518  if (ii < 0) { j = dst->nr2mModul; ii = -ii; }
    519519  NATNUMBER i = (NATNUMBER)ii;
    520   i = i & r->nr2mModul;
     520  i = i & dst->nr2mModul;
    521521  /* now we have: from = j * i mod 2^m */
    522   return (number)nr2mMult((number)i, (number)j);
    523 }
    524 
    525 number nr2mMapQ(number from, const coeffs r)
    526 {
    527   int_number erg = (int_number) omAlloc(sizeof(mpz_t));
     522  return (number)nr2mMult((number)i, (number)j, dst);
     523}
     524
     525number nr2mMapQ(number from, const coeffs src, const coeffs dst)
     526{
     527  int_number erg = (int_number)  omAllocBin(gmp_nrz_bin);
    528528  mpz_init(erg);
    529529  int_number k = (int_number) omAlloc(sizeof(mpz_t));
    530   mpz_init_set_ui(k, r->nr2mModul);
     530  mpz_init_set_ui(k, dst->nr2mModul);
    531531
    532532  nlGMP(from, (number)erg);
    … …  
    540540}
    541541
    542 number nr2mMapGMP(number from, const coeffs r)
    543 {
    544   int_number erg = (int_number) omAlloc(sizeof(mpz_t));
     542number nr2mMapGMP(number from, const coeffs src, const coeffs dst)
     543{
     544  int_number erg = (int_number)  omAllocBin(gmp_nrz_bin);
    545545  mpz_init(erg);
    546546  int_number k = (int_number) omAlloc(sizeof(mpz_t));
    547   mpz_init_set_ui(k, r->nr2mModul);
     547  mpz_init_set_ui(k, dst->nr2mModul);
    548548
    549549  mpz_and(erg, (int_number)from, k);
    … …  
    556556}
    557557
    558 nMapFunc nr2mSetMap(const ring src, const ring dst)
    559 {
    560   if (rField_is_Ring_2toM(src)
     558nMapFunc nr2mSetMap(const coeffs src, const coeffs dst)
     559{
     560  if (nField_is_Ring_2toM(src)
    561561     && (src->ringflagb == dst->ringflagb))
    562562  {
    563     return nr2mCopy;
    564   }
    565   if (rField_is_Ring_2toM(src)
     563    return ndCopyMap;
     564  }
     565  if (nField_is_Ring_2toM(src)
    566566     && (src->ringflagb < dst->ringflagb))
    567567  { /* i.e. map an integer mod 2^s into Z mod 2^t, where t < s */
    568568    return nr2mMapMachineInt;
    569569  }
    570   if (rField_is_Ring_2toM(src)
     570  if (nField_is_Ring_2toM(src)
    571571     && (src->ringflagb > dst->ringflagb))
    572572  { /* i.e. map an integer mod 2^s into Z mod 2^t, where t > s */
    573573    // to be done
    574574  }
    575   if (rField_is_Ring_Z(src))
     575  if (nField_is_Ring_Z(src))
    576576  {
    577577    return nr2mMapGMP;
    578578  }
    579   if (rField_is_Q(src))
     579  if (nField_is_Q(src))
    580580  {
    581581    return nr2mMapQ;
    582582  }
    583   if (rField_is_Zp(src)
     583  if (nField_is_Zp(src)
    584584     && (src->ch == 2)
    585585     && (dst->ringflagb == 1))
    … …  
    587587    return nr2mMapZp;
    588588  }
    589   if (rField_is_Ring_PtoM(src) || rField_is_Ring_ModN(src))
     589  if (nField_is_Ring_PtoM(src) || nField_is_Ring_ModN(src))
    590590  {
    591591    // Computing the n of Z/n
    592     int_number modul = (int_number) omAlloc(sizeof(mpz_t)); // evtl. spaeter mit bin
     592    int_number modul = (int_number)  omAllocBin(gmp_nrz_bin);
    593593    mpz_init(modul);
    594594    mpz_set(modul, src->ringflaga);
    … …  
    672672  int n=1;
    673673
    674   s = nr2mEati(s, &z);
     674  s = nr2mEati(s, &z,r);
    675675  if ((*s) == '/')
    676676  {
    677677    s++;
    678     s = nr2mEati(s, &n);
     678    s = nr2mEati(s, &n,r);
    679679  }
    680680  if (n == 1)
    681681    *a = (number)z;
    682682  else
    683       *a = nr2mDiv((number)z,(number)n);
     683      *a = nr2mDiv((number)z,(number)n,r);
    684684  return s;
    685685}

  • coeffs/rmodulo2m.h

    r37d318 r925a43c  
    1616
    1717void    nr2mInitChar    (coeffs r, void*);
    18 number  nr2mCopy        (number a, const coeffs r);
    1918BOOLEAN nr2mGreaterZero (number k, const coeffs r);
    2019number  nr2mMult        (number a, number b, const coeffs r);
Note: See TracChangeset for help on using the changeset viewer.