Changeset a3f03d9 in git


Ignore:
Timestamp:
Nov 26, 2002, 2:54:44 PM (21 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
5bce7cb0f36aa5eb9d9d034dd62834042e3e256d
Parents:
fdd985e9b4554ba4958ac4b242be22749004eee6
Message:
*hannes: merge v-2-0: longrat stuff, gmp 4 stuff, removed gmp1 stuff


git-svn-id: file:///usr/local/Singular/svn/trunk@6341 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed

  • Singular/longrat.cc

    rfdd985e ra3f03d9  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: longrat.cc,v 1.44 2002-07-23 13:09:36 Singular Exp $ */
     4/* $Id: longrat.cc,v 1.45 2002-11-26 13:54:41 Singular Exp $ */
    55/*
    66* ABSTRACT: computation with long rational numbers (Hubert Grassmann)
    … …  
    2525
    2626#ifndef BYTES_PER_MP_LIMB
    27 #ifdef HAVE_LIBGMP2
    2827#define BYTES_PER_MP_LIMB sizeof(mp_limb_t)
    29 #else
    30 #define BYTES_PER_MP_LIMB sizeof(mp_limb)
    31 #endif
    3228#endif
    3329
    … …  
    7470#define MP_SMALL 1
    7571//#define mpz_isNeg(A) (mpz_cmp_si(A,(long)0)<0)
    76 #ifdef HAVE_LIBGMP1
    77 #define mpz_isNeg(A) ((A)->size<0)
    78 #define mpz_limb_size(A) ((A)->size)
    79 #define mpz_limb_d(A) ((A)->d)
    80 #define MPZ_DIV(A,B,C) mpz_div((A),(B),(C))
    81 #define MPZ_EXACTDIV(A,B,C) mpz_div((A),(B),(C))
    82 #else
    8372#define mpz_isNeg(A) ((A)->_mp_size<0)
    8473#define mpz_limb_size(A) ((A)->_mp_size)
    … …  
    9180#endif
    9281#define nlGmpSimple(A)
    93 #endif
    9482
    9583#ifdef LDEBUG
    … …  
    183171    return FALSE;
    184172  }
    185 #ifdef HAVE_LIBGMP2
    186173  omCheckAddrSize(a->z._mp_d,a->z._mp_alloc*BYTES_PER_MP_LIMB);
    187174  if (a->z._mp_alloc==0)
    188 #else
    189   omCheckIf(omCheckAddrSize(a->z.d,a->z.alloc*BYTES_PER_MP_LIMB), return FALSE);
    190   if(a->z.alloc==0)
    191 #endif
    192175    Print("!!longrat:z->alloc=0 in %s:%l\n",f,l);
    193176
    194177  if (a->s<2)
    195178  {
    196 #ifdef HAVE_LIBGMP2
    197179    omCheckIf(omCheckAddrSize(a->n._mp_d,a->n._mp_alloc*BYTES_PER_MP_LIMB), return FALSE);
    198180    if (a->z._mp_alloc==0)
    199 #else
    200     omCheckIf(omCheckAddrSize(a->n.d,a->n.alloc*BYTES_PER_MP_LIMB), return FALSE);
    201     if(a->z.alloc==0)
    202 #endif
    203181      Print("!!longrat:n->alloc=0 in %s:%l\n",f,l);
    204182    if (mpz_cmp_si(&a->n,(long)1)==0)
    … …  
    420398  if (SR_HDL(a) & SR_INT)
    421399     return 1; /* immidiate int */
    422 #ifdef HAVE_LIBGMP2
    423400  int s=a->z._mp_alloc;
    424 #else
    425   int s=a->z.alloc;
    426 #endif
    427401  if (a->s<2)
    428402  {
    429 #ifdef HAVE_LIBGMP2
    430403    s+=a->n._mp_alloc;
    431 #else
    432     s+=a->n.alloc;
    433 #endif
    434404  }
    435405  return s;
    436406}
    437 
    438 /*
    439 * delete leading 0s from a gmp number
    440 */
    441 #ifdef HAVE_LIBGMP1
    442 static void nlGmpSimple(MP_INT *z)
    443 {
    444   int k;
    445   if (mpz_limb_size(z)<0)
    446   {
    447     k=-mpz_limb_size(z)-1;
    448     while ((k>0) && (mpz_limb_d(z)[k]==0))
    449     { k--;printf("X"); }
    450     k++;
    451     mpz_limb_size(z)=-k;
    452   }
    453   else
    454   {
    455     k=mpz_limb_size(z)-1;
    456     while ((k>0) && (mpz_limb_d(z)[k]==0))
    457     { k--;printf("X"); }
    458     k++;
    459     mpz_limb_size(z)=k;
    460   }
    461 }
    462 #endif
    463407
    464408/*2
    … …  
    493437  return ul;
    494438}
     439
     440
    495441
    496442/*
    … …  
    993939}
    994940
    995 #if (defined(i386)) && (defined(HAVE_LIBGMP1))
    996 /*
    997 * compute x^exp for x in Z
    998 * there seems to be an bug in mpz_pow_ui for i386
    999 */
    1000 static inline void nlPow (MP_INT * res,MP_INT * x,int exp)
    1001 {
    1002   if (exp==0)
    1003   {
    1004     mpz_set_si(res,(long)1);
    1005   }
    1006   else
    1007   {
    1008     MP_INT xh;
    1009     mpz_init(&xh);
    1010     mpz_set(res,x);
    1011     exp--;
    1012     while (exp!=0)
    1013     {
    1014       mpz_mul(&xh,res,x);
    1015       mpz_set(res,&xh);
    1016       exp--;
    1017     }
    1018     mpz_clear(&xh);
    1019   }
    1020 }
    1021 #endif
    1022 
    1023941/*2
    1024942* u:= x ^ exp
    … …  
    1043961    mpz_init(&(*u)->z);
    1044962    (*u)->s = x->s;
    1045 #if (!defined(i386)) || (defined(HAVE_LIBGMP2))
    1046963    mpz_pow_ui(&(*u)->z,&x->z,(unsigned long)exp);
    1047 #else
    1048     nlPow(&(*u)->z,&x->z,exp);
    1049 #endif
    1050964    if (x->s<2)
    1051965    {
    1052966      mpz_init(&(*u)->n);
    1053 #if (!defined(i386)) || (defined(HAVE_LIBGMP2))
    1054967      mpz_pow_ui(&(*u)->n,&x->n,(unsigned long)exp);
    1055 #else
    1056       nlPow(&(*u)->n,&x->n,exp);
    1057 #endif
    1058968    }
    1059969    if (aa!=NULL)
    … …  
    11621072  if (((!(SR_HDL(a) & SR_INT))&&(a->s<2))
    11631073  ||  ((!(SR_HDL(b) & SR_INT))&&(b->s<2))) return INT_TO_SR(1);
    1164   number aa=NULL;
    1165   if (SR_HDL(a) & SR_INT)
    1166   {
    1167     aa=nlRInit(SR_TO_INT(a));
    1168     a=aa;
    1169   }
    1170   else
    1171   if (SR_HDL(b) & SR_INT)
    1172   {
    1173     aa=nlRInit(SR_TO_INT(b));
    1174     b=aa;
    1175   }
    11761074  result=(number)omAllocBin(rnumber_bin);
    11771075#if defined(LDEBUG)
    … …  
    11791077#endif
    11801078  mpz_init(&result->z);
    1181   mpz_gcd(&result->z,&a->z,&b->z);
    1182   nlGmpSimple(&result->z);
     1079  if (SR_HDL(a) & SR_INT)
     1080  {
     1081    mpz_gcd_ui(&result->z,&b->z,ABS(SR_TO_INT(a)));
     1082  }
     1083  else
     1084  if (SR_HDL(b) & SR_INT)
     1085  {
     1086    mpz_gcd_ui(&result->z,&a->z,ABS(SR_TO_INT(b)));
     1087  }
     1088  else
     1089  {
     1090    mpz_gcd(&result->z,&a->z,&b->z);
     1091    nlGmpSimple(&result->z);
     1092  }
    11831093  result->s = 3;
    11841094  if (mpz_size1(&result->z)<=MP_SMALL)
    … …  
    11921102      result=INT_TO_SR(ui);
    11931103    }
    1194   }
    1195   if (aa!=NULL)
    1196   {
    1197     mpz_clear(&aa->z);
    1198     omFreeBin((ADDRESS)aa, rnumber_bin);
    11991104  }
    12001105#ifdef LDEBUG
    … …  
    13041209    return nlCopy(a);
    13051210  }
    1306   number aa=NULL;
    1307   if (SR_HDL(a) & SR_INT)
    1308   {
    1309     aa=nlRInit(SR_TO_INT(a));
    1310     a=aa;
    1311   }
    13121211  result=(number)omAllocBin(rnumber_bin);
    13131212#if defined(LDEBUG)
    … …  
    13181217  mpz_init(&gcd);
    13191218  mpz_init(&result->z);
    1320   mpz_gcd(&gcd,&a->z,&b->n);
     1219  if (SR_HDL(a) & SR_INT)
     1220    mpz_gcd_ui(&gcd,&b->n,ABS(SR_TO_INT(a)));
     1221  else
     1222    mpz_gcd(&gcd,&a->z,&b->n);
    13211223  if (mpz_cmp_si(&gcd,(long)1)!=0)
    13221224  {
    … …  
    13241226    mpz_init_set(&bt,&b->n);
    13251227    MPZ_EXACTDIV(&bt,&bt,&gcd);
    1326     mpz_mul(&result->z,&a->z,&bt);
     1228    if (SR_HDL(a) & SR_INT)
     1229      mpz_mul_si(&result->z,&bt,SR_TO_INT(a));
     1230    else
     1231      mpz_mul(&result->z,&bt,&a->z);
    13271232    mpz_clear(&bt);
    13281233  }
    13291234  else
    1330     mpz_mul(&result->z,&a->z,&b->n);
     1235    if (SR_HDL(a) & SR_INT)
     1236      mpz_mul_si(&result->z,&b->n,SR_TO_INT(a));
     1237    else
     1238      mpz_mul(&result->z,&b->n,&a->z);
    13311239  mpz_clear(&gcd);
    1332   if (aa!=NULL)
    1333   {
    1334     mpz_clear(&aa->z);
    1335     omFreeBin((ADDRESS)aa, rnumber_bin);
    1336   }
    13371240  nlGmpSimple(&result->z);
    13381241  if (mpz_size1(&result->z)<=MP_SMALL)
    … …  
    14071310  }
    14081311  return INT_TO_SR(1);
     1312}
     1313
     1314/*2
     1315* acces to Nominator, nlCopy(n) for integers
     1316*/
     1317number   nlGetNom(number &n, const ring r)
     1318{
     1319  if (!(SR_HDL(n) & SR_INT))
     1320  {
     1321    if (n->s==0)
     1322    {
     1323      nlNormalize(n);
     1324    }
     1325    if (!(SR_HDL(n) & SR_INT))
     1326    {
     1327      number u=(number)omAllocBin(rnumber_bin);
     1328      u->s=3;
     1329#if defined(LDEBUG)
     1330      u->debug=123456;
     1331#endif
     1332      mpz_init_set(&u->z,&n->z);
     1333      if (n->s!=3)
     1334      {
     1335        int ui=(int)mpz_get_si(&u->z);
     1336        if ((((ui<<3)>>3)==ui)
     1337        && (mpz_cmp_si(&u->z,(long)ui)==0))
     1338        {
     1339          mpz_clear(&u->z);
     1340          omFreeBin((ADDRESS)u, rnumber_bin);
     1341          return INT_TO_SR(ui);
     1342        }
     1343      }
     1344      return u;
     1345    }
     1346  }
     1347  return n; // imm. int
    14091348}
    14101349
    … …  
    22812220}
    22822221
    2283 LINLINE number nl_Copy(number a, ring r)
    2284 {
    2285   if ((SR_HDL(a) & SR_INT)||(a==NULL))
    2286   {
    2287     return a;
    2288   }
    2289   return _nlCopy_NoImm(a);
    2290 }
    2291 
    22922222
    22932223LINLINE void nlNew (number * r)
    … …  
    23922322#endif // DO_LINLINE
    23932323
     2324#ifndef P_NUMBERS_H
     2325
     2326void nlInpGcd(number &a, number b, ring r)
     2327{
     2328  if ((SR_HDL(b)|SR_HDL(a))&SR_INT)
     2329  {
     2330    number n=nlGcd(a,b,r);
     2331    nlDelete(&a,r);
     2332    a=n;
     2333  }
     2334  else
     2335  {
     2336    mpz_gcd(&a->z,&a->z,&b->z);
     2337    if (mpz_size1(&a->z)<=MP_SMALL)
     2338    {
     2339      int ui=(int)mpz_get_si(&a->z);
     2340      if ((((ui<<3)>>3)==ui)
     2341      && (mpz_cmp_si(&a->z,(long)ui)==0))
     2342      {
     2343        mpz_clear(&a->z);
     2344        omFreeBin((ADDRESS)a, rnumber_bin);
     2345        a=INT_TO_SR(ui);
     2346      }       
     2347    }
     2348  }
     2349}
     2350void nlInpIntDiv(number &a, number b, ring r)
     2351{
     2352  if ((SR_HDL(b)|SR_HDL(a))&SR_INT)
     2353  {
     2354    number n=nlIntDiv(a,b);
     2355    nlDelete(&a,r);
     2356    a=n;
     2357  }
     2358  else
     2359  {
     2360    if (mpz_isNeg(&a->z))
     2361    {
     2362      if (mpz_isNeg(&b->z))
     2363      {
     2364        mpz_add(&a->z,&a->z,&b->z);
     2365      }
     2366      else
     2367      {
     2368        mpz_sub(&a->z,&a->z,&b->z);
     2369      }
     2370      mpz_add_ui(&a->z,&a->z,1);
     2371    }
     2372    else
     2373    {
     2374      if (mpz_isNeg(&b->z))
     2375      {
     2376        mpz_sub(&a->z,&a->z,&b->z);
     2377      }
     2378      else
     2379      {
     2380        mpz_add(&a->z,&a->z,&b->z);
     2381      }
     2382      mpz_sub_ui(&a->z,&a->z,1);
     2383    }
     2384    MPZ_DIV(&a->z,&a->z,&b->z);
     2385    if (mpz_size1(&a->z)<=MP_SMALL)
     2386    {
     2387      int ui=(int)mpz_get_si(&a->z);
     2388      if ((((ui<<3)>>3)==ui)
     2389      && (mpz_cmp_si(&a->z,(long)ui)==0))
     2390      {
     2391        mpz_clear(&a->z);
     2392        omFreeBin((ADDRESS)a, rnumber_bin);
     2393        a=INT_TO_SR(ui);
     2394      }
     2395    }
     2396  }
     2397}
     2398void nlInpAdd(number &a, number b, ring r)
     2399{
     2400  // TODO
     2401  if ((SR_HDL(b)|SR_HDL(a))&SR_INT)
     2402  {
     2403    number n=nlGcd(a,b,r);
     2404    nlDelete(&a,r);
     2405    a=n;
     2406  }
     2407  else
     2408  {
     2409    mpz_gcd(&a->z,&a->z,&b->z);
     2410    if (mpz_size1(&a->z)<=MP_SMALL)
     2411    {
     2412      int ui=(int)mpz_get_si(&a->z);
     2413      if ((((ui<<3)>>3)==ui)
     2414      && (mpz_cmp_si(&a->z,(long)ui)==0))
     2415      {
     2416        mpz_clear(&a->z);
     2417        omFreeBin((ADDRESS)a, rnumber_bin);
     2418        a=INT_TO_SR(ui);
     2419      }       
     2420    }
     2421  }
     2422}
     2423void nlInpMult(number &a, number b, ring r)
     2424{
     2425  if ((SR_HDL(b)|SR_HDL(a))&SR_INT)
     2426  {
     2427    number n=nlMult(a,b);
     2428    nlDelete(&a,r);
     2429    a=n;
     2430  }
     2431  else
     2432  {
     2433    mpz_mul(&a->z,&a->z,&b->z);
     2434    if (a->s==3)
     2435    {
     2436      if(b->s!=3)
     2437      {
     2438        mpz_init_set(&a->n,&b->n);
     2439      }
     2440    }
     2441    else
     2442    {
     2443      if(b->s!=3)
     2444      {
     2445        mpz_mul(&a->n,&a->n,&b->n);
     2446      }
     2447    } 
     2448  }
     2449}
     2450
     2451#if 0
     2452number nlMod(number a, number b)
     2453{
     2454  if (((SR_HDL(b)&SR_HDL(a))&SR_INT)
     2455  {
     2456    int bi=SR_TO_INT(b);
     2457    int ai=SR_TO_INT(a);
     2458    int bb=ABS(bi);
     2459    int c=ai%bb;
     2460    if (c<0)  c+=bb;
     2461    return (INT_TO_SR(c));
     2462  }
     2463  number al;
     2464  number bl;
     2465  if (SR_HDL(a))&SR_INT)
     2466    al=nlRInit(SR_TO_INT(a));
     2467  else
     2468    al=nlCopy(a);
     2469  if (SR_HDL(b))&SR_INT)
     2470    bl=nlRInit(SR_TO_INT(b));
     2471  else
     2472    bl=nlCopy(b);
     2473  number r=nlRInit(0);
     2474  mpz_mod(r->z,al->z,bl->z);
     2475  nlDelete(&al);
     2476  nlDelete(&bl);
     2477  if (mpz_size1(&r->z)<=MP_SMALL)
     2478  {
     2479    int ui=(int)mpz_get_si(&r->z);
     2480    if ((((ui<<3)>>3)==ui)
     2481    && (mpz_cmp_si(&x->z,(long)ui)==0))
     2482    {
     2483      mpz_clear(&r->z);
     2484      omFreeBin((ADDRESS)r, rnumber_bin);
     2485      r=INT_TO_SR(ui);
     2486    }
     2487  } 
     2488  return r;
     2489}
     2490#endif
     2491#endif // not P_NUMBERS_H
    23942492#endif // LONGRAT_CC

  • Singular/longrat.h

    rfdd985e ra3f03d9  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: longrat.h,v 1.30 2002-11-04 16:52:23 bricken Exp $ */
     6/* $Id: longrat.h,v 1.31 2002-11-26 13:54:40 Singular Exp $ */
    77/*
    88* ABSTRACT: computation with long rational numbers
    … …  
    1010#include "structs.h"
    1111
    12 extern "C" {
    13 #ifdef __cplusplus
    14 #undef __cplusplus
    15 #include <gmp.h>
    16 #define __cplusplus
    17 #else
    18 #include <gmp.h>
    19 #endif
    20 }
    21 #ifdef HAVE_SMALLGMP
    22 #  define HAVE_LIBGMP2
    23 #else
    24 #if (__GNU_MP_VERSION > 1) && (__GNU_MP_VERSION_MINOR >= 0)
    25 #  define HAVE_LIBGMP2
    26 #else
    27 #  define HAVE_LIBGMP1
    28 #endif
    29 #endif
     12#include "si_gmp.h"
    3013
    3114typedef MP_INT lint;
    … …  
    3821#define MP_SMALL 1
    3922
    40 #ifdef HAVE_LIBGMP1
    41 #define mpz_size1(A) (ABS((A)->size))
    42 #else
    4323#define mpz_size1(A) (ABS((A)->_mp_size))
    44 #endif
    4524//#define mpz_size1(A) mpz_size(A)
    4625
     26struct snumber;
     27typedef struct snumber  *number;
    4728struct snumber
    4829{
    … …  
    6950LINLINE BOOLEAN  nlIsZero(number za);
    7051LINLINE number   nlCopy(number a);
    71 LINLINE number   nl_Copy(number a, ring r);
    7252LINLINE void     nlNew(number *r);
    7353LINLINE void     nlDelete(number *a, const ring r);
    … …  
    9676int      nlSize(number n);
    9777number   nlGetDenom(number &n, const ring r);
     78number   nlGetNom(number &n, const ring r);
    9879#ifdef LDEBUG
    9980BOOLEAN  nlDBTest(number a, char *f, int l);
    … …  
    10889extern omBin_s* rnumber_bin;
    10990
     91// in-place operations
     92void nlInpGcd(number &a, number b, ring r);
     93void nlInpIntDiv(number &a, number b, ring r);
     94void nlInpAdd(number &a, number b, ring r);
     95void nlInpMult(number &a, number b, ring r);
     96
    11097#endif
    11198

  • Singular/numbers.cc

    rfdd985e ra3f03d9  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: numbers.cc,v 1.47 2002-07-23 13:09:37 Singular Exp $ */
     4/* $Id: numbers.cc,v 1.48 2002-11-26 13:54:43 Singular Exp $ */
    55
    66/*
    … …  
    4949char *  (*nRead)(char *s,number *a);
    5050void    (*nPower)(number a, int i, number * result);
    51 number  (*nGcd)(number a, number b, ring r);
    52 number  (*nLcm)(number a, number b, ring r);
     51number  (*nGcd)(number a, number b, const ring r);
     52number  (*nLcm)(number a, number b, const ring r);
    5353char * (*nName)(number n);
    54 void   (*n__Delete)(number *a, ring r);
     54void   (*n__Delete)(number *a, const ring r);
    5555
    5656/*0 implementation*/
    5757number nNULL; /* the 0 as constant */
    58 int    nChar;
    5958
    6059
    … …  
    6362void   nDummy1(number* d) { *d=NULL; }
    6463void   ndDelete(number* d, const ring r) { *d=NULL; }
     64void   ndInpMult(number &a, number b, ring r)
     65{
     66  number n=n_Mult(a,b,r);
     67  n_Delete(&a,r);
     68  a=n;
     69}
    6570
    6671#ifdef LDEBUG
    … …  
    8489number ndGetDenom(number &n, const ring r) { return n_Init(1,r); }
    8590
    86 int    nGetChar() { return nChar; }
    87 
    8891int ndSize(number a) { return (int)nIsZero(a)==FALSE; }
    8992
    9093number ndCopy(number a) { return a; }
    91 number nd_Copy(number a, ring r) { return r->cf->nCopy(a); }
     94number nd_Copy(number a,const ring r) { return r->cf->nCopy(a); }
    9295
    9396/*2
    … …  
    99102  int c=rInternalChar(r);
    100103
    101   nChar=c;
    102104  n__Delete= r->cf->cfDelete;
    103105  if (rField_is_Extension(r))
    … …  
    174176void nInitChar(ring r)
    175177{
    176   int c=rInternalChar(r);
     178  short c=rInternalChar(r);
    177179  n_coeffType t=rFieldType(r);
    178180
    … …  
    181183    if (r->algring==NULL)
    182184    {
    183       int ch=-c;
     185      short ch=-c;
    184186      if (c==1) ch=0;
    185187      r->algring=(ring) rDefault(ch,r->P,r->parameter);
    … …  
    211213  {
    212214    WerrorS("nInitChar failed");
     215    return;
    213216  }
    214217  r->cf=n;
    215   r->cf->nChar = c;
    216   r->cf->nPar  = ndPar;
    217   r->cf->nParDeg=ndParDeg;
    218   r->cf->nSize = ndSize;
    219   r->cf->n_GetDenom= ndGetDenom;
    220   r->cf->nName =  ndName;
    221   r->cf->nImPart=ndReturn0;
    222   r->cf->cfDelete= ndDelete;
    223   r->cf->nNew=nDummy1;
    224   r->cf->nCopy  = ndCopy;
    225   r->cf->cfCopy  = nd_Copy;
     218  n->nChar = c;
     219  n->nPar  = ndPar;
     220  n->nParDeg=ndParDeg;
     221  n->nSize = ndSize;
     222  n->n_GetDenom= ndGetDenom;
     223  n->nName =  ndName;
     224  n->nImPart=ndReturn0;
     225  n->cfDelete= ndDelete;
     226  n->nNew=nDummy1;
     227  n->nInpMult=ndInpMult;
     228  n->cfCopy=nd_Copy;
     229  n->nIntMod=ndIntMod; /* dummy !! */
     230  n->nNormalize=nDummy2;
     231  n->nGcd  = ndGcd;
     232  n->nLcm  = ndGcd; /* tricky, isn't it ?*/
    226233  if (rField_is_Extension(r))
    227234  {
    228235    //naInitChar(c,TRUE,r);
    229     r->cf->cfDelete = naDelete;
    230     r->cf-> nNew       = naNew;
    231     r->cf-> nNormalize = naNormalize;
    232     r->cf->nInit       = naInit;
    233     r->cf->nPar        = naPar;
    234     r->cf->nParDeg     = naParDeg;
    235     r->cf->nInt        = naInt;
    236     r->cf->nAdd        = naAdd;
    237     r->cf->nSub        = naSub;
    238     r->cf->nMult       = naMult;
    239     r->cf->nDiv        = naDiv;
    240     r->cf->nExactDiv   = naDiv;
    241     r->cf->nIntDiv     = naIntDiv;
    242     r->cf->nIntMod     = ndIntMod; /* dummy !! */
    243     r->cf->nNeg        = naNeg;
    244     r->cf->nInvers     = naInvers;
    245     r->cf->nCopy       = naCopy;
    246     r->cf->cfCopy      = na_Copy;
    247     r->cf->nGreater    = naGreater;
    248     r->cf->nEqual      = naEqual;
    249     r->cf->nIsZero     = naIsZero;
    250     r->cf->nIsOne      = naIsOne;
    251     r->cf->nIsMOne     = naIsMOne;
    252     r->cf->nGreaterZero= naGreaterZero;
    253     r->cf->nWrite      = naWrite;
    254     r->cf->nRead       = naRead;
    255     r->cf->nPower      = naPower;
    256     r->cf->nGcd        = naGcd;
    257     r->cf->nLcm        = naLcm;
    258     r->cf->cfSetMap    = naSetMap;
    259     r->cf->nName       = naName;
    260     r->cf->nSize       = naSize;
    261     r->cf->n_GetDenom   = naGetDenom;
    262 #ifdef LDEBUG
    263     //r->cf->nDBTest     = naDBTest;
     236    n->cfDelete = naDelete;
     237    n-> nNew       = naNew;
     238    n-> nNormalize = naNormalize;
     239    n->nInit       = naInit;
     240    n->nPar        = naPar;
     241    n->nParDeg     = naParDeg;
     242    n->nInt        = naInt;
     243    n->nAdd        = naAdd;
     244    n->nSub        = naSub;
     245    n->nMult       = naMult;
     246    n->nDiv        = naDiv;
     247    n->nExactDiv   = naDiv;
     248    n->nIntDiv     = naIntDiv;
     249    n->nNeg        = naNeg;
     250    n->nInvers     = naInvers;
     251    n->nCopy       = naCopy;
     252    n->cfCopy      = na_Copy;
     253    n->nGreater    = naGreater;
     254    n->nEqual      = naEqual;
     255    n->nIsZero     = naIsZero;
     256    n->nIsOne      = naIsOne;
     257    n->nIsMOne     = naIsMOne;
     258    n->nGreaterZero= naGreaterZero;
     259    n->nWrite      = naWrite;
     260    n->nRead       = naRead;
     261    n->nPower      = naPower;
     262    n->nGcd        = naGcd;
     263    n->nLcm        = naLcm;
     264    n->cfSetMap    = naSetMap;
     265    n->nName       = naName;
     266    n->nSize       = naSize;
     267    n->n_GetDenom   = naGetDenom;
     268#ifdef LDEBUG
     269    //n->nDBTest     = naDBTest;
    264270#endif
    265271  }
    266272  else if (rField_is_Q(r))
    267273  {
    268     r->cf->cfDelete= nlDelete;
    269     r->cf->nNew   = nlNew;
    270     r->cf->nNormalize=nlNormalize;
    271     r->cf->nInit  = nlInit;
    272     r->cf->nInt   = nlInt;
    273     r->cf->nAdd   = nlAdd;
    274     r->cf->nSub   = nlSub;
    275     r->cf->nMult  = nlMult;
    276     r->cf->nDiv   = nlDiv;
    277     r->cf->nExactDiv= nlExactDiv;
    278     r->cf->nIntDiv= nlIntDiv;
    279     r->cf->nIntMod= nlIntMod;
    280     r->cf->nNeg   = nlNeg;
    281     r->cf->nInvers= nlInvers;
    282     r->cf->nCopy  = nlCopy;
    283     r->cf->cfCopy  = nl_Copy;
    284     r->cf->nGreater = nlGreater;
    285     r->cf->nEqual = nlEqual;
    286     r->cf->nIsZero = nlIsZero;
    287     r->cf->nIsOne = nlIsOne;
    288     r->cf->nIsMOne = nlIsMOne;
    289     r->cf->nGreaterZero = nlGreaterZero;
    290     r->cf->nWrite = nlWrite;
    291     r->cf->nRead = nlRead;
    292     r->cf->nPower = nlPower;
    293     r->cf->nGcd  = nlGcd;
    294     r->cf->nLcm  = nlLcm;
    295     r->cf->cfSetMap = nlSetMap;
    296     r->cf->nSize  = nlSize;
    297     r->cf->n_GetDenom = nlGetDenom;
    298 #ifdef LDEBUG
    299     //r->cf->nDBTest=nlDBTest;
     274    n->cfDelete= nlDelete;
     275    n->nNew   = nlNew;
     276    n->nNormalize=nlNormalize;
     277    n->nInit  = nlInit;
     278    n->nInt   = nlInt;
     279    n->nAdd   = nlAdd;
     280    n->nSub   = nlSub;
     281    n->nMult  = nlMult;
     282    n->nDiv   = nlDiv;
     283    n->nExactDiv= nlExactDiv;
     284    n->nIntDiv= nlIntDiv;
     285    n->nIntMod= nlIntMod;
     286    n->nNeg   = nlNeg;
     287    n->nInvers= nlInvers;
     288    n->nCopy  = nlCopy;
     289    n->nGreater = nlGreater;
     290    n->nEqual = nlEqual;
     291    n->nIsZero = nlIsZero;
     292    n->nIsOne = nlIsOne;
     293    n->nIsMOne = nlIsMOne;
     294    n->nGreaterZero = nlGreaterZero;
     295    n->nWrite = nlWrite;
     296    n->nRead = nlRead;
     297    n->nPower = nlPower;
     298    n->nGcd  = nlGcd;
     299    n->nLcm  = nlLcm;
     300    n->cfSetMap = nlSetMap;
     301    n->nSize  = nlSize;
     302    n->n_GetDenom = nlGetDenom;
     303#ifdef LDEBUG
     304    //n->nDBTest=nlDBTest;
    300305#endif
    301306  }
    … …  
    304309  {
    305310    npInitChar(c,r);
    306     r->cf->nNormalize=nDummy2;
    307     r->cf->nInit  = npInit;
    308     r->cf->nInt   = npInt;
    309     r->cf->nAdd   = npAdd;
    310     r->cf->nSub   = npSub;
    311     r->cf->nMult  = npMult;
    312     r->cf->nDiv   = npDiv;
    313     r->cf->nExactDiv= npDiv;
    314     r->cf->nIntDiv= npDiv;
    315     r->cf->nIntMod= ndIntMod; /* dummy !! */
    316     r->cf->nNeg   = npNeg;
    317     r->cf->nInvers= npInvers;
    318     r->cf->nGreater = npGreater;
    319     r->cf->nEqual = npEqual;
    320     r->cf->nIsZero = npIsZero;
    321     r->cf->nIsOne = npIsOne;
    322     r->cf->nIsMOne = npIsMOne;
    323     r->cf->nGreaterZero = npGreaterZero;
    324     r->cf->nWrite = npWrite;
    325     r->cf->nRead = npRead;
    326     r->cf->nPower = npPower;
    327     r->cf->nGcd  = ndGcd;
    328     r->cf->nLcm  = ndGcd; /* tricky, isn't it ?*/
    329     r->cf->cfSetMap = npSetMap;
     311    n->nInit  = npInit;
     312    n->nInt   = npInt;
     313    n->nAdd   = npAdd;
     314    n->nSub   = npSub;
     315    n->nMult  = npMult;
     316    n->nDiv   = npDiv;
     317    n->nExactDiv= npDiv;
     318    n->nNeg   = npNeg;
     319    n->nInvers= npInvers;
     320    n->nCopy  = ndCopy;
     321    n->nGreater = npGreater;
     322    n->nEqual = npEqual;
     323    n->nIsZero = npIsZero;
     324    n->nIsOne = npIsOne;
     325    n->nIsMOne = npIsMOne;
     326    n->nGreaterZero = npGreaterZero;
     327    n->nWrite = npWrite;
     328    n->nRead = npRead;
     329    n->nPower = npPower;
     330    n->cfSetMap = npSetMap;
    330331    /* nName= ndName; */
    331332    /*nSize  = ndSize;*/
    332333#ifdef LDEBUG
    333     //r->cf->nDBTest=npDBTest;
     334    //n->nDBTest=npDBTest;
    334335#endif
    335336  }
    … …  
    338339  {
    339340    //nfSetChar(c,r->parameter);
    340     r->cf->nNormalize=nDummy2;
    341     r->cf->nInit  = nfInit;
    342     r->cf->nPar   = nfPar;
    343     r->cf->nParDeg= nfParDeg;
    344     r->cf->nInt   = nfInt;
    345     r->cf->nAdd   = nfAdd;
    346     r->cf->nSub   = nfSub;
    347     r->cf->nMult  = nfMult;
    348     r->cf->nDiv   = nfDiv;
    349     r->cf->nExactDiv= nfDiv;
    350     r->cf->nIntDiv= nfDiv;
    351     r->cf->nIntMod= ndIntMod; /* dummy !! */
    352     r->cf->nNeg   = nfNeg;
    353     r->cf->nInvers= nfInvers;
    354     r->cf->nGreater = nfGreater;
    355     r->cf->nEqual = nfEqual;
    356     r->cf->nIsZero = nfIsZero;
    357     r->cf->nIsOne = nfIsOne;
    358     r->cf->nIsMOne = nfIsMOne;
    359     r->cf->nGreaterZero = nfGreaterZero;
    360     r->cf->nWrite = nfWrite;
    361     r->cf->nRead = nfRead;
    362     r->cf->nPower = nfPower;
    363     r->cf->nGcd  = ndGcd;
    364     r->cf->nLcm  = ndGcd; /* tricky, isn't it ?*/
    365     r->cf->cfSetMap = nfSetMap;
    366     r->cf->nName= nfName;
     341    n->nInit  = nfInit;
     342    n->nPar   = nfPar;
     343    n->nParDeg= nfParDeg;
     344    n->nInt   = nfInt;
     345    n->nAdd   = nfAdd;
     346    n->nSub   = nfSub;
     347    n->nMult  = nfMult;
     348    n->nDiv   = nfDiv;
     349    n->nExactDiv= nfDiv;
     350    n->nNeg   = nfNeg;
     351    n->nInvers= nfInvers;
     352    n->nCopy  = ndCopy;
     353    n->nGreater = nfGreater;
     354    n->nEqual = nfEqual;
     355    n->nIsZero = nfIsZero;
     356    n->nIsOne = nfIsOne;
     357    n->nIsMOne = nfIsMOne;
     358    n->nGreaterZero = nfGreaterZero;
     359    n->nWrite = nfWrite;
     360    n->nRead = nfRead;
     361    n->nPower = nfPower;
     362    n->cfSetMap = nfSetMap;
     363    n->nName= nfName;
    367364    /*nSize  = ndSize;*/
    368365#ifdef LDEBUG
    369     //r->cf->nDBTest=nfDBTest;
     366    //n->nDBTest=nfDBTest;
    370367#endif
    371368  }
    … …  
    374371  else if (rField_is_R(r))
    375372  {
    376     r->cf->nNormalize=nDummy2;
    377     r->cf->nInit  = nrInit;
    378     r->cf->nInt   = nrInt;
    379     r->cf->nAdd   = nrAdd;
    380     r->cf->nSub   = nrSub;
    381     r->cf->nMult  = nrMult;
    382     r->cf->nDiv   = nrDiv;
    383     r->cf->nExactDiv= nrDiv;
    384     r->cf->nIntDiv= nrDiv;
    385     r->cf->nIntMod= ndIntMod; /* dummy !! */
    386     r->cf->nNeg   = nrNeg;
    387     r->cf->nInvers= nrInvers;
    388     r->cf->nGreater = nrGreater;
    389     r->cf->nEqual = nrEqual;
    390     r->cf->nIsZero = nrIsZero;
    391     r->cf->nIsOne = nrIsOne;
    392     r->cf->nIsMOne = nrIsMOne;
    393     r->cf->nGreaterZero = nrGreaterZero;
    394     r->cf->nWrite = nrWrite;
    395     r->cf->nRead = nrRead;
    396     r->cf->nPower = nrPower;
    397     r->cf->nGcd  = ndGcd;
    398     r->cf->nLcm  = ndGcd; /* tricky, isn't it ?*/
    399     r->cf->cfSetMap=nrSetMap;
     373    n->nInit  = nrInit;
     374    n->nInt   = nrInt;
     375    n->nAdd   = nrAdd;
     376    n->nSub   = nrSub;
     377    n->nMult  = nrMult;
     378    n->nDiv   = nrDiv;
     379    n->nExactDiv= nrDiv;
     380    n->nNeg   = nrNeg;
     381    n->nInvers= nrInvers;
     382    n->nCopy  = ndCopy;
     383    n->nGreater = nrGreater;
     384    n->nEqual = nrEqual;
     385    n->nIsZero = nrIsZero;
     386    n->nIsOne = nrIsOne;
     387    n->nIsMOne = nrIsMOne;
     388    n->nGreaterZero = nrGreaterZero;
     389    n->nWrite = nrWrite;
     390    n->nRead = nrRead;
     391    n->nPower = nrPower;
     392    n->cfSetMap=nrSetMap;
    400393    /* nName= ndName; */
    401394    /*nSize  = ndSize;*/
    402395#ifdef LDEBUG
    403     //r->cf->nDBTest=nrDBTest;
     396    //n->nDBTest=nrDBTest;
    404397#endif
    405398  }
    … …  
    407400  else if (rField_is_long_R(r))
    408401  {
    409     r->cf->cfDelete= ngfDelete;
    410     r->cf->nNew=ngfNew;
    411     r->cf->nNormalize=nDummy2;
    412     r->cf->nInit  = ngfInit;
    413     r->cf->nInt   = ngfInt;
    414     r->cf->nAdd   = ngfAdd;
    415     r->cf->nSub   = ngfSub;
    416     r->cf->nMult  = ngfMult;
    417     r->cf->nDiv   = ngfDiv;
    418     r->cf->nExactDiv= ngfDiv;
    419     r->cf->nIntDiv= ngfDiv;
    420     r->cf->nIntMod= ndIntMod; /* dummy !! */
    421     r->cf->nNeg   = ngfNeg;
    422     r->cf->nInvers= ngfInvers;
    423     r->cf->nCopy  = ngfCopy;
    424     r->cf->cfCopy  = ngf_Copy;
    425     r->cf->nGreater = ngfGreater;
    426     r->cf->nEqual = ngfEqual;
    427     r->cf->nIsZero = ngfIsZero;
    428     r->cf->nIsOne = ngfIsOne;
    429     r->cf->nIsMOne = ngfIsMOne;
    430     r->cf->nGreaterZero = ngfGreaterZero;
    431     r->cf->nWrite = ngfWrite;
    432     r->cf->nRead = ngfRead;
    433     r->cf->nPower = ngfPower;
    434     r->cf->nGcd  = ndGcd;
    435     r->cf->nLcm  = ndGcd; /* tricky, isn't it ?*/
    436     r->cf->cfSetMap=ngfSetMap;
    437     r->cf->nName= ndName;
    438     r->cf->nSize  = ndSize;
    439 #ifdef LDEBUG
    440     //r->cf->nDBTest=ngfDBTest;
     402    n->cfDelete= ngfDelete;
     403    n->nNew=ngfNew;
     404    n->nInit  = ngfInit;
     405    n->nInt   = ngfInt;
     406    n->nAdd   = ngfAdd;
     407    n->nSub   = ngfSub;
     408    n->nMult  = ngfMult;
     409    n->nDiv   = ngfDiv;
     410    n->nExactDiv= ngfDiv;
     411    n->nNeg   = ngfNeg;
     412    n->nInvers= ngfInvers;
     413    n->nCopy  = ngfCopy;
     414    n->nGreater = ngfGreater;
     415    n->nEqual = ngfEqual;
     416    n->nIsZero = ngfIsZero;
     417    n->nIsOne = ngfIsOne;
     418    n->nIsMOne = ngfIsMOne;
     419    n->nGreaterZero = ngfGreaterZero;
     420    n->nWrite = ngfWrite;
     421    n->nRead = ngfRead;
     422    n->nPower = ngfPower;
     423    n->cfSetMap=ngfSetMap;
     424    n->nName= ndName;
     425    n->nSize  = ndSize;
     426#ifdef LDEBUG
     427    //n->nDBTest=ngfDBTest;
    441428#endif
    442429  }
    … …  
    444431  else if (rField_is_long_C(r))
    445432  {
    446     r->cf->cfDelete= ngcDelete;
    447     r->cf->nNew=ngcNew;
    448     r->cf->nNormalize=nDummy2;
    449     r->cf->nInit  = ngcInit;
    450     r->cf->nInt   = ngcInt;
    451     r->cf->nAdd   = ngcAdd;
    452     r->cf->nSub   = ngcSub;
    453     r->cf->nMult  = ngcMult;
    454     r->cf->nDiv   = ngcDiv;
    455     r->cf->nExactDiv= ngcDiv;
    456     r->cf->nIntDiv= ngcDiv;
    457     r->cf->nIntMod= ndIntMod; /* dummy !! */
    458     r->cf->nNeg   = ngcNeg;
    459     r->cf->nInvers= ngcInvers;
    460     r->cf->nCopy  = ngcCopy;
    461     r->cf->cfCopy = ngc_Copy;
    462     r->cf->nGreater = ngcGreater;
    463     r->cf->nEqual = ngcEqual;
    464     r->cf->nIsZero = ngcIsZero;
    465     r->cf->nIsOne = ngcIsOne;
    466     r->cf->nIsMOne = ngcIsMOne;
    467     r->cf->nGreaterZero = ngcGreaterZero;
    468     r->cf->nWrite = ngcWrite;
    469     r->cf->nRead = ngcRead;
    470     r->cf->nPower = ngcPower;
    471     r->cf->nGcd  = ndGcd;
    472     r->cf->nLcm  = ndGcd; /* tricky, isn't it ?*/
    473     r->cf->cfSetMap=ngcSetMap;
    474     r->cf->nPar=ngcPar;
    475     r->cf->nRePart=ngcRePart;
    476     r->cf->nImPart=ngcImPart;
     433    n->cfDelete= ngcDelete;
     434    n->nNew=ngcNew;
     435    n->nNormalize=nDummy2;
     436    n->nInit  = ngcInit;
     437    n->nInt   = ngcInt;
     438    n->nAdd   = ngcAdd;
     439    n->nSub   = ngcSub;
     440    n->nMult  = ngcMult;
     441    n->nDiv   = ngcDiv;
     442    n->nExactDiv= ngcDiv;
     443    n->nNeg   = ngcNeg;
     444    n->nInvers= ngcInvers;
     445    n->nCopy  = ngcCopy;
     446    n->nGreater = ngcGreater;
     447    n->nEqual = ngcEqual;
     448    n->nIsZero = ngcIsZero;
     449    n->nIsOne = ngcIsOne;
     450    n->nIsMOne = ngcIsMOne;
     451    n->nGreaterZero = ngcGreaterZero;
     452    n->nWrite = ngcWrite;
     453    n->nRead = ngcRead;
     454    n->nPower = ngcPower;
     455    n->cfSetMap=ngcSetMap;
     456    n->nPar=ngcPar;
     457    n->nRePart=ngcRePart;
     458    n->nImPart=ngcImPart;
    477459    /*nSize  = ndSize;*/
    478460#ifdef LDEBUG
    479     //r->cf->nDBTest=ngcDBTest;
     461    //n->nDBTest=ngcDBTest;
    480462#endif
    481463  }
    … …  
    488470  if (!errorreported)
    489471  {
    490     r->cf->nNULL=r->cf->nInit(0);
    491     if (r->cf->nRePart==NULL)
    492       r->cf->nRePart=r->cf->nCopy;
     472    n->nNULL=n->nInit(0);
     473    if (n->nRePart==NULL)
     474      n->nRePart=n->nCopy;
     475    if (n->nIntDiv==NULL)
     476      n->nIntDiv=n->nDiv;
    493477  }
    494478}

  • Singular/numbers.h

    rfdd985e ra3f03d9  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: numbers.h,v 1.29 2002-07-23 13:09:37 Singular Exp $ */
     6/* $Id: numbers.h,v 1.30 2002-11-26 13:54:44 Singular Exp $ */
    77/*
    88* ABSTRACT: interface to coefficient aritmetics
    … …  
    1818#define n_Neg(n, r)           (r)->cf->nNeg(n)
    1919#define n_Sub(n1, n2, r)      (r)->cf->nSub(n1, n2)
    20 #define n_GetChar(r)          ((r)->cf->nChar)
     20//#define n_GetChar(r)          ((r)->cf->nChar)
     21#define n_GetChar(r)          ((r)->ch)
    2122#define n_Init(i, r)          (r)->cf->nInit(i)
    2223#define n_IsOne(n, r)         (r)->cf->nIsOne(n)
    … …  
    2728#define n_Gcd(a, b, r)        (r)->cf->nGcd(a,b,r)
    2829#define n_IntDiv(a, b, r)     (r)->cf->nIntDiv(a,b)
     30#define n_InpMult(a, b, r)    (r)->cf->nInpMult(a,b,r)
    2931
    3032/* variables */
    … …  
    7072void ndDelete(number* d, const ring r);
    7173void nDummy2(number &d);
    72 number ndGcd(number a, number b, const ring r);
     74number ndGcd(number a, number b, const ring);
    7375number ndCopy(number a);
    74 number nd_Copy(number a, ring r);
    7576
    7677#ifdef LDEBUG
    7778void nDBDummy1(number* d,char *f, int l);
    7879#endif
    79 int  nGetChar();
     80#define nGetChar() n_GetChar(currRing)
     81
    8082void nInitChar(ring r);
    8183void nKillChar(ring r);

  • Singular/structs.h

    rfdd985e ra3f03d9  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: structs.h,v 1.66 2002-07-23 13:09:34 Singular Exp $ */
     6/* $Id: structs.h,v 1.67 2002-11-26 13:54:44 Singular Exp $ */
    77/*
    88* ABSTRACT
    … …  
    207207{
    208208   n_Procs_s* next;
    209    int     nChar;
    210    n_coeffType type;
    211    int     char_flag;
    212    int     ref;
    213209   // the union stuff
    214210   // Zp:
    … …  
    217213   #ifdef HAVE_DIV_MOD
    218214   CARDINAL *npInvTable;
    219    #else
     215   #endif
     216   #if !defined(HAVE_DIV_MOD) || !defined(HAVE_MULT_MOD)
    220217   CARDINAL *npExpTable;
    221218   CARDINAL *npLogTable;
    … …  
    253250   nMapFunc (*cfSetMap)(ring src, ring dst);
    254251   char *  (*nName)(number n);
     252   void    (*nInpMult)(number &a, number b, ring r);
    255253//extern number  (*nMap)(number from);
    256254
    257255   number nNULL; /* the 0 as constant */
     256   int     char_flag;
     257   int     ref;
     258   short   nChar;
     259   n_coeffType type;
    258260};
    259261
Note: See TracChangeset for help on using the changeset viewer.