Changeset 958e16 in git


Ignore:
Timestamp:
Jan 9, 2001, 4:40:16 PM (23 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', 'f7310ec678c9a43c82931ce9d078d4a5753828c9')
Children:
7c7ca9230029cf671d69f48a31aeed1b1346288d
Parents:
7f03cd745a69a67b839b01c64677d5b9aec8dd64
Message:
*hannes: merged number-ops


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

Legend:

Unmodified
Added
Removed
  • Singular/fglmgauss.cc

    r7f03cd r958e16  
    11// emacs edit mode for this file is -*- C++ -*-
    2 // $Id: fglmgauss.cc,v 1.13 2000-09-18 09:18:58 obachman Exp $
     2// $Id: fglmgauss.cc,v 1.14 2001-01-09 15:40:05 Singular Exp $
    33
    44/****************************************
     
    138138            nDelete( & gcd );
    139139            gcd= p.gcd();
    140             temp= nGcd( pdenom, gcd );
     140            temp= nGcd( pdenom, gcd, currRing );
    141141            nDelete( & gcd );
    142142            gcd= temp;
  • Singular/fglmvec.cc

    r7f03cd r958e16  
    11// emacs edit mode for this file is -*- C++ -*-
    2 // $Id: fglmvec.cc,v 1.14 2000-09-18 09:18:58 obachman Exp $
     2// $Id: fglmvec.cc,v 1.15 2001-01-09 15:40:05 Singular Exp $
    33
    44/****************************************
     
    451451            current= rep->getconstelem( i );
    452452            if ( ! nIsZero( current ) ) {
    453                 number temp= nGcd( theGcd, current );
     453                number temp= nGcd( theGcd, current, currRing );
    454454                nDelete( &theGcd );
    455455                theGcd= temp;
     
    474474        if ( ! nIsZero( rep->getconstelem(i) ) ) {
    475475            isZero= FALSE;
    476             number temp= nLcm( theLcm, rep->getconstelem( i ) );
     476            number temp= nLcm( theLcm, rep->getconstelem( i ), currRing );
    477477            nDelete( &theLcm );
    478478            theLcm= temp;
  • Singular/fglmzero.cc

    r7f03cd r958e16  
    11// emacs edit mode for this file is -*- C++ -*-
    2 // $Id: fglmzero.cc,v 1.32 2000-12-15 18:49:28 Singular Exp $
     2// $Id: fglmzero.cc,v 1.33 2001-01-09 15:40:06 Singular Exp $
    33
    44/****************************************
     
    983983            nDelete( & gcd );
    984984            gcd= p.gcd();
    985             temp= nGcd( pdenom, gcd );
     985            temp= nGcd( pdenom, gcd, currRing );
    986986            nDelete( &gcd );
    987987            gcd= temp;
  • Singular/gnumpc.cc

    r7f03cd r958e16  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: gnumpc.cc,v 1.16 2000-12-15 18:49:28 Singular Exp $ */
     4/* $Id: gnumpc.cc,v 1.17 2001-01-09 15:40:06 Singular Exp $ */
    55/*
    66* ABSTRACT: computations with GMP complex floating-point numbers
     
    8383* delete a
    8484*/
    85 #ifdef LDEBUG
    86 void ngcDBDelete (number * a,char *f, int l)
    87 #else
    88 void ngcDelete (number * a)
    89 #endif
     85void ngcDelete (number * a, ring r)
    9086{
    9187  if ( *a != NULL ) {
  • Singular/gnumpc.h

    r7f03cd r958e16  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: gnumpc.h,v 1.7 2000-12-15 18:49:29 Singular Exp $ */
     6/* $Id: gnumpc.h,v 1.8 2001-01-09 15:40:07 Singular Exp $ */
    77/*
    88* ABSTRACT: computations with GMP floating-point numbers
     
    3636#ifdef LDEBUG
    3737BOOLEAN  ngcDBTest(number a, char *f, int l);
    38 void     ngcDBDelete(number *a, char *f, int l);
    39 #define  ngcDelete(A) nlDBDelete(A,__FILE__,__LINE__)
    40 #else
    41 void     ngcDelete(number *a);
    4238#endif
     39void     ngcDelete(number *a, ring r);
    4340
    4441nMapFunc  ngcSetMap(ring src, ring dst);
  • Singular/gnumpfl.cc

    r7f03cd r958e16  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: gnumpfl.cc,v 1.17 2000-12-15 18:49:29 Singular Exp $ */
     4/* $Id: gnumpfl.cc,v 1.18 2001-01-09 15:40:07 Singular Exp $ */
    55/*
    66* ABSTRACT: computations with GMP floating-point numbers
     
    9090* delete a
    9191*/
    92 #ifdef LDEBUG
    93 void ngfDBDelete (number * a,char *f, int l)
    94 #else
    95 void ngfDelete (number * a)
    96 #endif
     92void ngfDelete (number * a, ring r)
    9793{
    9894  if ( *a != NULL )
  • Singular/gnumpfl.h

    r7f03cd r958e16  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: gnumpfl.h,v 1.8 2000-12-20 10:54:24 pohl Exp $ */
     6/* $Id: gnumpfl.h,v 1.9 2001-01-09 15:40:07 Singular Exp $ */
    77/*
    88* ABSTRACT: computations with GMP floating-point numbers
     
    3232#ifdef LDEBUG
    3333BOOLEAN  ngfDBTest(number a, char *f, int l);
    34 void     ngfDBDelete(number *a, char *f, int l);
    35 #define  ngfDelete(A) nlDBDelete(A,__FILE__,__LINE__)
    36 #else
    37 void     ngfDelete(number *a);
    3834#endif
     35void     ngfDelete(number *a, ring r);
    3936
    4037nMapFunc  ngfSetMap(ring src, ring dst);
     
    4239void setGMPFloatDigits( size_t digits, size_t rest );
    4340#endif
    44 
    45 
    46 // local Variables: ***
    47 // folded-file: t ***
    48 // compile-command: "make installg" ***
    49 // End: ***
  • Singular/iparith.cc

    r7f03cd r958e16  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: iparith.cc,v 1.246 2001-01-09 13:50:42 Singular Exp $ */
     4/* $Id: iparith.cc,v 1.247 2001-01-09 15:40:07 Singular Exp $ */
    55
    66/*
     
    17461746static BOOLEAN jjGCD_N(leftv res, leftv u, leftv v)
    17471747{
    1748   res->data=(char *)nGcd((number) u->Data(), (number) v->Data());
     1748  res->data=(char *)nGcd((number) u->Data(), (number) v->Data(), currRing);
    17491749  return FALSE;
    17501750}
  • Singular/kspoly.cc

    r7f03cd r958e16  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kspoly.cc,v 1.23 2000-12-14 16:38:50 obachman Exp $ */
     4/* $Id: kspoly.cc,v 1.24 2001-01-09 15:40:09 Singular Exp $ */
    55/*
    66*  ABSTRACT -  Routines for Spoly creation and reductions
     
    275275  nTest(bn);
    276276
    277   number cn = nGcd(an, bn);
     277  number cn = nGcd(an, bn, currRing);
    278278
    279279  if(nIsOne(cn))
  • Singular/longalg.cc

    r7f03cd r958e16  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: longalg.cc,v 1.53 2000-12-31 15:14:35 obachman Exp $ */
     4/* $Id: longalg.cc,v 1.54 2001-01-09 15:40:09 Singular Exp $ */
    55/*
    66* ABSTRACT:   algebraic numbers
     
    5050/* procedure variables */
    5151static numberfunc
    52                 nacMult, nacSub, nacAdd, nacDiv, nacIntDiv, nacGcd, nacLcm;
    53 #ifdef LDEBUG
    54 static void     (*nacDBDelete)(number *a,char *f,int l);
    55 #define         nacDelete(A) nacDBDelete(A,__FILE__,__LINE__)
    56 #else
    57 static void     (*nacDelete)(number *a);
    58 #endif
     52                nacMult, nacSub, nacAdd, nacDiv, nacIntDiv;
     53static number   (*nacGcd)(number a, number b, ring r);
     54static number   (*nacLcm)(number a, number b, ring r);
     55static void     (*nacDelete)(number *a, ring r);
    5956       number   (*nacInit)(int i);
    6057static int      (*nacInt)(number &n);
     
    7572static int napExpi(int i, alg a, alg b);
    7673
    77 static number nadGcd( number a, number b) { return nacInit(1); }
     74static number nadGcd( number a, number b, ring r) { return nacInit(1); }
    7875/*2
    7976*  sets the appropriate operators
     
    9895  {
    9996    naIsChar0 = 1;
    100 #ifdef LDEBUG
    101     nacDBDelete      = nlDBDelete;
    102 #else
    10397    nacDelete      = nlDelete;
    104 #endif
    10598    nacInit        = nlInit;
    10699    nacInt         = nlInt;
     
    126119  {
    127120    naIsChar0 = 0;
    128 #ifdef LDEBUG
    129     nacDBDelete    = nDBDummy1;
    130 #else
    131     nacDelete      = nDummy1;
    132 #endif
     121    nacDelete      = ndDelete;
    133122    npSetChar(-i, r->algring); // to be changes HS
    134123    nacInit        = npInit;
     
    162151/*============= procedure for polynomials: napXXXX =======================*/
    163152
    164 #define napSetCoeff(p,n) {nacDelete(&((p)->ko));(p)->ko=n;}
    165 #define napIter(A) A=(A)->ne
     153#define napSetCoeff(p,n) {nacDelete(&((p)->ko),currRing);(p)->ko=n;}
    166154
    167155
     
    221209  {
    222210    *p = h->ne;
    223     nacDelete(&(h->ko));
     211    nacDelete(&(h->ko),currRing);
    224212    omFreeSize((ADDRESS)h, napMonomSize);
    225213  }
     
    237225    w = h;
    238226    h = h->ne;
    239     nacDelete(&(w->ko));
     227    nacDelete(&(w->ko),currRing);
    240228    omFreeSize((ADDRESS)w, napMonomSize);
    241229  }
     
    364352      if (nacIsZero(t))
    365353      {
    366         nacDelete(&t);
     354        nacDelete(&t,currRing);
    367355        napDelete1(&a1);
    368356      }
    369357      else
    370358      {
    371         nacDelete(&(a1->ko));
     359        nacDelete(&(a1->ko),currRing);
    372360        a1->ko = t;
    373361        a = a->ne = a1;
     
    397385* multiply a alg. poly by -1
    398386*/
    399 static alg napNeg(alg a)
    400 {
    401   alg p = a;
     387napoly napNeg(napoly a)
     388{
     389  napoly p = a;
    402390
    403391  while (p!=NULL)
     
    422410    t = nacMult(p->ko, z);
    423411    nacNormalize(t);
    424     nacDelete(&p->ko);
     412    nacDelete(&p->ko,currRing);
    425413    p->ko = t;
    426414    p = p->ne;
     
    471459      {
    472460        t = nacMult(a->ko, h);
    473         nacDelete(&(a->ko));
     461        nacDelete(&(a->ko),currRing);
    474462        a->ko = t;
    475463        for (i = naNumbOfPar - 1; i >= 0; i--)
     
    571559    h = napCopy(g);
    572560    napMultT(h, qq);
    573     nacDelete(&(qq->ko));
     561    nacDelete(&(qq->ko),currRing);
    574562    a = napAdd(a, h);
    575563  }
     
    599587    h = napCopy(g);
    600588    napMultT(h, qq);
    601     nacDelete(&(qq->ko));
     589    nacDelete(&(qq->ko),currRing);
    602590    a = napAdd(a, h);
    603591  }
     
    628616      h = nacInit(1);
    629617      t = nacDiv(h, x->ko);
    630       nacDelete(&(x->ko));
    631       nacDelete(&h);
     618      nacDelete(&(x->ko),currRing);
     619      nacDelete(&h,currRing);
    632620      x->ko = t;
    633621    }
     
    646634    nacNormalize(t);
    647635    napMultN(qa, t);
    648     nacDelete(&h);
    649     nacDelete(&t);
     636    nacDelete(&h,currRing);
     637    nacDelete(&t,currRing);
    650638    napDelete(&x);
    651639    napDelete(&r);
     
    666654    t = nacDiv(h, r->ko);
    667655    napMultN(q, t);
    668     nacDelete(&h);
    669     nacDelete(&t);
     656    nacDelete(&h,currRing);
     657    nacDelete(&t,currRing);
    670658    napDelete(&x);
    671659    napDelete(&r);
     
    694682      t = nacDiv(h, r->ko);
    695683      napMultN(q, t);
    696       nacDelete(&h);
    697       nacDelete(&t);
     684      nacDelete(&h,currRing);
     685      nacDelete(&t,currRing);
    698686      napDelete(&x);
    699687      napDelete(&r);
     
    927915  do
    928916  {
    929     d=nacGcd(p->ko, h);
     917    d=nacGcd(p->ko, h, currRing);
    930918    if(nacIsOne(d))
    931919    {
    932       nacDelete(&h);
    933       nacDelete(&d);
     920      nacDelete(&h,currRing);
     921      nacDelete(&d,currRing);
    934922      return;
    935923    }
    936     nacDelete(&h);
     924    nacDelete(&h,currRing);
    937925    h = d;
    938926    p = p->ne;
     
    940928  while (p!=NULL);
    941929  h = nacInvers(d);
    942   nacDelete(&d);
     930  nacDelete(&d,currRing);
    943931  p = ph;
    944932  while (p!=NULL)
    945933  {
    946934    d = nacMult(p->ko, h);
    947     nacDelete(&(p->ko));
     935    nacDelete(&(p->ko),currRing);
    948936    p->ko = d;
    949937    p = p->ne;
    950938  }
    951   nacDelete(&h);
     939  nacDelete(&h,currRing);
    952940}
    953941
     
    963951  while (p!=NULL)
    964952  {
    965     d = nacLcm(h, p->ko);
    966     nacDelete(&h);
     953    d = nacLcm(h, p->ko, currRing);
     954    nacDelete(&h,currRing);
    967955    h = d;
    968956    p = p->ne;
     
    974962    {
    975963      d=nacMult(h, p->ko);
    976       nacDelete(&(p->ko));
     964      nacDelete(&(p->ko),currRing);
    977965      p->ko = d;
    978966      p = p->ne;
    979967    }
    980     nacDelete(&h);
     968    nacDelete(&h,currRing);
    981969  }
    982970  napContent(ph);
     
    994982  {
    995983    a = a->ne;
    996     y = nacGcd(x, a->ko);
    997     nacDelete(&x);
     984    y = nacGcd(x, a->ko, currRing);
     985    nacDelete(&x,currRing);
    998986    x = y;
    999987    if (nacIsOne(x))
     
    1002990  do
    1003991  {
    1004     y = nacGcd(x, b->ko);
    1005     nacDelete(&x);
     992    y = nacGcd(x, b->ko, currRing);
     993    nacDelete(&x,currRing);
    1006994    x = y;
    1007995    if (nacIsOne(x))
     
    11021090    while (b!=NULL)
    11031091    {
    1104       d = nacLcm(h, b->ko);
    1105       nacDelete(&h);
     1092      d = nacLcm(h, b->ko, currRing);
     1093      nacDelete(&h,currRing);
    11061094      h = d;
    11071095      b = b->ne;
     
    12751263*  deletes p
    12761264*/
    1277 #ifdef LDEBUG
    1278 void naDBDelete(number *p,char *f, int lno)
    1279 #else
    1280 void naDelete(number *p)
    1281 #endif
     1265void naDelete(number *p, ring r)
    12821266{
    12831267  lnumber l = (lnumber) * p;
     
    16901674  number h = naSub(a, b);
    16911675  BOOLEAN bo = naIsZero(h);
    1692   naDelete(&h);
     1676  naDelete(&h,currRing);
    16931677  return bo;
    16941678}
     
    18311815      if (!nacIsZero(t))
    18321816      {
    1833         nacDelete(&t);
     1817        nacDelete(&t,currRing);
    18341818        return FALSE;
    18351819      }
    18361820      else
    1837         nacDelete(&t);
     1821        nacDelete(&t,currRing);
    18381822    }
    18391823    x = x->ne;
     
    18851869  {
    18861870    x = naMult(*rc, p);
    1887     naDelete(rc);
     1871    naDelete(rc,currRing);
    18881872    *rc = x;
    18891873  }
     
    18931877* result =gcd(a,b)
    18941878*/
    1895 number naGcd(number a, number b)
     1879number naGcd(number a, number b, ring r)
    18961880{
    18971881  lnumber x, y;
     
    19851969    napMultN(x,n);
    19861970    napMultN(y,n);
    1987     nacDelete(&n);
     1971    nacDelete(&n,currRing);
    19881972    while(x!=NULL)
    19891973    {
     
    20362020    nacNormalize(h1);
    20372021    napMultN(x, h1);
    2038     nacDelete(&h1);
     2022    nacDelete(&h1,currRing);
    20392023    napDelete1(&y);
    20402024    p->n = NULL;
     
    20832067      napMultN(x,n);
    20842068      napMultN(y,n);
    2085       nacDelete(&n);
     2069      nacDelete(&n,currRing);
    20862070      while(x!=NULL)
    20872071      {
     
    21402124  while (x!=NULL)
    21412125  {
    2142     number d=nacGcd(g,napGetCoeff(x));
     2126    number d=nacGcd(g,napGetCoeff(x), currRing);
    21432127    if(nacIsOne(d))
    21442128    {
    2145       nacDelete(&g);
    2146       nacDelete(&d);
     2129      nacDelete(&g,currRing);
     2130      nacDelete(&d,currRing);
    21472131      naTest(pp);
    21482132      return;
    21492133    }
    2150     nacDelete(&g);
     2134    nacDelete(&g,currRing);
    21512135    g = d;
    21522136    napIter(x);
     
    21542138  while (y!=NULL)
    21552139  {
    2156     number d=nacGcd(g,napGetCoeff(y));
     2140    number d=nacGcd(g,napGetCoeff(y), currRing);
    21572141    if(nacIsOne(d))
    21582142    {
    2159       nacDelete(&g);
    2160       nacDelete(&d);
     2143      nacDelete(&g,currRing);
     2144      nacDelete(&d,currRing);
    21612145      naTest(pp);
    21622146      return;
    21632147    }
    2164     nacDelete(&g);
     2148    nacDelete(&g,currRing);
    21652149    g = d;
    21662150    napIter(y);
     
    21802164    napIter(y);
    21812165  }
    2182   nacDelete(&g);
     2166  nacDelete(&g,currRing);
    21832167  naTest(pp);
    21842168}
     
    21882172* and in     result->z the lcm(a->z,b->n)
    21892173*/
    2190 number naLcm(number la, number lb)
     2174number naLcm(number la, number lb, ring r)
    21912175{
    21922176  lnumber result;
     
    22102194    while (xx!=NULL)
    22112195    {
    2212       bt = nacGcd(t, xx->ko);
     2196      bt = nacGcd(t, xx->ko, currRing);
    22132197      r = nacMult(t, xx->ko);
    2214       nacDelete(&(xx->ko));
     2198      nacDelete(&(xx->ko),currRing);
    22152199      xx->ko = nacDiv(r, bt);
    22162200      nacNormalize(xx->ko);
    2217       nacDelete(&bt);
    2218       nacDelete(&r);
     2201      nacDelete(&bt,currRing);
     2202      nacDelete(&r,currRing);
    22192203      xx=xx->ne;
    22202204    }
    22212205  }
    2222   nacDelete(&t);
     2206  nacDelete(&t,currRing);
    22232207  result->z = x;
    22242208#ifdef HAVE_FACTORY
     
    22712255        a=nacDiv(nacInit(1),a);
    22722256        napMultN(x,a);
    2273         nacDelete(&a);
     2257        nacDelete(&a,currRing);
    22742258      }
    22752259    }
     
    23972381      {
    23982382        number t_erg=(number)erg;
    2399         naDelete(&t_erg);
     2383        naDelete(&t_erg,currRing);
    24002384        return (number)NULL;
    24012385      }
     
    25702554BOOLEAN naDBTest(number a, char *f,int l)
    25712555{
    2572 #if 0
    25732556  lnumber x=(lnumber)a;
    25742557  if (x == NULL)
     
    26132596    p = p->ne;
    26142597  }
     2598  return TRUE;
     2599}
    26152600#endif
    2616   return TRUE;
    2617 }
    2618 #endif
    2619 
     2601
  • Singular/longalg.h

    r7f03cd r958e16  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: longalg.h,v 1.24 2000-12-15 18:49:32 Singular Exp $ */
     6/* $Id: longalg.h,v 1.25 2001-01-09 15:40:10 Singular Exp $ */
    77/*
    88* ABSTRACT:   algebraic numbers
     
    4141#define napAddExp(P,I,E)  ((P)->e[I-1]+=(E))
    4242#define napLength(p)      (pLength((poly)p))
    43 #ifdef LDEBUG
    44 void    naDBDelete (number *p,char *f, int l);
    45 #define naDelete(A) naDBDelete(A,__FILE__,__LINE__)
    46 #else
    47 void    naDelete (number *p);
    48 #endif
     43napoly napNeg(napoly a);
     44void    naDelete (number *p, ring r);
    4945number  naInit(int i);                              /* z := i */
    5046number  naPar(int i);                               /* z := par(i) */
     
    7268number  naSub(number la, number li);               /* lu := la-li */
    7369void    naNormalize(number &p);
    74 number  naGcd(number a, number b);
    75 number  naLcm(number a, number b);
     70number  naGcd(number a, number b, ring r);
     71number  naLcm(number a, number b, ring r);
    7672char *  naRead(char * s, number * p);
    7773void    naWrite(number &p);
  • Singular/longrat.cc

    r7f03cd r958e16  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: longrat.cc,v 1.35 2000-12-21 13:22:00 pohl Exp $ */
     4/* $Id: longrat.cc,v 1.36 2001-01-09 15:40:10 Singular Exp $ */
    55/*
    66* ABSTRACT: computation with long rational numbers (Hubert Grassmann)
     
    11131113  r=nlSub(a,b);
    11141114  rr=(!nlIsZero(r)) && (nlGreaterZero(r));
    1115   nlDelete(&r);
     1115  nlDelete(&r,currRing);
    11161116  return rr;
    11171117}
     
    11331133* result =gcd(a,b)
    11341134*/
    1135 number nlGcd(number a, number b)
     1135number nlGcd(number a, number b, ring r)
    11361136{
    11371137  number result;
     
    12191219    if (mpz_cmp_ui(&x->z,(long)0)==0)
    12201220    {
    1221       nlDelete(&x);
     1221      nlDelete(&x,currRing);
    12221222      x=nlInit(0);
    12231223      return;
     
    12921292* returns in result->z the lcm(a->z,b->n)
    12931293*/
    1294 number nlLcm(number a, number b)
     1294number nlLcm(number a, number b, ring r)
    12951295{
    12961296  number result;
     
    15041504}
    15051505
    1506 void _nlDelete_NoImm(number *a)
     1506void _nlDelete_NoImm(number *a, ring r)
    15071507{
    15081508  switch ((*a)->s)
     
    21902190BOOLEAN _nlEqual_aNoImm_OR_bNoImm(number a, number b);
    21912191number  _nlCopy_NoImm(number a);
    2192 void    _nlDelete_NoImm(number *a);
     2192void    _nlDelete_NoImm(number *a, ring r);
    21932193number  _nlNeg_NoImm(number a);
    21942194number  _nlAdd_aNoImm_OR_bNoImm(number a, number b);
     
    22752275* delete a
    22762276*/
    2277 #ifdef LDEBUG
    2278 void nlDBDelete (number * a,char *f, int l)
    2279 #else
    2280 LINLINE void nlDelete (number * a)
    2281 #endif
     2277LINLINE void nlDelete (number * a, ring r)
    22822278{
    22832279  if (*a!=NULL)
     
    22872283#endif
    22882284    if ((SR_HDL(*a) & SR_INT)==0)
    2289       _nlDelete_NoImm(a);
     2285      _nlDelete_NoImm(a,r);
    22902286    *a=NULL;
    22912287  }
  • Singular/longrat.h

    r7f03cd r958e16  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: longrat.h,v 1.19 2000-12-15 18:49:33 Singular Exp $ */
     6/* $Id: longrat.h,v 1.20 2001-01-09 15:40:11 Singular Exp $ */
    77/*
    88* ABSTRACT: computation with long rational numbers
     
    6868LINLINE void     nlNew(number *r);
    6969#ifndef LDEBUG
    70 LINLINE void     nlDelete(number *a);
     70LINLINE void     nlDelete(number *a, ring r);
    7171#endif
    7272LINLINE number   nlNeg(number za);
     
    7575LINLINE number   nlMult(number a, number b);
    7676
    77 number   nlGcd(number a, number b);
    78 number   nlLcm(number a, number b);   /*special routine !*/
     77number   nlGcd(number a, number b, ring r);
     78number   nlLcm(number a, number b, ring r);   /*special routine !*/
    7979BOOLEAN  nlGreater(number a, number b);
    8080BOOLEAN  nlIsMOne(number a);
     
    9696#ifdef LDEBUG
    9797BOOLEAN  nlDBTest(number a, char *f, int l);
    98 void     nlDBDelete(number *a, char *f, int l);
    99 #define  nlDelete(A) nlDBDelete(A,__FILE__,__LINE__)
    10098#endif
    10199
  • Singular/modulop.h

    r7f03cd r958e16  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: modulop.h,v 1.14 2000-12-18 15:44:41 obachman Exp $ */
     6/* $Id: modulop.h,v 1.15 2001-01-09 15:40:11 Singular Exp $ */
    77/*
    88* ABSTRACT: numbers modulo p (<=32003)
     
    1111
    1212// define if a*b is with mod instead of tables
    13 #if defined(i386)
    14 // seems to be better on i386 processors
    1513#define HAVE_MULT_MOD
    16 #endif
    1714
    1815extern int npPrimeM;
  • Singular/numbers.cc

    r7f03cd r958e16  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: numbers.cc,v 1.36 2000-12-20 11:15:46 obachman Exp $ */
     4/* $Id: numbers.cc,v 1.37 2001-01-09 15:40:12 Singular Exp $ */
    55
    66/*
     
    5050void    (*nPower)(number a, int i, number * result);
    5151number  (*nGetDenom)(number &n);
    52 numberfunc nGcd,nLcm;
     52number  (*nGcd)(number a, number b, ring r);
     53number  (*nLcm)(number a, number b, ring r);
    5354char * (*nName)(number n);
    54 #ifdef LDEBUG
    55 BOOLEAN (*nDBTest)(number a, char *f, int l);
    56 void (*nDBDelete)(number *a, char *f, int l);
    57 #else
    58 void   (*nDelete)(number *a);
    59 #endif
     55void   (*n__Delete)(number *a, ring r);
    6056
    6157/*0 implementation*/
     
    6763
    6864void   nDummy1(number* d) { *d=NULL; }
     65void   ndDelete(number* d, ring r) { *d=NULL; }
    6966
    7067#ifdef LDEBUG
     
    8279int    ndParDeg(number n) { return 0; }
    8380
    84 number ndGcd(number a, number b) { return nInit(1); }
     81number ndGcd(number a, number b, ring r) { return r->cf->nInit(1); }
    8582
    8683number ndIntMod(number a, number b) { return nInit(0); }
     
    103100
    104101  nChar=c;
    105 #ifdef LDEBUG
    106   nDBDelete= r->cf->nDBDelete;
    107 #else
    108   nDelete= r->cf->nDelete;
    109 #endif
     102  n__Delete= r->cf->cfDelete;
    110103  if (rField_is_Extension(r))
    111104  {
    112105    naSetChar(c,r);
     106#ifdef LONGALGNEW
     107    test |= Sy_bit(OPT_INTSTRATEGY); /*intStrategy*/
     108    test &= ~Sy_bit(OPT_REDTAIL); /*noredTail*/
     109  }
     110  else if (rField_is_Q(r))
     111  {
     112    test |= Sy_bit(OPT_INTSTRATEGY); /*26*/
     113#endif /* LONGALGNEW */
    113114  }
    114115  else if (rField_is_Zp(r))
     
    116117  {
    117118    npSetChar(c, r);
     119#ifdef LONGALGNEW
     120    test &= ~Sy_bit(OPT_INTSTRATEGY); /*26*/
     121#endif /* LONGALGNEW */
    118122  }
    119123  /* -------------- GF(p^m) -----------------------*/
    120124  else if (rField_is_GF(r))
    121125  {
     126#ifdef LONGALGNEW
     127    test &= ~Sy_bit(OPT_INTSTRATEGY); /*26*/
     128#endif /* LONGALGNEW */
    122129    nfSetChar(c,r->parameter);
     130  }
     131  /* -------------- R -----------------------*/
     132  //if (c==(-1))
     133  else if (rField_is_R(r))
     134  {
    123135  }
    124136  /* -------------- long R -----------------------*/
     
    172184  nRePart = r->cf->nRePart;
    173185  nImPart = r->cf->nImPart;
    174 #ifdef LDEBUG
    175   nDBTest=r->cf->nDBTest;
    176 #endif
    177186  if (!errorreported) nNULL=r->cf->nNULL;
    178187}
     
    193202      if (c==1) ch=0;
    194203      r->algring=(ring) rDefault(ch,r->P,r->parameter);
     204      //r->algring->ShortOut=r->ShortOut;
    195205      // includes: nInitChar(r->algring);
    196206    }
     
    228238  r->cf->nName =  ndName;
    229239  r->cf->nImPart=ndReturn0;
     240  r->cf->cfDelete= ndDelete;
     241  r->cf->nNew=nDummy1;
    230242  if (rField_is_Extension(r))
    231243  {
    232244    //naInitChar(c,TRUE,r);
    233 #ifdef LDEBUG
    234     r->cf->nDBDelete = naDBDelete;
    235 #else
    236     r->cf->nDelete = naDelete;
    237 #endif
     245    r->cf->cfDelete = naDelete;
    238246    r->cf-> nNew       = naNew;
    239247    r->cf-> nNormalize = naNormalize;
     
    268276    r->cf->nGetDenom   = naGetDenom;
    269277#ifdef LDEBUG
    270     r->cf->nDBTest     = naDBTest;
     278    //r->cf->nDBTest     = naDBTest;
    271279#endif
    272280  }
    273281  else if (rField_is_Q(r))
    274282  {
    275 #ifdef LDEBUG
    276     r->cf->nDBDelete= nlDBDelete;
    277 #else
    278     r->cf->nDelete= nlDelete;
    279 #endif
     283    r->cf->cfDelete= nlDelete;
    280284    r->cf->nNew   = nlNew;
    281285    r->cf->nNormalize=nlNormalize;
     
    307311    r->cf->nGetDenom = nlGetDenom;
    308312#ifdef LDEBUG
    309     r->cf->nDBTest=nlDBTest;
     313    //r->cf->nDBTest=nlDBTest;
    310314#endif
    311315  }
     
    313317  /*----------------------char. p----------------*/
    314318  {
    315 #ifdef LDEBUG
    316     r->cf->nDBDelete= nDBDummy1;
    317 #else
    318     r->cf->nDelete= nDummy1;
    319 #endif
    320319    npInitChar(c,r);
    321     r->cf->nNew   = nDummy1;
    322320    r->cf->nNormalize=nDummy2;
    323321    r->cf->nInit  = npInit;
     
    348346    /*nSize  = ndSize;*/
    349347#ifdef LDEBUG
    350     r->cf->nDBTest=npDBTest;
     348    //r->cf->nDBTest=npDBTest;
    351349#endif
    352350  }
     
    354352  else if (rField_is_GF(r))
    355353  {
    356 #ifdef LDEBUG
    357     r->cf->nDBDelete= nDBDummy1;
    358 #else
    359     r->cf->nDelete= nDummy1;
    360 #endif
    361354    //nfSetChar(c,r->parameter);
    362     r->cf->nNew   = nDummy1;
    363355    r->cf->nNormalize=nDummy2;
    364356    r->cf->nInit  = nfInit;
     
    391383    /*nSize  = ndSize;*/
    392384#ifdef LDEBUG
    393     r->cf->nDBTest=nfDBTest;
     385    //r->cf->nDBTest=nfDBTest;
    394386#endif
    395387  }
     
    398390  else if (rField_is_R(r))
    399391  {
    400 #ifdef LDEBUG
    401     r->cf->nDBDelete= nDBDummy1;
    402 #else
    403     r->cf->nDelete= nDummy1;
    404 #endif
    405     r->cf->nNew=nDummy1;
    406392    r->cf->nNormalize=nDummy2;
    407393    r->cf->nInit  = nrInit;
     
    432418    /*nSize  = ndSize;*/
    433419#ifdef LDEBUG
    434     r->cf->nDBTest=nrDBTest;
     420    //r->cf->nDBTest=nrDBTest;
    435421#endif
    436422  }
     
    439425  {
    440426    //setGMPFloatDigits(r->ch_flags);
    441 #ifdef LDEBUG
    442     r->cf->nDBDelete= ngfDBDelete;
    443 #else
    444     r->cf->nDelete= ngfDelete;
    445 #endif
     427    r->cf->cfDelete= ngfDelete;
    446428    r->cf->nNew=ngfNew;
    447429    r->cf->nNormalize=nDummy2;
     
    473455    r->cf->nSize  = ndSize;
    474456#ifdef LDEBUG
    475     r->cf->nDBTest=ngfDBTest;
     457    //r->cf->nDBTest=ngfDBTest;
    476458#endif
    477459  }
     
    480462  {
    481463    //setGMPFloatDigits(r->ch_flags);
    482 #ifdef LDEBUG
    483     r->cf->nDBDelete= ngcDBDelete;
    484 #else
    485     r->cf->nDelete= ngcDelete;
    486 #endif
     464    r->cf->cfDelete= ngcDelete;
    487465    r->cf->nNew=ngcNew;
    488466    r->cf->nNormalize=nDummy2;
     
    516494    /*nSize  = ndSize;*/
    517495#ifdef LDEBUG
    518     r->cf->nDBTest=ngcDBTest;
     496    //r->cf->nDBTest=ngcDBTest;
    519497#endif
    520498  }
     
    548526        n->next=n->next->next;
    549527        cf_root=tmp.next;
    550         r->cf->nDelete(&(r->cf->nNULL));
     528        r->cf->cfDelete(&(r->cf->nNULL),r);
    551529        switch(r->cf->type)
    552530        {
    553531          case n_Zp:
     532               #ifdef HAVE_DIV_MOD
     533               omFreeSize( (ADDRESS)r->cf->npInvTable,
     534                           r->cf->npPrimeM*sizeof(CARDINAL) );
     535               #else
    554536               omFreeSize( (ADDRESS)r->cf->npExpTable,
    555537                           r->cf->npPrimeM*sizeof(CARDINAL) );
    556538               omFreeSize( (ADDRESS)r->cf->npLogTable,
    557539                           r->cf->npPrimeM*sizeof(CARDINAL) );
     540               #endif
    558541               break;
    559542
  • Singular/numbers.h

    r7f03cd r958e16  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: numbers.h,v 1.23 2000-12-15 18:49:35 Singular Exp $ */
     6/* $Id: numbers.h,v 1.24 2001-01-09 15:40:12 Singular Exp $ */
    77/*
    88* ABSTRACT: interface to coefficient aritmetics
     
    1111
    1212#define n_Copy(n, r)          (r)->cf->nCopy(n)
    13 #define n_Delete(n, r)        (r)->cf->nDelete(n)
     13#define n_Delete(n, r)        (r)->cf->cfDelete(n,r)
    1414#define n_Mult(n1, n2, r)     (r)->cf->nMult(n1, n2)
    1515#define n_Add(n1, n2, r)      (r)->cf->nAdd(n1, n2)
     
    2525#define n_Write(n, r)         (r)->cf->nWrite(n)
    2626#define n_Normalize(n, r)     (r)->cf->nNormalize(n)
     27#define n_Gcd(a, b, r)        (r)->cf->nGcd(a,b,r)
     28#define n_IntDiv(a, b, r)     (r)->cf->nIntDiv(a,b)
    2729
    2830/* variables */
     
    5355extern void    (*nPower)(number a, int i, number * result);
    5456extern number  (*nGetDenom)(number &n);
    55 extern numberfunc nGcd, nLcm;
     57extern number (*nGcd)(number a, number b, ring r);
     58extern number (*nLcm)(number a, number b, ring r);
    5659
    5760extern number nNULL; /* the 0 as constant */
    5861
    59 #ifdef LDEBUG
    60 extern BOOLEAN (*nDBTest)(number a, char *f, int l);
    61 #define nTest(a) nDBTest(a,__FILE__,__LINE__)
    62 extern void    (*nDBDelete)(number * a,char *f, int l);
    63 #define nDelete(A) nDBDelete(A,__FILE__,__LINE__)
    64 #else
     62extern void    (*n__Delete)(number * a, ring r);
    6563#define nTest(a) (1)
    66 extern void    (*nDelete)(number * a);
    67 #endif
     64#define nDelete(A) (currRing)->cf->cfDelete(A,currRing)
    6865
    6966#define nSetMap(R) (currRing->cf->nSetMap(R,currRing))
     
    7168
    7269void nDummy1(number* d);
     70void ndDelete(number* d, ring r);
    7371void nDummy2(number &d);
    7472number ndGcd(number a, number b);
  • Singular/p_Numbers.h

    r7f03cd r958e16  
    77 *  Author:  obachman (Olaf Bachmann)
    88 *  Created: 8/00
    9  *  Version: $Id: p_Numbers.h,v 1.5 2000-12-01 12:57:04 Singular Exp $
     9 *  Version: $Id: p_Numbers.h,v 1.6 2001-01-09 15:40:12 Singular Exp $
    1010 *******************************************************************/
    1111#ifndef P_NUMBERS_H
     
    1414#include "numbers.h"
    1515#define n_Copy_FieldGeneral(n, r)           (r)->cf->nCopy(n)
    16 #define n_Delete_FieldGeneral(n, r)         (r)->cf->nDelete(n)
     16#define n_Delete_FieldGeneral(n, r)         (r)->cf->cfDelete(n,r)
    1717#define n_Mult_FieldGeneral(n1, n2, r)      (r)->cf->nMult(n1, n2)
    1818#define n_Add_FieldGeneral(n1, n2, r)       (r)->cf->nAdd(n1, n2)
     
    3535#include "longrat.cc"
    3636#define n_Copy_FieldQ(n, r)        nlCopy(n)
    37 #define n_Delete_FieldQ(n, r)      nlDelete(n)
     37#define n_Delete_FieldQ(n, r)      nlDelete(n,r)
    3838#define n_Mult_FieldQ(n1, n2, r)   nlMult(n1,n2)
    3939#define n_Add_FieldQ(n1, n2, r)    nlAdd(n1, n2)
  • Singular/p_polys.cc

    r7f03cd r958e16  
    77 *  Author:  obachman (Olaf Bachmann)
    88 *  Created: 8/00
    9  *  Version: $Id: p_polys.cc,v 1.14 2000-12-20 11:15:46 obachman Exp $
     9 *  Version: $Id: p_polys.cc,v 1.15 2001-01-09 15:40:12 Singular Exp $
    1010 *******************************************************************/
    1111
     
    826826  if (r->cf->nIsZero(n))
    827827  {
    828     r->cf->nDelete(&n);
     828    r->cf->cfDelete(&n, r);
    829829    return NULL;
    830830  }
  • Singular/polys1.cc

    r7f03cd r958e16  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: polys1.cc,v 1.61 2000-12-31 15:14:42 obachman Exp $ */
     4/* $Id: polys1.cc,v 1.62 2001-01-09 15:40:13 Singular Exp $ */
    55
    66/*
     
    1515#include "tok.h"
    1616#include "numbers.h"
     17#include "ffields.h"
    1718#include "omalloc.h"
    1819#include "febase.h"
     
    2829#endif
    2930
    30 
    31 /*-----------------------------------------------------------*/
     31/*-------- several access procedures to monomials -------------------- */
    3232/*
    3333* the module weights for std
     
    485485    {
    486486      nNormalize(pGetCoeff(p));
    487       d=nGcd(h,pGetCoeff(p));
     487      d=nGcd(h,pGetCoeff(p),currRing);
    488488      nDelete(&h);
    489489      h = d;
     
    589589//  }
    590590//}
     591void p_Content(poly ph, ring r)
     592{
     593  number h,d;
     594  poly p;
     595
     596  if(pNext(ph)==NULL)
     597  {
     598    pSetCoeff(ph,n_Init(1,r));
     599  }
     600  else
     601  {
     602    n_Normalize(pGetCoeff(ph),r);
     603    if(!n_GreaterZero(pGetCoeff(ph),r)) ph = p_Neg(ph,r);
     604    h=n_Copy(pGetCoeff(ph),r);
     605    p = pNext(ph);
     606    while (p!=NULL)
     607    {
     608      n_Normalize(pGetCoeff(p),r);
     609      d=n_Gcd(h,pGetCoeff(p),r);
     610      n_Delete(&h,r);
     611      h = d;
     612      if(n_IsOne(h,r))
     613      {
     614        break;
     615      }
     616      pIter(p);
     617    }
     618    p = ph;
     619    //number tmp;
     620    if(!n_IsOne(h,r))
     621    {
     622      while (p!=NULL)
     623      {
     624        //d = nDiv(pGetCoeff(p),h);
     625        //tmp = nIntDiv(pGetCoeff(p),h);
     626        //if (!nEqual(d,tmp))
     627        //{
     628        //  StringSetS("** div0:");nWrite(pGetCoeff(p));StringAppendS("/");
     629        //  nWrite(h);StringAppendS("=");nWrite(d);StringAppendS(" int:");
     630        //  nWrite(tmp);Print(StringAppendS("\n"));
     631        //}
     632        //nDelete(&tmp);
     633        d = n_IntDiv(pGetCoeff(p),h,r);
     634        p_SetCoeff(p,d,r);
     635        pIter(p);
     636      }
     637    }
     638    n_Delete(&h,r);
     639#ifdef HAVE_FACTORY
     640    //if ( (nGetChar() == 1) || (nGetChar() < 0) ) /* Q[a],Q(a),Zp[a],Z/p(a) */
     641    //{
     642    //  singclap_divide_content(ph);
     643    //  if(!nGreaterZero(pGetCoeff(ph))) ph = pNeg(ph);
     644    //}
     645#endif
     646  }
     647}
    591648
    592649void pCleardenom(poly ph)
     
    606663    {
    607664      nNormalize(pGetCoeff(p));
    608       d=nLcm(h,pGetCoeff(p));
     665      d=nLcm(h,pGetCoeff(p),currRing);
    609666      nDelete(&h);
    610667      h=d;
     
    642699          while (p!=NULL)
    643700          {
    644             d=nLcm(h,pGetCoeff(p));
     701            d=nLcm(h,pGetCoeff(p),currRing);
    645702            nDelete(&h);
    646703            h=d;
     
    704761}
    705762
     763// orders monoms of poly using merge sort (ususally faster than
     764// insertion sort). ASSUMES that pSetm was performed on monoms
     765poly pOrdPolyMerge(poly p)
     766{
     767  poly qq,pp,result=NULL;
     768
     769  if (p == NULL) return NULL;
     770
     771  loop
     772  {
     773    qq = p;
     774    loop
     775    {
     776      if (pNext(p) == NULL)
     777      {
     778        result=pAdd(result, qq);
     779        pTest(result);
     780        return result;
     781      }
     782      if (pLmCmp(p,pNext(p)) != 1)
     783      {
     784        pp = p;
     785        pIter(p);
     786        pNext(pp) = NULL;
     787        result = pAdd(result, qq);
     788        break;
     789      }
     790      pIter(p);
     791    }
     792  }
     793}
     794
     795// orders monoms of poly using insertion sort, performs pSetm on each monom
     796poly pOrdPolyInsertSetm(poly p)
     797{
     798  poly qq,result = NULL;
     799
     800#if 0
     801  while (p != NULL)
     802  {
     803    qq = p;
     804    pIter(p);
     805    qq->next = NULL;
     806    pSetm(qq);
     807    result = pAdd(result,qq);
     808    pTest(result);
     809  }
     810#else
     811  while (p != NULL)
     812  {
     813    qq = p;
     814    pIter(p);
     815    qq->next = result;
     816    result = qq;
     817    pSetm(qq);
     818  }
     819  p = result;
     820  result = NULL;
     821  while (p != NULL)
     822  {
     823    qq = p;
     824    pIter(p);
     825    qq->next = NULL;
     826    result = pAdd(result, qq);
     827  }
     828  pTest(result);
     829#endif
     830  return result;
     831}
    706832
    707833/*2
     
    719845  while (p != NULL)
    720846  {
    721     if (OldPar==0)
     847    if ((OldPar==0)||(rField_is_GF(oldRing)))
    722848    {
    723849      qq = pInit();
     
    771897          else if (perm[i]<0)
    772898          {
    773             lnumber c=(lnumber)pGetCoeff(qq);
    774             napAddExp(c->z,-perm[i],e/*p_GetExp( p,i,oldRing)*/);
    775             mapped_to_par=1;
     899            if (rField_is_GF())
     900            {
     901              number c=pGetCoeff(qq);
     902              number ee=nfPar(1);
     903              number eee;nfPower(ee,e,&eee); //nfDelete(ee,currRing);
     904              ee=nfMult(c,eee);
     905              //nfDelete(c,currRing);nfDelete(eee,currRing);
     906              pSetCoeff0(qq,ee);
     907            }
     908            else
     909            {
     910              lnumber c=(lnumber)pGetCoeff(qq);
     911              napAddExp(c->z,-perm[i],e/*p_GetExp( p,i,oldRing)*/);
     912              mapped_to_par=1;
     913            }
    776914          }
    777915          else
  • Singular/structs.h

    r7f03cd r958e16  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: structs.h,v 1.52 2000-12-31 15:14:45 obachman Exp $ */
     6/* $Id: structs.h,v 1.53 2001-01-09 15:40:13 Singular Exp $ */
    77/*
    88* ABSTRACT
     
    2222   but configure dislikes it */
    2323
     24
     25// define if a*b is with mod instead of tables
     26#if defined(i386)
     27// seems to be better on i386 processors
     28#define HAVE_MULT_MOD
     29#ifdef HAVE_MULT_MOD
     30/* #define HAVE_DIV_MOD*/
     31#endif
     32#endif
    2433
    2534typedef long Exponent_t;
     
    93102struct sip_package;
    94103struct s_si_link_extension;
     104#ifndef LONGALGNEW
    95105struct reca;
     106#endif /* not LONGALGNEW */
    96107
    97108typedef struct  n_Procs_s  n_Procs_s;
     
    129140typedef ip_command *       command;
    130141typedef struct s_si_link_extension *si_link_extension;
     142#ifndef LONGALGNEW
    131143typedef struct reca *      alg;
    132144#define napoly             alg
     145#else /* LONGALGNEW */
     146#define napoly             poly
     147#endif /* LONGALGNEW */
    133148
    134149#ifdef __cplusplus
     
    162177{
    163178  int anz;
     179#ifndef LONGALGNEW
    164180  alg *liste;
     181#else /* LONGALGNEW */
     182  poly *liste;
     183#endif /* LONGALGNEW */
    165184};
    166185typedef struct snaIdeal * naIdeal;
     
    201220   int npPrimeM;
    202221   int npPminus1M;
     222   #ifdef HAVE_DIV_MOD
     223   CARDINAL *npInvTable;
     224   #else
    203225   CARDINAL *npExpTable;
    204226   CARDINAL *npLogTable;
     227   #endif
    205228   // Zp_a, Q_a
    206229
     
    229252   void    (*nPower)(number a, int i, number * result);
    230253   number  (*nGetDenom)(number &n);
    231    numberfunc nGcd, nLcm;
     254   number  (*nGcd)(number a, number b, ring r);
     255   number  (*nLcm)(number a, number b, ring r);
     256   void    (*cfDelete)(number * a, ring r);
    232257   nMapFunc (*nSetMap)(ring src, ring dst);
    233 #ifdef LDEBUG
    234    BOOLEAN (*nDBTest)(number a, char *f, int l);
    235    void    (*nDBDelete)(number * a,char *f, int l);
    236 #else
    237    void    (*nDelete)(number * a);
    238 #endif
    239258   char *  (*nName)(number n);
    240259//extern number  (*nMap)(number from);
  • Singular/syz1.cc

    r7f03cd r958e16  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz1.cc,v 1.69 2000-12-06 11:03:31 Singular Exp $ */
     4/* $Id: syz1.cc,v 1.70 2001-01-09 15:40:14 Singular Exp $ */
    55/*
    66* ABSTRACT: resolutions
     
    900900    {
    901901      coefgcd =
    902         nGcd(pGetCoeff(tso.p1),pGetCoeff(tso.p2));
     902        nGcd(pGetCoeff(tso.p1),pGetCoeff(tso.p2),currRing);
    903903      tso.syz = pHead(tso.lcm);
    904904      p = tso.syz;
  • Singular/syz2.cc

    r7f03cd r958e16  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz2.cc,v 1.20 2000-12-06 11:03:32 Singular Exp $ */
     4/* $Id: syz2.cc,v 1.21 2001-01-09 15:40:15 Singular Exp $ */
    55/*
    66* ABSTRACT: resolutions
     
    232232          tso.length = -1;
    233233          number coefgcd =
    234             nGcd(pGetCoeff(tso.p1),pGetCoeff(tso.p2));
     234            nGcd(pGetCoeff(tso.p1),pGetCoeff(tso.p2),currRing);
    235235          tso.syz = pCopy((syzstr->resPairs[index])[i].syz);
    236236          poly tt = pDivide(tso.lcm,tso.p1);
  • Singular/syz3.cc

    r7f03cd r958e16  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz3.cc,v 1.6 2000-12-06 11:03:33 Singular Exp $ */
     4/* $Id: syz3.cc,v 1.7 2001-01-09 15:40:15 Singular Exp $ */
    55/*
    66* ABSTRACT: resolutions
     
    734734    {
    735735      tso.p = ksOldCreateSpoly(tso.p2,tso.p1);
    736       number coefgcd = nGcd(pGetCoeff(tso.p1),pGetCoeff(tso.p2));
     736      number coefgcd = nGcd(pGetCoeff(tso.p1),pGetCoeff(tso.p2),currRing);
    737737      assume (old_repr->m[tso.ind1]!=NULL);
    738738      tso.syz = pCopy(old_repr->m[tso.ind1]);
     
    12521252    {
    12531253      tso.p = ksOldCreateSpoly(tso.p2,tso.p1);
    1254       number coefgcd = nGcd(pGetCoeff(tso.p1),pGetCoeff(tso.p2));
     1254      number coefgcd = nGcd(pGetCoeff(tso.p1),pGetCoeff(tso.p2),currRing);
    12551255      assume (add_repr->m[tso.ind1]!=NULL);
    12561256      tso.syz = pCopy(add_repr->m[tso.ind1]);
  • Singular/tesths.cc

    r7f03cd r958e16  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: tesths.cc,v 1.83 2000-12-12 08:44:55 obachman Exp $ */
     4/* $Id: tesths.cc,v 1.84 2001-01-09 15:40:16 Singular Exp $ */
    55
    66/*
     
    226226  setjmp(si_start_jmpbuf);
    227227  yyparse();
    228 #endif
    229   //Print("at very end\n");
    230228  m2_end(0);
     229#endif
    231230  return 0;
    232231}
Note: See TracChangeset for help on using the changeset viewer.