Changeset 8391d8 in git


Ignore:
Timestamp:
Sep 24, 2009, 6:37:42 PM (15 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b52fc4b2495505785981d640dcf7eb3e456778ef')
Children:
785e89b7306ebdeea35396a79b96dada09124098
Parents:
493699ee1754bff0d1b7c8f580f0b29c26002e60
Message:
*hannes: n_Init is now ring indep.


git-svn-id: file:///usr/local/Singular/svn/trunk@12128 2c84dea3-7e68-4137-9b89-c4e89433aadc
Files:
34 edited

Legend:

Unmodified
Added
Removed
  • Singular/iparith.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: iparith.cc,v 1.515 2009-09-16 12:45:30 Singular Exp $ */
     4/* $Id: iparith.cc,v 1.516 2009-09-24 16:36:12 Singular Exp $ */
    55
    66/*
     
    17201720  for(i=rl-1;i>=0;i--)
    17211721  {
    1722     q[i]=nlInit((*p)[i]);
    1723     x[i]=nlInit((*c)[i]);
     1722    q[i]=nlInit((*p)[i], NULL);
     1723    x[i]=nlInit((*c)[i], NULL);
    17241724  }
    17251725  number n=nlChineseRemainder(x,q,rl);
    17261726  for(i=rl-1;i>=0;i--)
    17271727  {
    1728     nlDelete(&(q[i]),currRing);
    1729     nlDelete(&(x[i]),currRing);
     1728    nlDelete(&(q[i]),NULL);
     1729    nlDelete(&(x[i]),NULL);
    17301730  }
    17311731  omFree(x); omFree(q);
     
    18181818  for(i=rl-1;i>=0;i--)
    18191819  {
    1820     q[i]=nlInit((*p)[i]);
     1820    q[i]=nlInit((*p)[i], currRing);
    18211821  }
    18221822  result=idChineseRemainder(x,q,rl);
     
    22552255  if (nlIsZero(a))
    22562256  {
    2257     if (nlIsZero(b)) res->data=(char *)nlInit(1);
     2257    if (nlIsZero(b)) res->data=(char *)nlInit(1, NULL);
    22582258    else             res->data=(char *)nlCopy(b);
    22592259  }
     
    42784278  if ((long)i == d)
    42794279  {
    4280     return nlInit(i);
     4280    return nlInit(i, NULL);
    42814281  }
    42824282  else
     
    42914291}
    42924292#else
    4293 #define jjLONG2N(D) nlInit((int)D)
     4293#define jjLONG2N(D) nlInit((int)D, NULL)
    42944294#endif
    42954295static BOOLEAN jjMEMORY(leftv res, leftv v)
     
    43694369  if (rField_is_Zp())
    43704370  {
    4371      if (((long)i)>(npPrimeM>>1))
    4372        n=nlInit((int)(((long)i)-npPrimeM));
    4373      else
    4374        n=nlInit((int)(long)i);
     4371    n=nlInit(npInt(i,currRing),NULL);
    43754372  }
    43764373  else if (rField_is_Q()) n=nlBigInt(i);
    43774374#ifdef HAVE_RINGS
    43784375  else if (rField_is_Ring_Z() || rField_is_Ring_ModN() || rField_is_Ring_PtoM()) n=nlMapGMP(i);
    4379   else if (rField_is_Ring_2toM()) n=nlInit((unsigned long) i);
     4376  else if (rField_is_Ring_2toM()) n=nlInit((unsigned long) i,NULL);
    43804377#endif
    43814378  else goto err;
     
    44564453{
    44574454  poly p=(poly)v->Data();
    4458   if (p==NULL) { res->data=(char *)nlInit(0); return FALSE; }
     4455  if (p==NULL) { res->data=(char *)nlInit(0,NULL); return FALSE; }
    44594456  if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
    44604457  {
     
    44664463  if (rField_is_Zp())
    44674464  {
    4468      if (((long)i)>(npPrimeM>>1))
    4469        n=nlInit((int)(((long)i)-npPrimeM));
    4470      else
    4471        n=nlInit((int)(long)i);
     4465    n=nlInit(npInt(i,currRing), NULL);
    44724466  }
    44734467  else if (rField_is_Q()) n=nlBigInt(i);
    44744468#ifdef HAVE_RINGS
    4475   else if (rField_is_Ring_Z() || rField_is_Ring_ModN() || rField_is_Ring_PtoM()) n=nlMapGMP(i);
    4476   else if (rField_is_Ring_2toM()) n=nlInit((unsigned long) i);
     4469  else if (rField_is_Ring_Z() || rField_is_Ring_ModN() || rField_is_Ring_PtoM())
     4470    n=nlMapGMP(i);
     4471  else if (rField_is_Ring_2toM())
     4472    n=nlInit((unsigned long) i, NULL);
    44774473#endif
    44784474  else goto err;
  • Singular/ipconv.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipconv.cc,v 1.41 2008-12-09 10:53:49 Singular Exp $ */
     4/* $Id: ipconv.cc,v 1.42 2009-09-24 16:36:12 Singular Exp $ */
    55/*
    66* ABSTRACT: automatic type conversions
     
    155155static void * iiI2BI(void *data)
    156156{
    157   number n=nlInit((int)(long)data);
     157  number n=nlInit((int)(long)data, NULL /*dummy for nlInit*/);
    158158  return (void *)n;
    159159}
  • Singular/ipid.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipid.cc,v 1.87 2009-07-28 14:18:34 Singular Exp $ */
     4/* $Id: ipid.cc,v 1.88 2009-09-24 16:36:12 Singular Exp $ */
    55
    66/*
     
    295295        break;
    296296      case BIGINT_CMD:
    297         IDNUMBER(h) = nlInit(0);
     297        IDNUMBER(h) = nlInit(0, NULL /* dummy for nlInit*/);
    298298        break;
    299299      case IDEAL_CMD:
  • Singular/ipshell.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipshell.cc,v 1.212 2009-09-17 07:43:15 seelisch Exp $ */
     4/* $Id: ipshell.cc,v 1.213 2009-09-24 16:36:12 Singular Exp $ */
    55/*
    66* ABSTRACT:
     
    21562156          if (IDELEMS(R->algring->qideal)==1)
    21572157          {
    2158             R->minpoly=naInit(1);
     2158            R->minpoly=naInit(1,R);
    21592159            lnumber n=(lnumber)R->minpoly;
    21602160            n->z=R->algring->qideal->m[0];
  • Singular/mpsr_GetPoly.cc

    r493699e r8391d8  
    33****************************************/
    44
    5 /* $Id: mpsr_GetPoly.cc,v 1.36 2009-08-14 17:13:42 Singular Exp $ */
     5/* $Id: mpsr_GetPoly.cc,v 1.37 2009-09-24 16:36:13 Singular Exp $ */
    66
    77/***************************************************************
     
    145145  MP_Uint32_t x;
    146146  mp_failr(IMP_GetUint32(link, &x));
    147   *a=npInit((int)x);
     147  *a=npInit((int)x, currRing);
    148148  return mpsr_Success;
    149149}
     
    225225  {
    226226    mp_failr(IMP_GetSint32(link, &i));
    227     *x = nlInit(i);
     227    *x = nlInit(i, currRing);
    228228  }
    229229  else if (node == MP_ApIntType)
     
    262262  // check for some more esoteric cases
    263263  else if (node == MP_Uint8Type)
    264     *x = nlInit(cvalue);
     264    *x = nlInit(cvalue, currRing);
    265265  else if (node == MP_Sint8Type)
    266266    // be careful -- need to handle the value "-2", for example
    267     *x = nlInit((int) ((MP_Sint8_t) cvalue));
     267    *x = nlInit((int) ((MP_Sint8_t) cvalue), currRing);
    268268  else if (node == MP_Uint32Type)
    269269  {
     
    272272    // check whether u_int can be casted safely to int
    273273    if (ui < INT_MAX)
    274       *x = nlInit(ui);
     274      *x = nlInit(ui, currRing);
    275275    else
    276276    {
  • kernel/clapconv.cc

    r493699e r8391d8  
    33*  Computer Algebra System SINGULAR     *
    44****************************************/
    5 // $Id: clapconv.cc,v 1.18 2009-09-16 12:26:26 Singular Exp $
     5// $Id: clapconv.cc,v 1.19 2009-09-24 16:37:41 Singular Exp $
    66/*
    77* ABSTRACT: convert data between Singular and factory
     
    482482  number n=convFactoryNSingN(xnew);
    483483  number p=convFactoryNSingN(qnew);
    484   number p2=nlIntDiv(p,nlInit(2));
     484  number p2=nlIntDiv(p,nlInit(2, currRing));
    485485  if (nlGreater(n,p2))
    486486  {
  • kernel/ffields.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ffields.cc,v 1.11 2009-09-16 12:26:26 Singular Exp $ */
     4/* $Id: ffields.cc,v 1.12 2009-09-24 16:37:41 Singular Exp $ */
    55/*
    66* ABSTRACT: finite fields with a none-prime number of elements (via tables)
     
    159159* int -> number
    160160*/
    161 number nfInit (int i)
     161number nfInit (int i, const ring r)
    162162{
    163163  // Hmm .. this is just to prevent initialization
     
    479479
    480480  s = nfEati(s, &i);
    481   z=nfInit(i);
     481  z=nfInit(i, currRing);
    482482  *a=z;
    483483  if (*s == '/')
     
    485485    s++;
    486486    s = nfEati(s, &i);
    487     n=nfInit(i);
     487    n=nfInit(i, currRing);
    488488    *a = nfDiv(z,n);
    489489  }
     
    670670number nfMapP(number c)
    671671{
    672   return nfInit((int)((long)c));
     672  return nfInit((int)((long)c), currRing);
    673673}
    674674
  • kernel/ffields.h

    r493699e r8391d8  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: ffields.h,v 1.4 2009-09-16 12:26:26 Singular Exp $ */
     6/* $Id: ffields.h,v 1.5 2009-09-24 16:37:41 Singular Exp $ */
    77/*
    88* ABSTRACT: finite fields with a none-prime number of elements (via tables)
     
    1313BOOLEAN nfGreaterZero (number k);
    1414number  nfMult        (number a, number b);
    15 number  nfInit        (int i);
     15number  nfInit        (int i, const ring r);
    1616number  nfPar         (int i);
    1717int     nfParDeg      (number n);
  • kernel/gnumpc.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: gnumpc.cc,v 1.9 2009-09-16 12:26:26 Singular Exp $ */
     4/* $Id: gnumpc.cc,v 1.10 2009-09-24 16:37:41 Singular Exp $ */
    55/*
    66* ABSTRACT: computations with GMP complex floating-point numbers
     
    6666{
    6767  if ( from != NULL)
    68     return ngcInit(npInt(from,ngfMapRing));
     68    return ngcInit(npInt(from,ngfMapRing), currRing);
    6969  else
    7070    return NULL;
     
    111111* n := i
    112112*/
    113 number ngcInit (int i)
     113number ngcInit (int i, const ring r)
    114114{
    115115  gmp_complex* n= NULL;
  • kernel/gnumpc.h

    r493699e r8391d8  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: gnumpc.h,v 1.4 2009-09-16 12:26:26 Singular Exp $ */
     6/* $Id: gnumpc.h,v 1.5 2009-09-24 16:37:41 Singular Exp $ */
    77/*
    88* ABSTRACT: computations with GMP floating-point numbers
     
    1717BOOLEAN  ngcIsZero(number za);
    1818void     ngcNew(number *r);
    19 number   ngcInit(int i);
     19number   ngcInit(int i, const ring r);
    2020int      ngcInt(number &n, const ring r);
    2121number   ngcNeg(number za);
  • kernel/gnumpfl.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: gnumpfl.cc,v 1.11 2009-09-16 12:26:26 Singular Exp $ */
     4/* $Id: gnumpfl.cc,v 1.12 2009-09-24 16:37:41 Singular Exp $ */
    55/*
    66* ABSTRACT: computations with GMP floating-point numbers
     
    2626{
    2727  if ( from != NULL)
    28     return ngfInit(npInt(from,ngfMapRing));
     28    return ngfInit(npInt(from,ngfMapRing), currRing);
    2929  else
    3030    return NULL;
     
    104104* n := i
    105105*/
    106 number ngfInit (int i)
     106number ngfInit (int i, const ring r)
    107107{
    108108  gmp_float* n= NULL;
  • kernel/gnumpfl.h

    r493699e r8391d8  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: gnumpfl.h,v 1.4 2009-09-16 12:26:26 Singular Exp $ */
     6/* $Id: gnumpfl.h,v 1.5 2009-09-24 16:37:41 Singular Exp $ */
    77/*
    88* ABSTRACT: computations with GMP floating-point numbers
     
    1717BOOLEAN  ngfIsZero(number za);
    1818void     ngfNew(number *r);
    19 number   ngfInit(int i);
     19number   ngfInit(int i, const ring r);
    2020int      ngfInt(number &n, const ring r);
    2121number   ngfNeg(number za);
  • kernel/ideals.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ideals.cc,v 1.77 2009-08-13 17:31:49 motsak Exp $ */
     4/* $Id: ideals.cc,v 1.78 2009-09-24 16:37:41 Singular Exp $ */
    55/*
    66* ABSTRACT - all basic methods to manipulate ideals
     
    39793979        }
    39803980        else
    3981           x[j]=nlInit(0);
     3981          x[j]=nlInit(0, currRing);
    39823982      }
    39833983      number n=nlChineseRemainder(x,q,rl);
  • kernel/longalg.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: longalg.cc,v 1.51 2009-09-16 12:26:26 Singular Exp $ */
     4/* $Id: longalg.cc,v 1.52 2009-09-24 16:37:41 Singular Exp $ */
    55/*
    66* ABSTRACT:   algebraic numbers
     
    3333#define napNormalize(p) p_Normalize(p,nacRing)
    3434static int naIsChar0;
    35 static int naPrimeM;
     35static ring naMapRing;
    3636
    3737#ifdef LDEBUG
     
    4949static number   (*nacLcm)(number a, number b, const ring r);
    5050static void     (*nacDelete)(number *a, const ring r);
    51        number   (*nacInit)(int i);
     51static number   (*nacInit)(int i, const ring r);
    5252static int      (*nacInt)(number &n, const ring r);
    5353       void     (*nacNormalize)(number &a);
     
    6969#define napCopy(p)       (napoly)p_Copy((poly)p,nacRing)
    7070
    71 static number nadGcd( number a, number b, const ring r) { return nacInit(1); }
     71static number nadGcd( number a, number b, const ring r) { return nacInit(1,r); }
    7272/*2
    7373*  sets the appropriate operators
     
    123123#endif
    124124  nacRing        = r->algring;
    125   nacInit        = nacRing->cf->nInit;
     125  nacInit        = nacRing->cf->cfInit;
    126126  nacInt         = nacRing->cf->n_Int;
    127127  nacCopy        = nacRing->cf->nCopy;
     
    524524  }
    525525  else
    526     pGetCoeff(a) = nacInit(1);
     526    pGetCoeff(a) = nacInit(1,nacRing);
    527527  i = 0;
    528528  const char  *olds=s;
     
    643643    return;
    644644  p = ph;
    645   h = nacInit(1);
     645  h = nacInit(1,nacRing);
    646646  while (p!=NULL)
    647647  {
     
    781781number napLcm(napoly a)
    782782{
    783   number h = nacInit(1);
     783  number h = nacInit(1,nacRing);
    784784
    785785  if (naIsChar0)
     
    890890*  z:= i
    891891*/
    892 number naInit(int i)
     892number naInit(int i, const ring r)
    893893{
    894894  if (i!=0)
    895895  {
    896     napoly z=napInit(i);
    897     if (z!=NULL)
    898     {
     896    number c=n_Init(i,r->algring);
     897    if (!n_IsZero(c,r->algring))
     898    {
     899      poly z=p_Init(r->algring);
     900      pSetCoeff0(z,c);
    899901      lnumber l = (lnumber)omAllocBin(rnumber_bin);
    900902      l->z = z;
     
    16361638{
    16371639  number x;
    1638   *rc = naInit(1);
     1640  *rc = naInit(1,nacRing);
    16391641  for (; i > 0; i--)
    16401642  {
     
    20652067  l->z=(napoly)p_Init(nacRing);
    20662068  int i=(int)((long)c);
    2067   if (i>(naPrimeM>>2)) i-=naPrimeM;
    2068   pGetCoeff(l->z)=nlInit(i);
     2069  if (i>((long)naMapRing->ch>>2)) i-=(long)naMapRing->ch;
     2070  pGetCoeff(l->z)=nlInit(i, nacRing);
    20692071  l->n=NULL;
    20702072  return (number)l;
     
    21062108  if (npIsZero(c)) return NULL;
    21072109  int i=(int)((long)c);
    2108   if (i>naPrimeM) i-=naPrimeM;
    2109   number n=npInit(i);
     2110  if (i>(long)naMapRing->ch) i-=(long)naMapRing->ch;
     2111  number n=npInit(i,naMapRing);
    21102112  if (npIsZero(n)) return NULL;
    21112113  lnumber l=(lnumber)omAllocBin(rnumber_bin);
     
    21232125{
    21242126  if (nlIsZero(c)) return NULL;
    2125   number n=npInit(nlModP(c,npPrimeM));
     2127  number n=npInit(nlModP(c,npPrimeM),nacRing);
    21262128  if (npIsZero(n)) return NULL;
    21272129  npTest(n);
     
    21362138static number (*nacMap)(number);
    21372139static int naParsToCopy;
    2138 static ring napMapRing;
    21392140static napoly napMap(napoly p)
    21402141{
     
    21452146  int i;
    21462147  for(i=1;i<=naParsToCopy;i++)
    2147     napSetExp(a,i,napGetExpFrom(p,i,napMapRing));
     2148    napSetExp(a,i,napGetExpFrom(p,i,naMapRing));
    21482149  p_Setm(a,nacRing);
    21492150  pGetCoeff(w) = nacMap(pGetCoeff(p));
     
    21552156    pIter(a);
    21562157    for(i=1;i<=naParsToCopy;i++)
    2157       napSetExp(a,i,napGetExpFrom(p,i,napMapRing));
     2158      napSetExp(a,i,napGetExpFrom(p,i,naMapRing));
    21582159    p_Setm(a,nacRing);
    21592160    pGetCoeff(a) = nacMap(pGetCoeff(p));
     
    22452246nMapFunc naSetMap(ring src, ring dst)
    22462247{
     2248  naMapRing=src;
    22472249  if (rField_is_Q_a(dst)) /* -> Q(a) */
    22482250  {
     
    22532255    if (rField_is_Zp(src))
    22542256    {
    2255       naPrimeM = rChar(src);
    22562257      return naMapP0;  /* Z/p -> Q(a)*/
    22572258    }
     
    22672268        naParsToCopy++;
    22682269      }
    2269       napMapRing=src;
    22702270      nacMap=nacCopy;
    22712271      if ((naParsToCopy==rPar(dst))&&(naParsToCopy==rPar(src)))
     
    22832283    if (rField_is_Zp(src))
    22842284    {
    2285       int c=rChar(src);
    2286       if (c==npPrimeM)
     2285      if (src->ch==dst->ch)
    22872286      {
    22882287        return naMapPP;  /* Z/p -> Z/p(a)*/
     
    22902289      else
    22912290      {
    2292         naPrimeM = c;
    22932291        return naMapPP1;  /* Z/p' -> Z/p(a)*/
    22942292      }
     
    23022300      else
    23032301      {
    2304         npMapPrime=rChar(src);
    23052302        nacMap = npMapP;
    23062303      }
     
    23142311        naParsToCopy++;
    23152312      }
    2316       napMapRing=src;
    23172313      if ((naParsToCopy==rPar(dst))&&(naParsToCopy==rPar(src))
    23182314      && (nacMap==nacCopy))
     
    24302426    return (number)rr;
    24312427  }
    2432   return r->cf->nInit(1);
     2428  return n_Init(1,r);
    24332429}
    24342430
  • kernel/longalg.h

    r493699e r8391d8  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: longalg.h,v 1.17 2009-09-16 12:26:26 Singular Exp $ */
     6/* $Id: longalg.h,v 1.18 2009-09-24 16:37:41 Singular Exp $ */
    77/*
    88* ABSTRACT:   algebraic numbers
     
    2828void naSetChar(int p, ring r);
    2929void    naDelete (number *p, const ring r);
    30 number  naInit(int i);                              /* z := i */
     30number  naInit(int i, const ring r);                /* z := i */
    3131number  naPar(int i);                               /* z := par(i) */
    3232int     naParDeg(number n);                         /* i := deg(n) */
  • kernel/longrat.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: longrat.cc,v 1.44 2009-09-16 12:26:26 Singular Exp $ */
     4/* $Id: longrat.cc,v 1.45 2009-09-24 16:37:41 Singular Exp $ */
    55/*
    66* ABSTRACT: computation with long rational numbers (Hubert Grassmann)
     
    106106{
    107107  number to;
    108   to = nlInit(npInt(from,nlMapRing));
     108  to = nlInit(npInt(from,nlMapRing), currRing);
    109109  return to;
    110110}
     
    22292229
    22302230
    2231 LINLINE number nlInit (int i)
     2231LINLINE number nlInit (int i, const ring r)
    22322232{
    22332233  number n;
  • kernel/longrat.h

    r493699e r8391d8  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: longrat.h,v 1.15 2009-09-16 12:26:26 Singular Exp $ */
     6/* $Id: longrat.h,v 1.16 2009-09-24 16:37:41 Singular Exp $ */
    77/*
    88* ABSTRACT: computation with long rational numbers
     
    4848
    4949LINLINE BOOLEAN  nlEqual(number a, number b);
    50 LINLINE number   nlInit(int i);
     50LINLINE number   nlInit(int i, const ring r);
    5151number nlRInit (int i);
    5252LINLINE BOOLEAN  nlIsOne(number a);
  • kernel/modulop.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: modulop.cc,v 1.18 2009-09-21 13:59:32 Singular Exp $ */
     4/* $Id: modulop.cc,v 1.19 2009-09-24 16:37:41 Singular Exp $ */
    55/*
    66* ABSTRACT: numbers modulo p (<=32003)
     
    6262* create a number from int
    6363*/
    64 number npInit (int i)
     64number npInit (int i, const ring r)
    6565{
    6666  long ii=i;
    67   while (ii <  0)                    ii += npPrimeM;
    68   while ((ii>1) && (ii >= npPrimeM)) ii -= npPrimeM;
     67  while (ii <  0L)                         ii += (long)r->ch;
     68  while ((ii>1L) && (ii >= ((long)r->ch))) ii -= (long)r->ch;
    6969  return (number)ii;
    7070}
     
    406406number npMap0(number from)
    407407{
    408   return npInit(nlModP(from,npPrimeM));
     408  return npInit(nlModP(from,npPrimeM),currRing);
    409409}
    410410
     
    434434  size = (*f)[0]._mp_size;
    435435  if (size == 0)
    436     return npInit(0);
     436    return npInit(0,currRing);
    437437  if(size<0)
    438438    size = -size;
  • kernel/modulop.h

    r493699e r8391d8  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: modulop.h,v 1.9 2009-09-16 12:26:26 Singular Exp $ */
     6/* $Id: modulop.h,v 1.10 2009-09-24 16:37:41 Singular Exp $ */
    77/*
    88* ABSTRACT: numbers modulo p (<=32003)
     
    2828BOOLEAN npGreaterZero (number k);
    2929number  npMult        (number a, number b);
    30 number  npInit        (int i);
     30number  npInit        (int i, const ring r);
    3131int     npInt         (number &n, const ring r);
    3232number  npAdd         (number a, number b);
  • kernel/numbers.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: numbers.cc,v 1.26 2009-09-16 12:26:26 Singular Exp $ */
     4/* $Id: numbers.cc,v 1.27 2009-09-24 16:37:41 Singular Exp $ */
    55
    66/*
     
    3333
    3434void   (*nNew)(number *a);
    35 number (*nInit)(int i);
    3635number  (*nInit_bigint)(number i);
    3736number (*nPar)(int i);
     
    106105int    ndParDeg(number n) { return 0; }
    107106
    108 number ndGcd(number a, number b, const ring r) { return r->cf->nInit(1); }
     107number ndGcd(number a, number b, const ring r) { return n_Init(1,r); }
    109108
    110109number ndIntMod(number a, number b) { return nInit(0); }
     
    210209  nNew   = r->cf->nNew;
    211210  nNormalize=r->cf->nNormalize;
    212   nInit  = r->cf->nInit;
    213211  nPar   = r->cf->nPar;
    214212  nParDeg= r->cf->nParDeg;
     
    323321    n-> nNew       = naNew;
    324322    n-> nNormalize = naNormalize;
    325     n->nInit       = naInit;
     323    n->cfInit      = naInit;
    326324    n->nPar        = naPar;
    327325    n->nParDeg     = naParDeg;
     
    362360  {
    363361     nr2mInitExp(c,r);
    364      n->nInit = nr2mInit;
     362     n->cfInit = nr2mInit;
    365363     n->nCopy  = ndCopy;
    366364     n->n_Int  = nr2mInt;
     
    402400  {
    403401     nrnInitExp(c,r);
    404      n->nInit  = nrnInit;
     402     n->cfInit  = nrnInit;
    405403     n->cfDelete= nrnDelete;
    406404     n->nCopy  = nrnCopy;
     
    443441  else if (rField_is_Ring_Z(r))
    444442  {
    445      n->nInit  = nrzInit;
     443     n->cfInit  = nrzInit;
    446444     n->cfDelete= nrzDelete;
    447445     n->nCopy  = nrzCopy;
     
    487485    n->nNew   = nlNew;
    488486    n->nNormalize=nlNormalize;
    489     n->nInit = nlInit;
     487    n->cfInit = nlInit;
    490488    n->n_Int  = nlInt;
    491489    n->nAdd   = nlAdd;
     
    523521  {
    524522    npInitChar(c,r);
    525     n->nInit = npInit;
     523    n->cfInit = npInit;
    526524    n->n_Int  = npInt;
    527525    n->nAdd   = npAdd;
     
    563561  {
    564562    //nfSetChar(c,r->parameter);
    565     n->nInit = nfInit;
     563    n->cfInit = nfInit;
    566564    n->nPar   = nfPar;
    567565    n->nParDeg= nfParDeg;
     
    595593  else if (rField_is_R(r))
    596594  {
    597     n->nInit = nrInit;
     595    n->cfInit = nrInit;
    598596    n->n_Int  = nrInt;
    599597    n->nAdd   = nrAdd;
     
    626624    n->cfDelete= ngfDelete;
    627625    n->nNew=ngfNew;
    628     n->nInit = ngfInit;
     626    n->cfInit = ngfInit;
    629627    n->n_Int  = ngfInt;
    630628    n->nAdd   = ngfAdd;
     
    658656    n->nNew=ngcNew;
    659657    n->nNormalize=nDummy2;
    660     n->nInit = ngcInit;
     658    n->cfInit = ngcInit;
    661659    n->n_Int  = ngcInt;
    662660    n->nAdd   = ngcAdd;
     
    697695  if (!errorreported)
    698696  {
    699     n->nNULL=n->nInit(0);
     697    n->nNULL=n->cfInit(0,r);
    700698    if (n->nRePart==NULL)
    701699      n->nRePart=n->nCopy;
  • kernel/numbers.h

    r493699e r8391d8  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: numbers.h,v 1.19 2009-09-16 12:26:27 Singular Exp $ */
     6/* $Id: numbers.h,v 1.20 2009-09-24 16:37:41 Singular Exp $ */
    77/*
    88* ABSTRACT: interface to coefficient aritmetics
     
    2020//#define n_GetChar(r)          ((r)->cf->nChar)
    2121#define n_GetChar(r)          ((r)->ch)
    22 #define n_Init(i, r)          (r)->cf->nInit(i)
     22#define n_Init(i, r)          (r)->cf->cfInit(i,r)
    2323#define n_IsOne(n, r)         (r)->cf->nIsOne(n)
    2424#define n_IsMOne(n, r)        (r)->cf->nIsMOne(n)
     
    4646extern numberfunc nMult, nSub ,nAdd ,nDiv, nIntDiv, nIntMod, nExactDiv;
    4747extern void    (*nNew)(number * a);
    48 extern number  (*nInit)(int i);
    4948extern number  (*nInit_bigint)(number i);
     49#define        nInit(i) n_Init(i,currRing)
    5050extern number  (*nPar)(int i);
    5151extern int     (*nParDeg)(number n);
  • kernel/p_polys.cc

    r493699e r8391d8  
    77 *  Author:  obachman (Olaf Bachmann)
    88 *  Created: 8/00
    9  *  Version: $Id: p_polys.cc,v 1.19 2009-08-13 17:31:50 motsak Exp $
     9 *  Version: $Id: p_polys.cc,v 1.20 2009-09-24 16:37:41 Singular Exp $
    1010 *******************************************************************/
    1111
     
    11121112  {
    11131113    rc = p_Init(r);
    1114     pSetCoeff0(rc,r->cf->nInit(i));
     1114    pSetCoeff0(rc,n_Init(i,r));
    11151115    if (r->cf->nIsZero(p_GetCoeff(rc,r)))
    11161116      p_DeleteLm(&rc,r);
     
    11251125{
    11261126  poly rc = p_Init(r);
    1127   pSetCoeff0(rc,r->cf->nInit(1));
     1127  pSetCoeff0(rc,n_Init(1,r));
    11281128  return rc;
    11291129}
  • kernel/polys1.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: polys1.cc,v 1.40 2009-06-04 08:32:59 Singular Exp $ */
     4/* $Id: polys1.cc,v 1.41 2009-09-24 16:37:42 Singular Exp $ */
    55
    66/*
     
    579579    if (rField_is_Q_a())
    580580    {
    581       number hzz = nlInit(1);
    582       h = nlInit(1);
     581      number hzz = nlInit(1, currRing);
     582      h = nlInit(1, currRing);
    583583      p=ph;
    584584      while (p!=NULL)
     
    13381338              else /* more difficult: we have really to multiply: */
    13391339              {
    1340                 lnumber mmc=(lnumber)naInit(1);
     1340                lnumber mmc=(lnumber)naInit(1,currRing);
    13411341                napSetExp(mmc->z,-perm[i],e/*p_GetExp( p,i,oldRing)*/);
    13421342                napSetm(mmc->z);
  • kernel/rintegers.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: rintegers.cc,v 1.24 2009-09-16 12:26:27 Singular Exp $ */
     4/* $Id: rintegers.cc,v 1.25 2009-09-24 16:37:42 Singular Exp $ */
    55/*
    66* ABSTRACT: numbers modulo n
     
    8787 * create a number from int
    8888 */
    89 number nrzInit (int i)
     89number nrzInit (int i, const ring r)
    9090{
    9191  int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
     
    146146number  nrzGetUnit (number a)
    147147{
    148   return nrzInit(1);
     148  return nrzInit(1, currRing);
    149149}
    150150
  • kernel/rintegers.h

    r493699e r8391d8  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: rintegers.h,v 1.10 2009-09-16 12:26:27 Singular Exp $ */
     6/* $Id: rintegers.h,v 1.11 2009-09-24 16:37:42 Singular Exp $ */
    77/*
    88* ABSTRACT: numbers modulo n
     
    2020BOOLEAN nrzGreaterZero (number k);
    2121number  nrzMult        (number a, number b);
    22 number  nrzInit        (int i);
     22number  nrzInit        (int i, const ring r);
    2323int     nrzInt         (number &n, const ring r);
    2424number  nrzAdd         (number a, number b);
  • kernel/rmodulo2m.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: rmodulo2m.cc,v 1.27 2009-09-16 12:26:27 Singular Exp $ */
     4/* $Id: rmodulo2m.cc,v 1.28 2009-09-24 16:37:42 Singular Exp $ */
    55/*
    66* ABSTRACT: numbers modulo 2^m
     
    131131 * create a number from int
    132132 */
    133 number nr2mInit (int i)
     133number nr2mInit (int i, const ring r)
    134134{
    135135  long ii = i;
  • kernel/rmodulo2m.h

    r493699e r8391d8  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: rmodulo2m.h,v 1.13 2009-09-16 12:26:27 Singular Exp $ */
     6/* $Id: rmodulo2m.h,v 1.14 2009-09-24 16:37:42 Singular Exp $ */
    77/*
    88* ABSTRACT: numbers modulo 2^m
     
    1616BOOLEAN nr2mGreaterZero (number k);
    1717number  nr2mMult        (number a, number b);
    18 number  nr2mInit        (int i);
     18number  nr2mInit        (int i, const ring r);
    1919int     nr2mInt         (number &n, const ring r);
    2020number  nr2mAdd         (number a, number b);
  • kernel/rmodulon.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: rmodulon.cc,v 1.38 2009-09-16 12:26:27 Singular Exp $ */
     4/* $Id: rmodulon.cc,v 1.39 2009-09-24 16:37:42 Singular Exp $ */
    55/*
    66* ABSTRACT: numbers modulo n
     
    3131 * create a number from int
    3232 */
    33 number nrnInit (int i)
     33number nrnInit (int i, const ring r)
    3434{
    3535  int_number erg = (int_number) omAllocBin(gmp_nrn_bin);
     
    145145number nrnGcd (number a,number b,ring r)
    146146{
    147   if ((a == NULL) && (b == NULL)) return nrnInit(0);
     147  if ((a == NULL) && (b == NULL)) return nrnInit(0,r);
    148148  int_number erg = (int_number) omAllocBin(gmp_nrn_bin);
    149149  mpz_init_set(erg, nrnModul);
     
    228228number  nrnGetUnit (number k)
    229229{
    230   if (mpz_divisible_p(nrnModul, (int_number) k)) return nrnInit(1);
     230  if (mpz_divisible_p(nrnModul, (int_number) k)) return nrnInit(1,currRing);
    231231
    232232  int_number unit = (int_number) nrnGcd(k, 0, currRing);
  • kernel/rmodulon.h

    r493699e r8391d8  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: rmodulon.h,v 1.13 2009-09-16 12:26:27 Singular Exp $ */
     6/* $Id: rmodulon.h,v 1.14 2009-09-24 16:37:42 Singular Exp $ */
    77/*
    88* ABSTRACT: numbers modulo n
     
    2121BOOLEAN nrnGreaterZero (number k);
    2222number  nrnMult        (number a, number b);
    23 number  nrnInit        (int i);
     23number  nrnInit        (int i, const ring r);
    2424int     nrnInt         (number &n, const ring r);
    2525number  nrnAdd         (number a, number b);
  • kernel/shortfl.cc

    r493699e r8391d8  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: shortfl.cc,v 1.8 2009-09-16 12:26:27 Singular Exp $ */
     4/* $Id: shortfl.cc,v 1.9 2009-09-24 16:37:42 Singular Exp $ */
    55
    66/*
     
    4848* create a number from int
    4949*/
    50 number nrInit (int i)
     50number nrInit (int i, const ring R)
    5151{
    5252  float r = (float)i;
  • kernel/shortfl.h

    r493699e r8391d8  
    77* ABSTRACT
    88*/
    9 /* $Id: shortfl.h,v 1.4 2009-09-16 12:26:27 Singular Exp $ */
     9/* $Id: shortfl.h,v 1.5 2009-09-24 16:37:42 Singular Exp $ */
    1010#include "structs.h"
    1111
    1212BOOLEAN nrGreaterZero (number k);
    1313number  nrMult        (number a, number b);
    14 number  nrInit        (int i);
     14number  nrInit        (int i, const ring r);
    1515int     nrInt         (number &n, const ring r);
    1616number  nrAdd         (number a, number b);
  • kernel/structs.h

    r493699e r8391d8  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: structs.h,v 1.65 2009-09-16 12:26:27 Singular Exp $ */
     6/* $Id: structs.h,v 1.66 2009-09-24 16:37:42 Singular Exp $ */
    77/*
    88* ABSTRACT
     
    275275   numberfunc nMult, nSub ,nAdd ,nDiv, nIntDiv, nIntMod, nExactDiv;
    276276   void    (*nNew)(number * a);
    277    number  (*nInit)(int i);
     277   number  (*cfInit)(int i,const ring r);
    278278   number  (*nPar)(int i);
    279279   int     (*nParDeg)(number n);
  • kernel/tgb.cc

    r493699e r8391d8  
    55*  Computer Algebra System SINGULAR     *
    66****************************************/
    7 /* $Id: tgb.cc,v 1.166 2009-09-16 12:26:27 Singular Exp $ */
     7/* $Id: tgb.cc,v 1.167 2009-09-24 16:37:42 Singular Exp $ */
    88/*
    99* ABSTRACT: slimgb and F4 implementation
     
    113113{
    114114  poly rc = p_Init_Special(r);
    115   pSetCoeff0(rc,r->cf->nInit(1));
     115  pSetCoeff0(rc,n_Init(1,r));
    116116  return rc;
    117117}
  • kernel/tgb_internal.h

    r493699e r8391d8  
    55*  Computer Algebra System SINGULAR     *
    66****************************************/
    7 /* $Id: tgb_internal.h,v 1.75 2009-09-21 14:39:55 Singular Exp $ */
     7/* $Id: tgb_internal.h,v 1.76 2009-09-24 16:37:42 Singular Exp $ */
    88/*
    99 * ABSTRACT: tgb internal .h file
     
    793793    number coef_bak=p_GetCoeff(t,c->r);
    794794
    795     p_SetCoeff(t,npInit(1),c->r);
     795    p_SetCoeff(t,npInit(1,c->r),c->r);
    796796    assume(npIsOne(p_GetCoeff(c->strat->S[i],c->r)));
    797797    number coefstrat=p_GetCoeff(c->strat->S[i],c->r);
     
    820820  } else {
    821821    number coef_bak=p_GetCoeff(t,c->r);
    822     number one=npInit(1);
     822    number one=npInit(1, currRing);
    823823    p_SetCoeff(t,one,c->r);
    824824
     
    10801080   int temp_size=cache->nIrreducibleMonomials;
    10811081   memset(temp_array,0,temp_size_bytes);
    1082    number minus_one=npInit(-1);
     1082   number minus_one=npInit(-1,currRing);
    10831083   int i;
    10841084   for(i=0;i<len;i++)
     
    12861286  int pos=0;
    12871287  int j;
    1288   const number one=npInit(1);
    1289   const number minus_one=npInit(-1);
     1288  const number one=npInit(1, currRing);
     1289  const number minus_one=npInit(-1, currRing);
    12901290  for(i=0;i<len;i++)
    12911291  {
     
    13941394  assume(len==pLength(p));
    13951395  poly orig_p=p;
    1396   if (p==NULL) {
     1396  if (p==NULL)
     1397  {
    13971398    len=0;
    13981399    return NULL;
    13991400  }
    14001401
    1401   number zero=npInit(0);
     1402  number zero=npInit(0,currRing);
    14021403  MonRedResNP<number_type>* mon=(MonRedResNP<number_type>*) omalloc(len*sizeof(MonRedResNP<number_type>));
    14031404  int i=0;
    14041405  double max_density=0.0;
    1405   while(p){
    1406 
     1406  while(p!=NULL)
     1407  {
    14071408    poly t=p;
    14081409    pIter(p);
     
    15421543    //assume rows "under r" have bigger or equal start index
    15431544    number_type* row_array=rows[r];
    1544     number_type zero=F4mat_to_number_type(npInit(0));
     1545    number_type zero=F4mat_to_number_type(npInit(0, currRing));
    15451546    int start=startIndices[r];
    15461547    number_type coef=row_array[start];
     
    15521553    assume(npIsOne((number) row_array[start]));
    15531554    int lastIndex=modP_lastIndexRow(row_array, ncols);
    1554     number minus_one=npInit(-1);
     1555    number minus_one=npInit(-1, currRing);
    15551556    for (other_row=r+1;other_row<nrows;other_row++)
    15561557    {
     
    18211822  number_type* number_array=(number_type*) omalloc(n*pn*sizeof(number_type));
    18221823  memset(number_array,0,sizeof(number_type)*n*pn);
    1823   number zero=npInit(0);
     1824  number zero=npInit(0, currRing);
    18241825
    18251826  for(j=0;j<pn;j++){
Note: See TracChangeset for help on using the changeset viewer.