Changeset 8e56ad in git


Ignore:
Timestamp:
Jan 30, 2008, 2:03:41 PM (15 years ago)
Author:
Oliver Wienand <wienand@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a657104b677b4c461d018cbf3204d72d34ad66a9')
Children:
faa7df853a3237b63560a72ed208619df8d26215
Parents:
b18621d3f9473a4a76cf41af06dfefe3b7a400f5
Message:
rintegers.cc:
Bereinigung

rmodulon:
Umstellung auf gmp


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

Legend:

Unmodified
Added
Removed

  • kernel/rintegers.cc

    rb18621 r8e56ad  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: rintegers.cc,v 1.4 2008-01-30 10:21:53 wienand Exp $ */
     4/* $Id: rintegers.cc,v 1.5 2008-01-30 13:03:41 wienand Exp $ */
    55/*
    66* ABSTRACT: numbers modulo n
    … …  
    1717#include "mpr_complex.h"
    1818#include "ring.h"
    19 #include "rmodulon.h"
     19#include "rintegers.h"
    2020#include "gmp.h"
    2121
    … …  
    143143BOOLEAN nrzIsOne (number a)
    144144{
    145   int x = mpz_cmp_si((int_number) a, 1);
    146   bool tmp = (0 == x);
    147   return tmp;
     145  return 0 == mpz_cmp_si((int_number) a, 1);
    148146}
    149147
    … …  
    170168int nrzComp(number a, number b)
    171169{
    172   if (nrnEqual(a, b)) return 0;
    173   if (nrnDivBy(a, b)) return -1;
    174   if (nrnDivBy(b, a)) return 1;
     170  if (nrzEqual(a, b)) return 0;
     171  if (nrzDivBy(a, b)) return -1;
     172  if (nrzDivBy(b, a)) return 1;
    175173  return 2;
    176174}
    … …  
    178176BOOLEAN nrzDivBy (number a,number b)
    179177{
    180   return mpz_divisible_p((int_number) a, (int_number) b) > 0;//TODO
     178  return mpz_divisible_p((int_number) a, (int_number) b) != 0;
    181179}
    182180

  • kernel/rmodulon.cc

    rb18621 r8e56ad  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: rmodulon.cc,v 1.8 2008-01-30 10:21:53 wienand Exp $ */
     4/* $Id: rmodulon.cc,v 1.9 2008-01-30 13:03:41 wienand Exp $ */
    55/*
    66* ABSTRACT: numbers modulo n
    … …  
    1818#include "ring.h"
    1919#include "rmodulon.h"
     20#include "gmp.h"
    2021
    2122#ifdef HAVE_RINGMODN
    2223
    23 NATNUMBER nrnModul;
    24 
    25 NATNUMBER XSGCD3(NATNUMBER a, NATNUMBER b, NATNUMBER c)
    26 {
    27   while ((a != 0 && b != 0) || (a != 0 && c != 0) || (b != 0 && c != 0))
    28   {
    29     if (a > b)
    30     {
    31       if (b > c) a = a % b;       // a > b > c
    32       else
    33       {
    34         if (a > c) a = a % c;     // a > b, c > b, a > c ==> a > c > b
    35         else c = c % a;           // c > a > b
    36       }
    37     }
    38     else
    39     {
    40       if (a > c) b = b % a;       // a > b > c
    41       else
    42       {
    43         if (b > c) b = b % c;     // a > b, c > b, a > c ==> a > c > b
    44         else c = c % b;           // c > a > b
    45       }
    46     }
    47   }
    48   return a + b + c;
    49 }
    50 
    51 NATNUMBER XSGCD2(NATNUMBER a, NATNUMBER b)
    52 {
    53   NATNUMBER TMP;
    54   while (a != 0 && b != 0)
    55   {
    56      TMP = a % b;
    57      a = b;
    58      b = TMP;
    59   }
    60   return a;
    61 }
     24typedef MP_INT *int_number;
     25
     26int_number nrnModul;
     27int_number nrnMinusOne;
     28
     29// int_number nrnModul;
     30// int_number nrnMinusOne;
    6231
    6332/*
    6433 * Multiply two numbers
    6534 */
    66 number nrnMult (number a,number b)
    67 {
    68   if (((NATNUMBER)a == 0) || ((NATNUMBER)b == 0))
    69     return (number)0;
    70   else
    71     return nrnMultM(a,b);
     35number nrnMult (number a, number b)
     36{
     37  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     38  mpz_init(erg);
     39  mpz_mul(erg, (int_number) a, (int_number) b);
     40  mpz_mod(erg, erg, nrnModul);
     41  return (number) erg;
    7242}
    7343
    … …  
    7747number nrnLcm (number a,number b,ring r)
    7848{
    79   NATNUMBER erg = XSGCD2(nrnModul, (NATNUMBER) a) * XSGCD2(nrnModul, (NATNUMBER) b) / XSGCD3(nrnModul, (NATNUMBER) a, (NATNUMBER) b);
    80   if (erg == nrnModul) return NULL;   // Schneller als return erg % nrnModul ?
     49  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     50  mpz_init(erg);
     51  mpz_lcm(erg, (int_number) a, (int_number) b);
     52  mpz_mod(erg, erg, nrnModul);
    8153  return (number) erg;
    8254}
    … …  
    8860number nrnGcd (number a,number b,ring r)
    8961{
    90   return (number) XSGCD3(nrnModul, (NATNUMBER) a, (NATNUMBER) b);
    91 }
    92 
    93 void nrnPower (number a, int i, number * result)
    94 {
    95   if (i==0)
    96   {
    97     //npInit(1,result);
    98     *(NATNUMBER *)result = 1;
    99   }
    100   else if (i==1)
    101   {
    102     *result = a;
    103   }
    104   else
    105   {
    106     nrnPower(a,i-1,result);
    107     *result = nrnMultM(a,*result);
    108   }
    109 }
    110 
    111 /*
    112  * create a number from int
    113  */
    114 number nrnInit (int i)
    115 {
    116   long ii = i;
    117   while (ii < 0) ii += nrnModul;
    118   while ((ii>1) && (ii >= nrnModul)) ii -= nrnModul;
    119   return (number) ii;
    120 }
    121 
    122 /*
    123  * convert a number to int (-p/2 .. p/2)
    124  */
    125 int nrnInt(number &n)
    126 {
    127   if ((NATNUMBER)n > (nrnModul >>1)) return (int)((NATNUMBER)n - nrnModul);
    128   else return (int)((NATNUMBER)n);
    129 }
    130 
    131 number nrnAdd (number a, number b)
    132 {
    133   return nrnAddM(a,b);
    134 }
    135 
    136 number nrnSub (number a, number b)
    137 {
    138   return nrnSubM(a,b);
    139 }
    140 
    141 number  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 
    161 BOOLEAN nrnIsZero (number  a)
    162 {
    163   return 0 == (NATNUMBER)a;
    164 }
    165 
    166 BOOLEAN nrnIsOne (number a)
    167 {
    168   return 1 == (NATNUMBER)a;
    169 }
    170 
    171 BOOLEAN nrnIsUnit (number a)
    172 {
    173   return nrnIsOne(nrnGcd(0, a, currRing));
    174 }
    175 
    176 BOOLEAN nrnIsMOne (number a)
    177 {
    178   return (nrnModul == (NATNUMBER)a + 1)  && (nrnModul != 2);
    179 }
    180 
    181 BOOLEAN nrnEqual (number a,number b)
    182 {
    183   return nrnEqualM(a,b);
    184 }
    185 
    186 BOOLEAN nrnGreater (number a,number b)
    187 {
    188   nrnDivBy(a, b);
    189 }
    190 
    191 int nrnComp(number a, number b)
    192 {
    193    NATNUMBER bs = XSGCD2((NATNUMBER) b, nrnModul);
    194    NATNUMBER as = XSGCD2((NATNUMBER) a, nrnModul);
    195    if (bs == as) return 0;
    196    if (as % bs == 0) return -1;
    197    if (bs % as == 0) return 1;
    198    return 2;
    199 }
    200 
    201 BOOLEAN nrnDivBy (number a,number b)
    202 {
    203   return (XSGCD2((NATNUMBER) b / XSGCD2((NATNUMBER) a, (NATNUMBER) b), nrnModul) == 1);
    204 }
    205 
    206 BOOLEAN nrnGreaterZero (number k)
    207 {
    208   return (((NATNUMBER) k) != 0) && ((NATNUMBER) k <= (nrnModul>>1));
    209 }
    210 
    211 //#ifdef HAVE_DIV_MOD
    212 #if 1 //ifdef HAVE_NTL // in ntl.a
    213 //extern void XGCD(long& d, long& s, long& t, long a, long b);
    214 #include <NTL/ZZ.h>
    215 #ifdef NTL_CLIENT
    216 NTL_CLIENT
    217 #endif
    218 #else
    219 void XGCD(long& d, long& s, long& t, long a, long b)
    220 {
    221    long  u, v, u0, v0, u1, v1, u2, v2, q, r;
    222 
    223    long aneg = 0, bneg = 0;
    224 
    225    if (a < 0) {
    226       a = -a;
    227       aneg = 1;
    228    }
    229 
    230    if (b < 0) {
    231       b = -b;
    232       bneg = 1;
    233    }
    234 
    235    u1=1; v1=0;
    236    u2=0; v2=1;
    237    u = a; v = b;
    238 
    239    while (v != 0) {
    240       q = u / v;
    241       r = u % v;
    242       u = v;
    243       v = r;
    244       u0 = u2;
    245       v0 = v2;
    246       u2 =  u1 - q*u2;
    247       v2 = v1- q*v2;
    248       u1 = u0;
    249       v1 = v0;
    250    }
    251 
    252    if (aneg)
    253       u1 = -u1;
    254 
    255    if (bneg)
    256       v1 = -v1;
    257 
    258    d = u;
    259    s = u1;
    260    t = v1;
    261 }
    262 #endif
    263 //#endif
     62  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     63  mpz_init(erg);
     64  mpz_gcd(erg, (int_number) a, (int_number) b);
     65  return (number) erg;
     66}
    26467
    26568/*
    … …  
    26972number  nrnExtGcd (number a, number b, number *s, number *t)
    27073{
    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 
    280 NATNUMBER InvModN(NATNUMBER a)
    281 {
    282    long d, s, t;
    283 
    284    // TODO in chain wird XSGCD2 aufgerufen
    285    XGCD(d, s, t, a, nrnModul);
    286    assume (d == 1);
    287    if (s < 0)
    288       return s + nrnModul;
    289    else
    290       return s;
    291 }
    292 
    293 inline number nrnInversM (number c)
    294 {
    295   // Table !!!
    296   NATNUMBER inv;
    297   inv = InvModN((NATNUMBER)c);
    298   return (number) inv;
     74  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     75  int_number bs = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     76  int_number bt = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     77  mpz_init(erg);
     78  mpz_init(bs);
     79  mpz_init(bt);
     80  mpz_gcdext(erg, bs, bt, (int_number) a, (int_number) b);
     81  *s = (number) bs;
     82  *t = (number) bt;
     83  return (number) erg;
     84}
     85
     86void nrnPower (number a, int i, number * result)
     87{
     88  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     89  mpz_init(erg);
     90  mpz_pow_ui(erg, (int_number) a, i);
     91  mpz_mod(erg, erg, nrnModul);
     92  *result = (number) erg;
     93}
     94
     95/*
     96 * create a number from int
     97 */
     98number nrnInit (int i)
     99{
     100  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     101  mpz_init_set_si(erg, i);
     102  return (number) erg;
     103}
     104
     105void nrnDelete(number *a, const ring r)
     106{
     107  mpz_clear((int_number) *a);
     108  omFree((ADDRESS) *a);
     109}
     110
     111/*
     112 * convert a number to int (-p/2 .. p/2)
     113 */
     114int nrnInt(number &n)
     115{
     116  return (int) mpz_get_si( (int_number) &n);
     117}
     118
     119number nrnAdd (number a, number b)
     120{
     121  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     122  mpz_init(erg);
     123  mpz_add(erg, (int_number) a, (int_number) b);
     124  mpz_mod(erg, erg, nrnModul);
     125  return (number) erg;
     126}
     127
     128number nrnSub (number a, number b)
     129{
     130  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     131  mpz_init(erg);
     132  mpz_sub(erg, (int_number) a, (int_number) b);
     133  mpz_mod(erg, erg, nrnModul);
     134  return (number) erg;
     135}
     136
     137number  nrnGetUnit (number a)
     138{
     139  return nrnDiv((number) nrnModul, nrnGcd(a, (number) nrnModul, NULL));
     140}
     141
     142BOOLEAN nrnIsUnit (number a)
     143{
     144  return nrnIsOne(nrnGcd(a, (number) nrnModul, NULL));
     145}
     146
     147BOOLEAN nrnIsZero (number  a)
     148{
     149  return 0 == mpz_cmpabs_ui((int_number) a, 0);
     150}
     151
     152BOOLEAN nrnIsOne (number a)
     153{
     154  return 0 == mpz_cmp_si((int_number) a, 1);
     155}
     156
     157BOOLEAN nrnIsMOne (number a)
     158{
     159  return 0 == mpz_cmp((int_number) a, nrnMinusOne);
     160}
     161
     162BOOLEAN nrnEqual (number a,number b)
     163{
     164  return 0 == mpz_cmp((int_number) a, (int_number) b);
     165}
     166
     167BOOLEAN nrnGreater (number a,number b)
     168{
     169  return 0 < mpz_cmp((int_number) a, (int_number) b);
     170}
     171
     172BOOLEAN nrnGreaterZero (number k)
     173{
     174  return 0 <= mpz_cmp_si((int_number) k, 0);
     175}
     176
     177int nrnComp(number a, number b)
     178{
     179  if (nrnEqual(a, b)) return 0;
     180  if (nrnDivBy(a, b)) return -1;
     181  if (nrnDivBy(b, a)) return 1;
     182  return 2;
     183}
     184
     185BOOLEAN nrnDivBy (number a,number b)
     186{
     187  return mpz_divisible_p((int_number) a, (int_number) b) != 0;
    299188}
    300189
    301190number nrnDiv (number a,number b)
    302191{
    303   NATNUMBER tmp = XSGCD3(nrnModul, (NATNUMBER) a, (NATNUMBER) b);
    304   a = (number) ((NATNUMBER) a / tmp);
    305   b = (number) ((NATNUMBER) b / tmp);
    306   if (XSGCD2(nrnModul, (NATNUMBER) b) == 1)
    307   {
    308     return (number) nrnMult(a, nrnInversM(b));
     192  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     193  mpz_init(erg);
     194  if (nrnDivBy(a, b))
     195  {
     196    mpz_divexact(erg, (int_number) a, (int_number) b);
     197    return (number) erg;
    309198  }
    310199  else
    311200  {
    312     WerrorS("div by zero divisor");
    313     return (number)0;
     201    int_number gcd = (int_number) nrnGcd(a, b, NULL);
     202    int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     203    mpz_init(erg);
     204    mpz_divexact(erg, (int_number) b, gcd);
     205    if (!nrnIsUnit((number) erg))
     206    {
     207      WarnS("Division by non divisible element.");
     208      WarnS("Result is zero.");
     209    }
     210    gcd = (int_number) nrnInvers((number) erg);
     211    mpz_divexact(erg, (int_number) a, gcd);
     212    mpz_mul(erg, erg, gcd);
     213    mpz_clear(gcd);
     214    omFree(gcd);
     215    mpz_mod(erg, erg, nrnModul);
     216    return (number) erg;
    314217  }
    315218}
    … …  
    317220number nrnIntDiv (number a,number b)
    318221{
    319   if ((NATNUMBER)a==0)
    320   {
    321     if ((NATNUMBER)b==0)
    322       return (number) 1;
    323     if ((NATNUMBER)b==1)
    324       return (number) 0;
    325     return (number) ( nrnModul / (NATNUMBER) b);
    326   }
    327   else
    328   {
    329     if ((NATNUMBER)b==0)
    330       return (number) 0;
    331     return (number) ((NATNUMBER) a / (NATNUMBER) b);
    332   }
     222  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     223  mpz_init(erg);
     224  mpz_tdiv_q(erg, (int_number) a, (int_number) b);
     225  return (number) erg;
    333226}
    334227
    335228number  nrnInvers (number c)
    336229{
    337   if (XSGCD2(nrnModul, (NATNUMBER) c) != 1)
    338   {
    339     WerrorS("division by zero divisor");
    340     return (number)0;
    341   }
    342   return nrnInversM(c);
     230  number s;
     231  number t;
     232  number k;
     233/*
     234 * Give the largest non unit k, such that a = x * k, b = y * k has
     235 * a solution and r, s, s.t. k = s*a + t*b
     236 */
     237  k = nrnExtGcd((number) nrnModul, c, &s, &t);
     238  if (!nrnIsOne((number) k))
     239  {
     240    WarnS("Non invertible element.");
     241    return nrnInit(0);                                   //TODO
     242  }
     243  mpz_clear((int_number) k);
     244  omFree((ADDRESS) k);
     245  mpz_clear((int_number) s);
     246  omFree((ADDRESS) s);
     247  return (number) t;
    343248}
    344249
    345250number nrnNeg (number c)
    346251{
    347   if ((NATNUMBER)c==0) return c;
    348   return nrnNegM(c);
    349 }
    350 
    351 NATNUMBER nrnMapModul;
    352 NATNUMBER nrnMapCoef;
    353 
    354 number nrnMapModN(number from)
    355 {
    356   NATNUMBER i = (nrnMapCoef * (NATNUMBER) from) % nrnModul;
    357   return (number) i;
     252  int_number erg = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     253  mpz_init(erg);
     254  mpz_sub(erg, nrnModul, (int_number) c);
     255  return (number) erg;
    358256}
    359257
    360258nMapFunc nrnSetMap(ring src, ring dst)
    361259{
    362   if (rField_is_Ring_ModN(src))
    363   {
    364     if (src->ringflaga == dst->ringflaga) return ndCopy;
    365     else
    366     {
    367       nrnMapModul = (NATNUMBER) src->ringflaga;
    368       if (nrnModul % nrnMapModul == 0)
    369       {
    370         nrnMapCoef = (nrnModul / nrnMapModul);
    371         NATNUMBER tmp = nrnModul;
    372         nrnModul = nrnMapModul;
    373         nrnMapCoef *= (NATNUMBER) nrnInvers((number) (nrnMapCoef % nrnMapModul));
    374         nrnModul = tmp;
    375       }
    376       else
    377         nrnMapCoef = 1;
    378       return nrnMapModN;
    379     }
    380   }
    381260  return NULL;      /* default */
    382261}
    … …  
    389268void nrnSetExp(int m, ring r)
    390269{
    391   nrnModul = m;
     270  nrnModul = (int_number) nrnInit(m);
     271  nrnMinusOne = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     272  mpz_init(nrnMinusOne);
     273  mpz_sub_ui(nrnMinusOne, nrnModul, 1);
     274
    392275//  PrintS("Modul: ");
    393276//  Print("%d\n", nrnModul);
    … …  
    396279void nrnInitExp(int m, ring r)
    397280{
    398   nrnModul = m;
    399 
     281  nrnModul = (int_number) nrnInit(m);
     282  nrnMinusOne = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     283  mpz_init(nrnMinusOne);
     284  mpz_sub_ui(nrnMinusOne, nrnModul, 1);
    400285  if (m < 2)
    401286  {
    … …  
    407292BOOLEAN nrnDBTest (number a, char *f, int l)
    408293{
    409   if (((NATNUMBER)a<0) || ((NATNUMBER)a>nrnModul))
     294  if ( (mpz_cmp_si((int_number) a, 0) < 0) || (mpz_cmp((int_number) a, nrnModul) > 0) )
    410295  {
    411296    return FALSE;
    … …  
    417302void nrnWrite (number &a)
    418303{
    419   if ((NATNUMBER)a > (nrnModul >>1)) StringAppend("-%d",(int)(nrnModul-((NATNUMBER)a)));
    420   else                          StringAppend("%d",(int)((NATNUMBER)a));
    421 }
    422 
    423 char* nrnEati(char *s, int *i)
    424 {
    425 
    426   if (((*s) >= '0') && ((*s) <= '9'))
    427   {
    428     (*i) = 0;
    429     do
    430     {
    431       (*i) *= 10;
    432       (*i) += *s++ - '0';
    433       if ((*i) >= (MAX_INT_VAL / 10)) (*i) = (*i) % nrnModul;
    434     }
    435     while (((*s) >= '0') && ((*s) <= '9'));
    436     if ((*i) >= nrnModul) (*i) = (*i) % nrnModul;
    437   }
    438   else (*i) = 1;
     304  char *s,*z;
     305  if (a==NULL)
     306  {
     307    StringAppendS("o");
     308  }
     309  else
     310  {
     311    int l=mpz_sizeinbase((int_number) a, 10);
     312    if (a->s<2) l=si_max(l,mpz_sizeinbase((int_number) a,10));
     313    l+=2;
     314    s=(char*)omAlloc(l);
     315    z=mpz_get_str(s,10,(int_number) a);
     316    StringAppendS(z);
     317    omFreeSize((ADDRESS)s,l);
     318  }
     319}
     320
     321/*2
     322* extracts a long integer from s, returns the rest    (COPY FROM longrat0.cc)
     323*/
     324char * nlCPEatLongC(char *s, MP_INT *i)
     325{
     326  char * start=s;
     327
     328  while (*s >= '0' && *s <= '9') s++;
     329  if (*s=='\0')
     330  {
     331    mpz_set_str(i,start,10);
     332  }
     333  else
     334  {
     335    char c=*s;
     336    *s='\0';
     337    mpz_set_str(i,start,10);
     338    *s=c;
     339  }
    439340  return s;
    440341}
    … …  
    442343char * nrnRead (char *s, number *a)
    443344{
    444   int z;
    445   int n=1;
    446 
    447   s = nrnEati(s, &z);
    448   if ((*s) == '/')
    449   {
    450     s++;
    451     s = nrnEati(s, &n);
    452   }
    453   if (n == 1)
    454     *a = (number)z;
    455   else
    456       *a = nrnDiv((number)z,(number)n);
     345  int_number z = (int_number) omAlloc(sizeof(MP_INT)); // evtl. spaeter mit bin
     346  {
     347    mpz_init(z);
     348    s = nlCPEatLongC(s, z);
     349  }
     350  *a = (number) z;
    457351  return s;
    458352}

  • kernel/rmodulon.h

    rb18621 r8e56ad  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: rmodulon.h,v 1.4 2007-06-20 09:39:25 wienand Exp $ */
     6/* $Id: rmodulon.h,v 1.5 2008-01-30 13:03:41 wienand Exp $ */
    77/*
    88* ABSTRACT: numbers modulo n
    … …  
    1414#define NATNUMBER unsigned long
    1515#endif
    16 
    17 extern int nrnExp;
    18 extern NATNUMBER nrnModul;
    1916
    2017BOOLEAN nrnGreaterZero (number k);
    … …  
    5148void    nrnInitExp(int c, ring r);
    5249
    53 
    54 static inline number nrnMultM(number a, number b)
    55 {
    56   return (number)
    57     ((((NATNUMBER) a)*((NATNUMBER) b)) % ((NATNUMBER) nrnModul));
    58 }
    59 
    60 static inline number nrnAddM(number a, number b)
    61 {
    62   NATNUMBER r = (NATNUMBER)a + (NATNUMBER)b;
    63   return (number) (r >= nrnModul ? r - nrnModul : r);
    64 }
    65 
    66 static inline number nrnSubM(number a, number b)
    67 {
    68   return (number)((NATNUMBER)a<(NATNUMBER)b ?
    69                        nrnModul-(NATNUMBER)b+(NATNUMBER)a : (NATNUMBER)a-(NATNUMBER)b);
    70 }
    71 
    72 #define nrnNegM(A) (number)(nrnModul-(NATNUMBER)(A))
    73 #define nrnEqualM(A,B)  ((A)==(B))
    74 
    7550#endif
    7651#endif
Note: See TracChangeset for help on using the changeset viewer.