Changeset 1e579c6 in git for kernel


Ignore:
Timestamp:
Jun 20, 2007, 11:39:25 AM (17 years ago)
Author:
Oliver Wienand <wienand@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
07e8ae3b1877436cb95506c90d799438d558c703
Parents:
f7aaec31bd73e9e5b3b2bd84ee5ff4fab2de4691
Message:
kutil.cc:
* use nExtGcd, nIsUnit
* extended spolys only for non-domains

numbers.cc, numbers.h, structs.h:
* new Functions: nIsUnit, nGetUnit, nExtGcd
* new Field: the Integers

polys.cc, polys.h:
* nGetUnit hack removed
* minor memory glitch

polys1.cc:
* no pContent for Integers

ring.h:
new rField methos for Integers and p^n

rintegers.*:
implementation of the whole numbers using gmp

rmodulo*:
added funcs: nIsUnit, nGetUnit, nExtGcd


git-svn-id: file:///usr/local/Singular/svn/trunk@10125 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
kernel
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • kernel/kutil.cc

    rf7aaec3 r1e579c6  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kutil.cc,v 1.58 2007-05-24 10:02:43 wienand Exp $ */
     4/* $Id: kutil.cc,v 1.59 2007-06-20 09:39:23 wienand Exp $ */
    55/*
    66* ABSTRACT: kernel: utils for kStd
    … …  
    10551055  pSetm(Lp.lcm);
    10561056  assume(!strat->sugarCrit);
    1057   if (pHasNotCF(p,strat->S[i]) && nIsOne(nGcd(0, pGetCoeff(p), currRing)) && nIsOne(nGcd(0, pGetCoeff(strat->S[i]), currRing)))
     1057  if (pHasNotCF(p,strat->S[i]) && nIsUnit(pGetCoeff(p)) && nIsUnit(pGetCoeff(strat->S[i])))
    10581058  {
    10591059#ifdef KDEBUG
    … …  
    12451245#endif
    12461246
    1247 void enterOneStrongPoly (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR = -1)
    1248 {
    1249   long d, s, t;
     1247BOOLEAN enterOneStrongPoly (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR = -1)
     1248{
     1249  number d, s, t;
    12501250  assume(i<=strat->sl);
    12511251  LObject  Lp;
    12521252  poly m1, m2, erg, gcd;
    12531253
    1254   XGCD(d, s, t, (long) pGetCoeff(p), (long) pGetCoeff(strat->S[i]));
    1255 
     1254  d = nExtGcd(pGetCoeff(p), pGetCoeff(strat->S[i]), &s, &t);
     1255
     1256  if (nIsOne(d) || nIsZero(s) || nIsZero(t))
     1257  {
     1258    nDelete(&d);
     1259    nDelete(&s);
     1260    nDelete(&t);
     1261    return FALSE;
     1262  }
    12561263
    12571264  k_GetStrongLeadTerms(p, strat->S[i], currRing, m1, m2, gcd, strat->tailRing);
    12581265
    1259   pSetCoeff0(m1, nInit(s));
    1260   pSetCoeff0(m2, nInit(t));
    1261   pSetCoeff0(gcd, nInit(d));
     1266  pSetCoeff0(m1, s);
     1267  pSetCoeff0(m2, t);
     1268  pSetCoeff0(gcd, d);
    12621269
    12631270
    … …  
    13231330    enterL(&strat->L,&strat->Ll,&strat->Lmax,h,posx);
    13241331  }
     1332  return TRUE;
    13251333}
    13261334#endif
    … …  
    26002608    {
    26012609      // Print("j:%d, Ll:%d\n",j,strat->Ll);
    2602       if (((unsigned long) pGetCoeff(h) % (unsigned long) pGetCoeff(strat->S[j]) != 0) &&
    2603          ((unsigned long) pGetCoeff(strat->S[j]) % (unsigned long) pGetCoeff(h) != 0))
    2604       {
    2605         new_pair=TRUE;
    2606         enterOneStrongPoly(j,h,ecart,isFromQ,strat, atR);
     2610//      if (((unsigned long) pGetCoeff(h) % (unsigned long) pGetCoeff(strat->S[j]) != 0) &&
     2611//         ((unsigned long) pGetCoeff(strat->S[j]) % (unsigned long) pGetCoeff(h) != 0))
     2612      {
     2613        if (enterOneStrongPoly(j,h,ecart,isFromQ,strat, atR))
     2614          new_pair=TRUE;
    26072615      }
    26082616    }
    … …  
    27282736    assume (rField_is_Ring(currRing));
    27292737    // enter also zero divisor * poly, if this is non zero and of smaller degree
    2730     enterExtendedSpoly(h, strat);
     2738    if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat);
    27312739    initenterpairsRing(h, k, ecart, 0, strat, atR);
    27322740    initenterstrongPairs(h, k, ecart, 0, strat, atR);

  • kernel/numbers.cc

    rf7aaec3 r1e579c6  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: numbers.cc,v 1.9 2007-05-11 10:48:04 wienand Exp $ */
     4/* $Id: numbers.cc,v 1.10 2007-06-20 09:39:24 wienand Exp $ */
    55
    66/*
    … …  
    2929#include "rmodulon.h"
    3030#endif
     31#ifdef HAVE_RINGZ
     32#include "rintegers.h"
     33#endif
    3134
    3235//static int characteristic = 0;
    … …  
    4952BOOLEAN (*nDivBy)(number a,number b);
    5053int     (*nComp)(number a,number b);
     54BOOLEAN (*nIsUnit)(number a);
     55number  (*nGetUnit)(number a);
     56number  (*nExtGcd)(number a, number b, number *s, number *t);
    5157#endif
    5258BOOLEAN (*nGreater)(number a,number b);
    … …  
    107113BOOLEAN ndDivBy(number a, number b) { return TRUE; }
    108114int ndComp(number a, number b) { return 0; }
     115BOOLEAN ndIsUnit(number a) { return TRUE; }
     116number  ndGetUnit (number a) { return nCopy(a); }
     117number  ndExtGcd (number a, number b, number *s, number *t) { return nInit(1); }
    109118#endif
    110119
    … …  
    127136  {
    128137    nr2mSetExp(c, r);
     138  }
     139#endif 
     140#ifdef HAVE_RINGZ
     141  /*----------------------ring Z / 2^m----------------*/
     142  else if (rField_is_Ring_Z(r))
     143  {
     144    nrzSetExp(c, r);
    129145  }
    130146#endif 
    … …  
    185201  nComp  = r->cf->nComp;
    186202  nDivBy = r->cf->nDivBy;
     203  nIsUnit = r->cf->nIsUnit;
     204  nGetUnit = r->cf->nGetUnit;
     205  nExtGcd = r->cf->nExtGcd;
    187206#endif
    188207  nGreater = r->cf->nGreater;
    … …  
    267286  n->nComp = ndComp;
    268287  n->nDivBy = ndDivBy;
     288  n->nIsUnit = ndIsUnit;
     289  n->nGetUnit = ndGetUnit;
     290  n->nExtGcd = ndExtGcd;
    269291#endif
    270292  if (rField_is_Extension(r))
    … …  
    338360     n->nLcm          = nr2mLcm;
    339361     n->nGcd          = nr2mGcd;
    340 //     n->nGetUnit = nr2mGetUnit; //TODO OLIVER
     362     n->nIsUnit = nr2mIsUnit;
     363     n->nGetUnit = nr2mGetUnit;
     364     n->nExtGcd = nr2mExtGcd;
    341365     n->nName= ndName;
    342366#ifdef LDEBUG
    … …  
    376400     n->nLcm          = nrnLcm;
    377401     n->nGcd          = nrnGcd;
    378 //     n->nGetUnit = nrnGetUnit; //TODO OLIVER
     402     n->nIsUnit = nrnIsUnit;
     403     n->nGetUnit = nrnGetUnit;
     404     n->nExtGcd = nrnExtGcd;
    379405     n->nName= ndName;
    380406#ifdef LDEBUG
    381407     n->nDBTest=nrnDBTest;
     408#endif
     409  }
     410#endif
     411#ifdef HAVE_RINGZ
     412  /* -------------- Z ----------------------- */
     413  else if (rField_is_Ring_Z(r))
     414  {
     415     n->nInit  = nrzInit;
     416     n->nCopy  = ndCopy;
     417     n->nInt   = nrzInt;
     418     n->nAdd   = nrzAdd;
     419     n->nSub   = nrzSub;
     420     n->nMult  = nrzMult;
     421     n->nDiv   = nrzDiv;
     422     n->nIntDiv       = nrzIntDiv;
     423     n->nExactDiv= nrzDiv;
     424     n->nNeg   = nrzNeg;
     425     n->nInvers= nrzInvers;
     426     n->nDivBy = nrzDivBy;
     427     n->nComp = nrzComp;
     428     n->nGreater = nrzGreater;
     429     n->nEqual = nrzEqual;
     430     n->nIsZero = nrzIsZero;
     431     n->nIsOne = nrzIsOne;
     432     n->nIsMOne = nrzIsMOne;
     433     n->nGreaterZero = nrzGreaterZero;
     434     n->nWrite = nrzWrite;
     435     n->nRead = nrzRead;
     436     n->nPower = nrzPower;
     437     n->cfSetMap = nrzSetMap;
     438     n->nNormalize = nDummy2;
     439     n->nLcm          = nrzLcm;
     440     n->nGcd          = nrzGcd;
     441     n->nIsUnit = nrzIsUnit;
     442     n->nGetUnit = nrzGetUnit;
     443     n->nExtGcd = nrzExtGcd;
     444     n->nName= ndName;
     445#ifdef LDEBUG
     446     n->nDBTest=nrzDBTest;
    382447#endif
    383448  }

  • kernel/numbers.h

    rf7aaec3 r1e579c6  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: numbers.h,v 1.8 2007-05-11 10:48:04 wienand Exp $ */
     6/* $Id: numbers.h,v 1.9 2007-06-20 09:39:24 wienand Exp $ */
    77/*
    88* ABSTRACT: interface to coefficient aritmetics
    … …  
    4949#ifdef HAVE_RINGS
    5050extern int     (*nComp)(number a,number b);
     51extern BOOLEAN (*nIsUnit)(number a);
     52extern number  (*nGetUnit)(number a);
     53extern number  (*nExtGcd)(number a, number b, number *s, number *t);
    5154#endif
    5255// always use in the form    n=nNeg(n) !

  • kernel/polys.cc

    rf7aaec3 r1e579c6  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: polys.cc,v 1.19 2007-05-23 07:47:30 wienand Exp $ */
     4/* $Id: polys.cc,v 1.20 2007-06-20 09:39:24 wienand Exp $ */
    55
    66/*
    … …  
    689689}
    690690
    691 #ifdef HAVE_RINGS  //HACK TODO Oliver
    692 number nGetUnit(number k) {
    693   number unit = nIntDiv(k, nGcd(k, 0, currRing));
    694   number gcd = nGcd(unit, 0, currRing);
    695   if (!nIsOne(gcd))
    696   {
    697     number tmp = nMult(unit, unit);
    698     number gcd_new = nGcd(tmp, 0, currRing);
    699     while (gcd_new != gcd)
    700     {
    701       gcd = gcd_new;
    702       tmp = nMult(tmp, unit);
    703       gcd_new = nGcd(tmp, 0, currRing);
    704     }
    705     unit = nAdd(unit, nIntDiv(0, gcd_new));
    706   }
    707 //  Print("k = %d ; unit = %d ; gcd = %d", k, unit, gcd);
    708   return unit;
    709 }
    710 #endif
    711 
    712691/*2
    713692*divides p1 by its leading coefficient
    … …  
    720699  if (rField_is_Ring(currRing))
    721700  {
    722     if (p1!=NULL)
     701    if ((p1!=NULL) && rField_has_Units(currRing))
    723702    {
    724703      k = nGetUnit(pGetCoeff(p1));
    … …  
    726705      {
    727706        c = nDiv(pGetCoeff(p1), k);
     707        nDelete(pGetCoeff(p1));
    728708        pSetCoeff0(p1, c);
    729709        h = pNext(p1);
    … …  
    731711        {
    732712          c = nDiv(pGetCoeff(h), k);
    733           pSetCoeff(h, c);
     713          nDelete(pGetCoeff(h));
     714          pSetCoeff0(h, c);
    734715          pIter(h);
    735716        }
    736         nDelete(&k);
    737       }
    738      return;
    739     }
     717      }
     718      nDelete(&k);
     719    }
     720    return;
    740721  }
    741722  else

  • kernel/polys.h

    rf7aaec3 r1e579c6  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: polys.h,v 1.10 2007-05-11 10:48:05 wienand Exp $ */
     6/* $Id: polys.h,v 1.11 2007-06-20 09:39:24 wienand Exp $ */
    77/*
    88* ABSTRACT - all basic methods to manipulate polynomials of the
    … …  
    256256 */
    257257 
    258 number nGetUnit(number k);
     258// number nGetUnit(number k);
    259259#endif
    260260

  • kernel/polys1.cc

    rf7aaec3 r1e579c6  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: polys1.cc,v 1.28 2007-05-23 07:47:30 wienand Exp $ */
     4/* $Id: polys1.cc,v 1.29 2007-06-20 09:39:24 wienand Exp $ */
    55
    66/*
    … …  
    483483#ifdef HAVE_RINGS
    484484  if (rField_is_Ring(currRing)) {
    485     if (ph!=NULL)
     485    if ((ph!=NULL) && rField_has_Units(currRing))
    486486    {
    487487      number k = nGetUnit(pGetCoeff(ph));

  • kernel/ring.h

    rf7aaec3 r1e579c6  
    77* ABSTRACT - the interpreter related ring operations
    88*/
    9 /* $Id: ring.h,v 1.21 2007-05-24 13:42:17 Singular Exp $ */
     9/* $Id: ring.h,v 1.22 2007-06-20 09:39:24 wienand Exp $ */
    1010
    1111/* includes */
    … …  
    9999#endif
    100100
     101#ifdef HAVE_RINGPTOM
     102inline BOOLEAN rField_is_Ring_PtoM(ring r=currRing)
     103{ return (r->ringtype == 3); }
     104#endif
     105
     106#ifdef HAVE_RINGZ
     107inline BOOLEAN rField_is_Ring_Z(ring r=currRing)
     108{ return (r->ringtype == 4); }
     109#endif
     110
    101111#ifdef HAVE_RINGS
    102112inline BOOLEAN rField_is_Ring(ring r=currRing)
    … …  
    104114
    105115inline BOOLEAN rField_is_Domain(ring r=currRing)
    106 { return (r->ringtype < 0); }
     116{ return (r->ringtype == 4 || r->ringtype == 0); }
     117
     118inline BOOLEAN rField_has_Units(ring r=currRing)
     119{ return ((r->ringtype == 1) || (r->ringtype == 2) || (r->ringtype == 3)); }
    107120#endif
    108121

  • kernel/ringgb.cc

    rf7aaec3 r1e579c6  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ringgb.cc,v 1.15 2007-05-19 13:59:03 wienand Exp $ */
     4/* $Id: ringgb.cc,v 1.16 2007-06-20 09:39:25 wienand Exp $ */
    55/*
    66* ABSTRACT: ringgb interface
    … …  
    256256    }
    257257  }
    258   Print(" Yes!\nzero-spoly --> 0?");
    259   for (i = 0; i < IDELEMS(GI); i++)
     258  if (!(rField_is_Domain()))
    260259  {
    261     f = plain_zero_spoly(GI->m[i]);
    262     nf = ringNF(f, GI, currRing);
    263     if (nf != NULL) {
    264       Print("spoly(");
    265       wrp(GI->m[i]);
    266       Print(", ");
    267       wrp(0);
    268       Print(") = ");
    269       wrp(h);
    270       Print(" --> ");
    271       wrp(nf);
    272       PrintLn();
    273       return(0);
    274     }
    275     pDelete(&f);
    276     pDelete(&nf);
    277     Print("-");
     260    Print(" Yes!\nzero-spoly --> 0?");
     261    for (i = 0; i < IDELEMS(GI); i++)
     262    {
     263      f = plain_zero_spoly(GI->m[i]);
     264      nf = ringNF(f, GI, currRing);
     265      if (nf != NULL) {
     266        Print("spoly(");
     267        wrp(GI->m[i]);
     268        Print(", ");
     269        wrp(0);
     270        Print(") = ");
     271        wrp(h);
     272        Print(" --> ");
     273        wrp(nf);
     274        PrintLn();
     275        return(0);
     276      }
     277      pDelete(&f);
     278      pDelete(&nf);
     279      Print("-");
     280    }
    278281  }
    279282  Print(" Yes!");

  • kernel/rintegers.cc

    rf7aaec3 r1e579c6  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: rintegers.cc,v 1.1 2007-06-19 10:47:30 wienand Exp $ */
     4/* $Id: rintegers.cc,v 1.2 2007-06-20 09:39:25 wienand Exp $ */
    55/*
    66* ABSTRACT: numbers modulo n
    … …  
    2222#ifdef HAVE_RINGZ
    2323
     24typedef MP_INT *int_number;
     25
    2426/*
    2527 * Multiply two numbers
    … …  
    2729number nrzMult (number a, number b)
    2830{
    29   mpz_t erg;
    30   mpz_init(erg);
    31   mpz_mul(erg, (mpz_t) &a, (mpz_t) &b);
     31  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     32  mpz_init(erg);
     33  mpz_mul(erg, (int_number) a, (int_number) b);
    3234  return (number) erg;
    3335}
    … …  
    3840number nrzLcm (number a,number b,ring r)
    3941{
    40   mpz_t erg;
    41   mpz_init(erg);
    42   return (number) erg;//TODO
     42  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     43  mpz_init(erg);
     44  mpz_lcm(erg, (int_number) a, (int_number) b);
     45  return (number) erg;
    4346}
    4447
    … …  
    4952number nrzGcd (number a,number b,ring r)
    5053{
    51   mpz_t erg;
    52   mpz_init(erg);
    53   return (number) erg;//TODO
     54  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     55  mpz_init(erg);
     56  mpz_gcd(erg, (int_number) a, (int_number) b);
     57  return (number) erg;
     58}
     59
     60/*
     61 * Give the largest non unit k, such that a = x * k, b = y * k has
     62 * a solution and r, s, s.t. k = s*a + t*b
     63 */
     64number  nrzExtGcd (number a, number b, number *s, number *t)
     65{
     66  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     67  int_number bs = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     68  int_number bt = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     69  mpz_init(erg);
     70  mpz_init(bs);
     71  mpz_init(bt);
     72  mpz_gcdext(erg, bs, bt, (int_number) a, (int_number) b);
     73  *s = (number) bs;
     74  *t = (number) bt;
     75  return (number) erg;
    5476}
    5577
    5678void nrzPower (number a, int i, number * result)
    5779{
    58   mpz_t erg;
    59   mpz_init(erg);
    60   return (number) erg;/TODO
     80  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     81  mpz_init(erg);
     82  mpz_pow_ui(erg, (int_number) a, i);
     83  *result = (number) erg;
    6184}
    6285
    … …  
    6689number nrzInit (int i)
    6790{
    68   mpz_t erg;
     91  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
    6992  mpz_init_set_si(erg, i);
    7093  return (number) erg;
    7194}
    7295
     96void nrzDelete(number *a, const ring r)
     97{
     98  mpz_clear((int_number) *a);
     99  omFree((ADDRESS) *a);
     100}
     101
    73102/*
    74103 * convert a number to int (-p/2 .. p/2)
    … …  
    76105int nrzInt(number &n)
    77106{
    78   return (int) mpz_get_si(&n)
     107  return (int) mpz_get_si( (__mpz_struct*) &n);
    79108}
    80109
    81110number nrzAdd (number a, number b)
    82111{
    83   mpz_t erg;
    84   mpz_init(erg);
    85   mpz_add(erg, (mpz_t) a, (mpz_t) b);
     112  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     113  mpz_init(erg);
     114  mpz_add(erg, (int_number) a, (int_number) b);
    86115  return (number) erg;
    87116}
    … …  
    89118number nrzSub (number a, number b)
    90119{
    91   mpz_t erg;
    92   mpz_init(erg);
    93   mpz_sub(erg, (mpz_t) a, (mpz_t) b);
    94   return (number) erg;
     120  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     121  mpz_init(erg);
     122  mpz_sub(erg, (int_number) a, (int_number) b);
     123  return (number) erg;
     124}
     125
     126number  nrzGetUnit (number a)
     127{
     128  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     129  mpz_init_set_si(erg, 1);
     130  return (number) erg;
     131}
     132
     133BOOLEAN nrzIsUnit (number a)
     134{
     135  return 0 == mpz_cmpabs_ui((int_number) a, 1);
    95136}
    96137
    97138BOOLEAN nrzIsZero (number  a)
    98139{
    99   return 0 == mpz_cmpabs_ui((mpz_t) a, 0);
     140  return 0 == mpz_cmpabs_ui((int_number) a, 0);
    100141}
    101142
    102143BOOLEAN nrzIsOne (number a)
    103144{
    104   return 0 == mpz_cmp_si((mpz_t) a, 1);
     145  return 0 == mpz_cmp_si((int_number) a, 1);
    105146}
    106147
    107148BOOLEAN nrzEqual (number a,number b)
    108149{
    109   return 0 == mpz_cmp((mpz_t) a, (mpz_t) b);
     150  return 0 == mpz_cmp((int_number) a, (int_number) b);
    110151}
    111152
    112153BOOLEAN nrzGreater (number a,number b)
    113154{
    114   return 0 < mpz_cmp((mpz_t) a, (mpz_t) b);
     155  return 0 < mpz_cmp((int_number) a, (int_number) b);
    115156}
    116157
    117158int nrzComp(number a, number b)
    118159{
    119    return 2;//TODO
     160  if (nrnEqual(a, b)) return 0;
     161  if (nrnDivBy(a, b)) return -1;
     162  if (nrnDivBy(b, a)) return 1;
     163  return 2;
    120164}
    121165
    122166BOOLEAN nrzDivBy (number a,number b)
    123167{
    124   return FALSE;//TODO
     168  return mpz_divisible_p((int_number) a, (int_number) b) > 0;//TODO
    125169}
    126170
    127171BOOLEAN nrzGreaterZero (number k)
    128172{
    129   return 0 <= mpz_cmp_si((mpz_t) a, 0);
     173  return 0 <= mpz_cmp_si((int_number) k, 0);
     174}
     175
     176BOOLEAN nrzIsMOne (number a)
     177{
     178  return 0 == mpz_cmp_si((int_number) a, 1);
    130179}
    131180
    132181number nrzDiv (number a,number b)
    133182{
    134   return (number)0; //TODO
     183  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     184  int_number r = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     185  mpz_init(erg);
     186  mpz_tdiv_qr(erg, r, (int_number) a, (int_number) b);
     187  if (!nrzIsZero((number) r))
     188  {
     189    WarnS("Division by non divisible element.");
     190    WarnS("Result is without remainder.");
     191  }
     192  mpz_clear(r);
     193  omFree(r);
     194  return (number) erg;
    135195}
    136196
    137197number nrzIntDiv (number a,number b)
    138198{
    139   return (number)0; //TODO
     199  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     200  mpz_init(erg);
     201  mpz_tdiv_q(erg, (int_number) a, (int_number) b);
     202  return (number) erg;
    140203}
    141204
    142205number  nrzInvers (number c)
    143206{
    144   return (number)0; //TODO
     207  if (!nrzIsUnit((number) c))
     208  {
     209    WarnS("Non invertible element.");
     210    return (number)0; //TODO
     211  }
     212  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     213  mpz_init(erg);
     214  mpz_set(erg, (int_number) c);
     215  return (number) erg;
    145216}
    146217
    147218number nrzNeg (number c)
    148219{
    149   return (number)0; //TODO
     220  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     221  mpz_init(erg);
     222  mpz_mul_si(erg, (int_number) c, -1);
     223  return (number) erg;
    150224}
    151225
    … …  
    177251void nrzWrite (number &a)
    178252{
    179   if ((NATNUMBER)a > (nrzModul >>1)) StringAppend("-%d",(int)(-((NATNUMBER)a)));
    180   else                          StringAppend("%d",(int)((NATNUMBER)a));
    181 }
    182 
    183 char* nrzEati(char *s, int *i)
    184 {
    185 
    186   if (((*s) >= '0') && ((*s) <= '9'))
    187   {
    188     (*i) = 0;
    189     do
    190     {
    191       (*i) *= 10;
    192       (*i) += *s++ - '0';
    193       if ((*i) >= (MAX_INT_VAL / 10)) (*i) = (*i) % nrzModul;
    194     }
    195     while (((*s) >= '0') && ((*s) <= '9'));
    196     if ((*i) >= nrzModul) (*i) = (*i) % nrzModul;
    197   }
    198   else (*i) = 1;
     253  char *s,*z;
     254  if (a==NULL)
     255  {
     256    StringAppendS("o");
     257  }
     258  else
     259  {
     260    int l=mpz_sizeinbase((int_number) a, 10);
     261    if (a->s<2) l=si_max(l,mpz_sizeinbase((int_number) a,10));
     262    l+=2;
     263    s=(char*)omAlloc(l);
     264    z=mpz_get_str(s,10,(int_number) a);
     265    StringAppendS(z);
     266    omFreeSize((ADDRESS)s,l);
     267  }
     268}
     269
     270/*2
     271* extracts a long integer from s, returns the rest    (COPY FROM longrat0.cc)
     272*/
     273char * nlEatLongC(char *s, MP_INT *i)
     274{
     275  char * start=s;
     276
     277  while (*s >= '0' && *s <= '9') s++;
     278  if (*s=='\0')
     279  {
     280    mpz_set_str(i,start,10);
     281  }
     282  else
     283  {
     284    char c=*s;
     285    *s='\0';
     286    mpz_set_str(i,start,10);
     287    *s=c;
     288  }
    199289  return s;
    200290}
    201291
    202 char* nrzRead (char *s, number *a)
    203 {
    204   int z;
    205   int n=1;
    206 
    207   s = nrzEati(s, &z);
    208   if ((*s) == '/')
    209   {
    210     s++;
    211     s = nrzEati(s, &n);
    212   }
    213   if (n == 1)
    214     *a = (number)z;
    215   else
    216       *a = nrzDiv((number)z,(number)n);
     292char * nrzRead (char *s, number *a)
     293{
     294  int_number z = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     295  {
     296    mpz_init(z);
     297    s = nlEatLongC(s, z);
     298  }
     299  *a = (number) z;
    217300  return s;
    218301}

  • kernel/rintegers.h

    rf7aaec3 r1e579c6  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: rintegers.h,v 1.1 2007-06-19 10:47:30 wienand Exp $ */
     6/* $Id: rintegers.h,v 1.2 2007-06-20 09:39:25 wienand Exp $ */
    77/*
    88* ABSTRACT: numbers modulo n
    … …  
    2424BOOLEAN nrzIsOne       (number a);
    2525BOOLEAN nrzIsMOne      (number a);
     26BOOLEAN nrzIsUnit      (number a);
     27number  nrzGetUnit     (number a);
    2628number  nrzDiv         (number a, number b);
    2729number  nrzIntDiv      (number a,number b);
    … …  
    3436number  nrzLcm         (number a,number b, ring r);
    3537number  nrzGcd         (number a,number b,ring r);
     38number  nrzExtGcd      (number a, number b, number *s, number *t);
    3639nMapFunc nrzSetMap     (ring src, ring dst);
    3740void    nrzWrite       (number &a);
    … …  
    4346void    nrzSetExp(int c, ring r);
    4447void    nrzInitExp(int c, ring r);
     48void    nrzDelete(number *a, const ring r);
    4549
    4650#endif

  • kernel/rmodulo2m.cc

    rf7aaec3 r1e579c6  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: rmodulo2m.cc,v 1.11 2007-05-23 07:47:31 wienand Exp $ */
     4/* $Id: rmodulo2m.cc,v 1.12 2007-06-20 09:39:25 wienand Exp $ */
    55/*
    66* ABSTRACT: numbers modulo 2^m
    … …  
    8080}
    8181
     82/*
     83 * Give the largest non unit k, such that a = x * k, b = y * k has
     84 * a solution.
     85 */
     86number nr2mExtGcd (number a, number b, number *s, number *t)
     87{
     88  NATNUMBER res = 0;
     89  if ((NATNUMBER) a == 0 && (NATNUMBER) b == 0) return (number) 1;
     90  while ((NATNUMBER) a % 2 == 0 && (NATNUMBER) b % 2 == 0)
     91  {
     92    a = (number) ((NATNUMBER) a / 2);
     93    b = (number) ((NATNUMBER) b / 2);
     94    res++;
     95  }
     96  if ((NATNUMBER) b % 2 == 0)
     97  {
     98    *t = NULL;
     99    *s = nr2mInvers(a);
     100    return (number) ((1L << res));// * (NATNUMBER) a);  // (2**res)*a    a ist Einheit
     101  }
     102  else
     103  {
     104    *s = NULL;
     105    *t = nr2mInvers(b);
     106    return (number) ((1L << res));// * (NATNUMBER) b);  // (2**res)*b    b ist Einheit
     107  }
     108}
     109
    82110void nr2mPower (number a, int i, number * result)
    83111{
    … …  
    126154{
    127155  return nr2mSubM(a,b);
     156}
     157
     158BOOLEAN nr2mIsUnit (number a)
     159{
     160  return ((NATNUMBER) a % 2 == 1);
     161}
     162
     163number  nr2mGetUnit (number k)
     164{
     165  if (k == NULL)
     166    return (number) 1;
     167  NATNUMBER tmp = (NATNUMBER) k;
     168  while (tmp % 2 == 0)
     169    tmp = tmp / 2;
     170  return (number) tmp;
    128171}
    129172
    … …  
    372415  else
    373416  {
    374     WarnS("nInitChar failed");
     417    WarnS("nInitExp failed");
    375418  }
    376419}

  • kernel/rmodulo2m.h

    rf7aaec3 r1e579c6  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: rmodulo2m.h,v 1.6 2007-05-11 10:48:05 wienand Exp $ */
     6/* $Id: rmodulo2m.h,v 1.7 2007-06-20 09:39:25 wienand Exp $ */
    77/*
    88* ABSTRACT: numbers modulo 2^m
    … …  
    2424BOOLEAN nr2mIsOne       (number a);
    2525BOOLEAN nr2mIsMOne      (number a);
     26BOOLEAN nr2mIsUnit      (number a);
     27number  nr2mGetUnit     (number a);
    2628number  nr2mDiv         (number a, number b);
    2729number  nr2mIntDiv      (number a,number b);
    … …  
    3436number  nr2mLcm         (number a,number b, ring r);
    3537number  nr2mGcd         (number a,number b,ring r);
     38number  nr2mExtGcd      (number a, number b, number *s, number *t);
    3639nMapFunc nr2mSetMap     (ring src, ring dst);
    3740void    nr2mWrite       (number &a);

  • kernel/rmodulon.cc

    rf7aaec3 r1e579c6  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: rmodulon.cc,v 1.5 2007-05-23 07:47:31 wienand Exp $ */
     4/* $Id: rmodulon.cc,v 1.6 2007-06-20 09:39:25 wienand Exp $ */
    55/*
    66* ABSTRACT: numbers modulo n
    … …  
    139139}
    140140
     141number  nrnGetUnit (number k)
     142{
     143  number unit = nrnIntDiv(k, nrnGcd(k, 0, currRing));
     144  number gcd = nrnGcd(unit, 0, currRing);
     145  if (!nrnIsOne(gcd))
     146  {
     147    number tmp = nrnMult(unit, unit);
     148    number gcd_new = nrnGcd(tmp, 0, currRing);
     149    while (gcd_new != gcd)
     150    {
     151      gcd = gcd_new;
     152      tmp = nrnMult(tmp, unit);
     153      gcd_new = nrnGcd(tmp, 0, currRing);
     154    }
     155    unit = nrnAdd(unit, nrnIntDiv(0, gcd_new));
     156  }
     157//  Print("k = %d ; unit = %d ; gcd = %d", k, unit, gcd);
     158  return unit;
     159}
     160
    141161BOOLEAN nrnIsZero (number  a)
    142162{
    … …  
    147167{
    148168  return 1 == (NATNUMBER)a;
     169}
     170
     171BOOLEAN nrnIsUnit (number a)
     172{
     173  return nrnIsOne(nrnGcd(0, a, currRing));
    149174}
    150175
    … …  
    238263//#endif
    239264
     265/*
     266 * Give the largest non unit k, such that a = x * k, b = y * k has
     267 * a solution and r, s, s.t. k = s*a + t*b
     268 */
     269number  nrnExtGcd (number a, number b, number *s, number *t)
     270{
     271  long bs;
     272  long bt;
     273  long d;
     274  XGCD(d, bs, bt, (long) a, (long) b);
     275  *s = nrnInit(bs);
     276  *t = nrnInit(bt);
     277  return (number) d;
     278}
     279
    240280NATNUMBER InvModN(NATNUMBER a)
    241281{

  • kernel/rmodulon.h

    rf7aaec3 r1e579c6  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: rmodulon.h,v 1.3 2007-05-11 10:48:05 wienand Exp $ */
     6/* $Id: rmodulon.h,v 1.4 2007-06-20 09:39:25 wienand Exp $ */
    77/*
    88* ABSTRACT: numbers modulo n
    … …  
    2828BOOLEAN nrnIsOne       (number a);
    2929BOOLEAN nrnIsMOne      (number a);
     30BOOLEAN nrnIsUnit      (number a);
     31number  nrnGetUnit     (number a);
    3032number  nrnDiv         (number a, number b);
    3133number  nrnIntDiv      (number a,number b);
    … …  
    3840number  nrnLcm         (number a,number b, ring r);
    3941number  nrnGcd         (number a,number b,ring r);
     42number  nrnExtGcd      (number a, number b, number *s, number *t);
    4043nMapFunc nrnSetMap     (ring src, ring dst);
    4144void    nrnWrite       (number &a);

  • kernel/structs.h

    rf7aaec3 r1e579c6  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: structs.h,v 1.38 2007-05-11 10:48:05 wienand Exp $ */
     6/* $Id: structs.h,v 1.39 2007-06-20 09:39:25 wienand Exp $ */
    77/*
    88* ABSTRACT
    … …  
    273273#ifdef HAVE_RINGS
    274274   int     (*nComp)(number a,number b);
     275   BOOLEAN (*nIsUnit)(number a);
     276   number  (*nGetUnit)(number a);
     277   number  (*nExtGcd)(number a, number b, number *s, number *t);
    275278#endif
    276279   number  (*nNeg)(number a);
Note: See TracChangeset for help on using the changeset viewer.