Changeset 550b4c in git for Singular/longalg.cc


Ignore:
Timestamp:
Apr 21, 1998, 12:59:29 PM (26 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
559a4bf0a3b03fde23553e3ceb0d6c6ff9e2d4e3
Parents:
aaafeb24812a2fa1306280482a08f65373287b7e
Message:
* Exponents in parameter (polys) are typedef'ed to EXPONENT_TYPE


git-svn-id: file:///usr/local/Singular/svn/trunk@1408 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed

  • Singular/longalg.cc

    raaafeb r550b4c  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: longalg.cc,v 1.20 1998-03-27 15:43:28 obachman Exp $ */
     4/* $Id: longalg.cc,v 1.21 1998-04-21 10:59:24 obachman Exp $ */
    55/*
    66* ABSTRACT:   algebraic numbers
    … …  
    4040alg naMinimalPoly;
    4141int naNumbOfPar;
     42int napMonomSize;
    4243char **naParNames;
    4344static int naIsChar0;
    … …  
    9899  naParNames=param;
    99100  naNumbOfPar=pars;
     101  napMonomSize = RECA_SIZE + naNumbOfPar*SIZEOF_PARAMETER;
    100102  if (i == 1)
    101103  {
    … …  
    180182static alg napInit(int i)
    181183{
    182   alg a = (alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int));
     184  alg a = (alg)Alloc0(napMonomSize);
    183185
    184186  a->ko = nacInit(i);
    … …  
    189191  else
    190192  {
    191     Free((ADDRESS)a, RECA_SIZE + naNumbOfPar * sizeof(int));
     193    Free((ADDRESS)a, napMonomSize);
    192194    return NULL;
    193195  }
    … …  
    199201alg napInitz(number z)
    200202{
    201   alg a = (alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int));
     203  alg a = (alg)Alloc0(napMonomSize);
    202204
    203205  a->ko = z;
    … …  
    216218    *p = h->ne;
    217219    nacDelete(&(h->ko));
    218     Free((ADDRESS)h, RECA_SIZE + naNumbOfPar * sizeof(int));
     220    Free((ADDRESS)h, napMonomSize);
    219221  }
    220222}
    … …  
    232234    h = h->ne;
    233235    nacDelete(&(w->ko));
    234     Free((ADDRESS)w, RECA_SIZE + naNumbOfPar * sizeof(int));
     236    Free((ADDRESS)w, napMonomSize);
    235237  }
    236238  *p = NULL;
    … …  
    246248
    247249  alg w, a;
    248   int s=RECA_SIZE + naNumbOfPar * sizeof(int);
    249 
    250   mmTestP(p,RECA_SIZE+naNumbOfPar*sizeof(int));
    251   a = w = (alg)Alloc(s);
    252   memcpy(w->e, p->e, naNumbOfPar * sizeof(int));
     250
     251  mmTestP(p,napMonomSize);
     252  a = w = (alg)Alloc(napMonomSize);
     253  memcpy(w->e, p->e, naNumbOfPar * SIZEOF_PARAMETER);
    253254  w->ko = nacCopy(p->ko);
    254255  loop
    … …  
    256257    p=p->ne;
    257258    if (p==NULL) break;
    258     mmTestP(p,s);
    259     a->ne = (alg)Alloc(s);
     259    mmTestP(p,napMonomSize);
     260    a->ne = (alg)Alloc(napMonomSize);
    260261    a = a->ne;
    261     memcpy(a->e, p->e, naNumbOfPar * sizeof(int));
     262    memcpy(a->e, p->e, naNumbOfPar * SIZEOF_PARAMETER);
    262263    a->ko = nacCopy(p->ko);
    263264  }
    … …  
    274275
    275276  if (p==NULL) return NULL;
    276   mmTestP(p,RECA_SIZE+naNumbOfPar*sizeof(int));
    277   a = w = (alg)Alloc(RECA_SIZE + naNumbOfPar * sizeof(int));
    278   memcpy(w->e, p->e, naNumbOfPar * sizeof(int));
     277  mmTestP(p,napMonomSize);
     278  a = w = (alg)Alloc(napMonomSize);
     279  memcpy(w->e, p->e, naNumbOfPar * SIZEOF_PARAMETER);
    279280  w->ko = nacNeg(nacCopy(p->ko));
    280281  loop
    … …  
    282283    p=p->ne;
    283284    if (p==NULL) break;
    284     mmTestP(p,RECA_SIZE+naNumbOfPar*sizeof(int));
    285     a->ne = (alg)Alloc(RECA_SIZE + naNumbOfPar * sizeof(int));
     285    mmTestP(p,napMonomSize);
     286    a->ne = (alg)Alloc(napMonomSize);
    286287    a = a->ne;
    287     memcpy(a->e, p->e, naNumbOfPar * sizeof(int));
     288    memcpy(a->e, p->e, naNumbOfPar * SIZEOF_PARAMETER);
    288289    a->ko = nacNeg(nacCopy(p->ko));
    289290  }
    … …  
    299300  int  i = 0;
    300301
    301   mmTestP(p,RECA_SIZE+naNumbOfPar*sizeof(int));
    302   mmTestP(q,RECA_SIZE+naNumbOfPar*sizeof(int));
     302  mmTestP(p,napMonomSize);
     303  mmTestP(q,napMonomSize);
    303304  while (p->e[i] == q->e[i])
    304305  {
    … …  
    323324  if (p1==NULL) return p2;
    324325  if (p2==NULL) return p1;
    325   mmTestP(p1,RECA_SIZE+naNumbOfPar*sizeof(int));
    326   mmTestP(p2,RECA_SIZE+naNumbOfPar*sizeof(int));
     326  mmTestP(p1,napMonomSize);
     327  mmTestP(p2,napMonomSize);
    327328  a1 = p1;
    328329  a2 = p2;
    329   a = p  = (alg)Alloc(RECA_SIZE + naNumbOfPar * sizeof(int));
     330  a = p  = (alg)Alloc(napMonomSize);
    330331  loop
    331332  {
    … …  
    340341        break;
    341342      }
    342       mmTestP(a1,RECA_SIZE+naNumbOfPar*sizeof(int));
     343      mmTestP(a1,napMonomSize);
    343344    }
    344345    else if (c == -1)
    … …  
    351352        break;
    352353      }
    353       mmTestP(a2,RECA_SIZE+naNumbOfPar*sizeof(int));
     354      mmTestP(a2,napMonomSize);
    354355    }
    355356    else
    … …  
    379380        break;
    380381      }
    381       mmTestP(a1,RECA_SIZE+naNumbOfPar*sizeof(int));
    382       mmTestP(a2,RECA_SIZE+naNumbOfPar*sizeof(int));
     382      mmTestP(a1,napMonomSize);
     383      mmTestP(a2,napMonomSize);
    383384    }
    384385  }
    385386  a = p->ne;
    386   Free((ADDRESS)p, RECA_SIZE + naNumbOfPar * sizeof(int));
     387  Free((ADDRESS)p, napMonomSize);
    387388  return a;
    388389}
    … …  
    398399  while (p!=NULL)
    399400  {
    400     mmTestP(p,RECA_SIZE+naNumbOfPar*sizeof(int));
     401    mmTestP(p,napMonomSize);
    401402    p->ko = nacNeg(p->ko);
    402403    p = p->ne;
    … …  
    414415  while (p!=NULL)
    415416  {
    416     mmTestP(p,RECA_SIZE+naNumbOfPar*sizeof(int));
     417    mmTestP(p,napMonomSize);
    417418    t = nacMult(p->ko, z);
    418419    nacNormalize(t);
    … …  
    552553  alg a, h, qq;
    553554
    554   qq = (alg)Alloc(RECA_SIZE + naNumbOfPar * sizeof(int));
     555  qq = (alg)Alloc(napMonomSize);
    555556  qq->ne = NULL;
    556557  a = f;
    557558  do
    558559  {
    559     mmTestP(a,RECA_SIZE+naNumbOfPar*sizeof(int));
    560     mmTestP(g,RECA_SIZE+naNumbOfPar*sizeof(int));
     560    mmTestP(a,napMonomSize);
     561    mmTestP(g,napMonomSize);
    561562    qq->e[0] = a->e[0] - g->e[0];
    562563    qq->ko = nacDiv(a->ko, g->ko);
    … …  
    568569  }
    569570  while ((a!=NULL) && (a->e[0] >= g->e[0]));
    570   Free((ADDRESS)qq, RECA_SIZE + naNumbOfPar * sizeof(int));
     571  Free((ADDRESS)qq, napMonomSize);
    571572  return a;
    572573}
    … …  
    579580  alg a, h, b, qq;
    580581
    581   qq = (alg)Alloc(RECA_SIZE + naNumbOfPar * sizeof(int));
     582  qq = (alg)Alloc(napMonomSize);
    582583  qq->ne = b = NULL;
    583584  a = f;
    584585  do
    585586  {
    586     mmTestP(a,RECA_SIZE+naNumbOfPar*sizeof(int));
    587     mmTestP(g,RECA_SIZE+naNumbOfPar*sizeof(int));
     587    mmTestP(a,napMonomSize);
     588    mmTestP(g,napMonomSize);
    588589    qq->e[0] = a->e[0] - g->e[0];
    589590    qq->ko = nacDiv(a->ko, g->ko);
    … …  
    596597  }
    597598  while ((a!=NULL) && (a->e[0] >= g->e[0]));
    598   Free((ADDRESS)qq, RECA_SIZE + naNumbOfPar * sizeof(int));
     599  Free((ADDRESS)qq, napMonomSize);
    599600  *q = b;
    600601  *r = a;
    … …  
    694695  int  d = 0, i;
    695696
    696   mmTestP(p,RECA_SIZE+naNumbOfPar*sizeof(int));
     697  mmTestP(p,napMonomSize);
    697698  for (i = naNumbOfPar-1; i>=0; i--)
    698699    d += p->e[i];
    … …  
    713714    {
    714715      BOOLEAN wroteCoeff=FALSE;
    715       mmTestP(p,RECA_SIZE+naNumbOfPar*sizeof(int));
     716      mmTestP(p,napMonomSize);
    716717      if ((napDeg(p)==0)
    717718      || ((!nacIsOne(p->ko))
    … …  
    754755
    755756
    756 static char *napHandleMons(char *s, int i, int *ex)
     757static char *napHandleMons(char *s, int i, PARAMETER_TYPE *ex)
    757758{
    758759  int  j;
    … …  
    776777  alg a;
    777778  int  i;
    778   a = (alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int));
     779  a = (alg)Alloc0(napMonomSize);
    779780  if ((*s >= '0') && (*s <= '9'))
    780781  {
    … …  
    10041005    return g;
    10051006  }
    1006   x = (alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int));
     1007  x = (alg)Alloc0(napMonomSize);
    10071008  g=a;
    10081009  h=b;
    … …  
    10611062alg napRedp (alg q)
    10621063{
    1063   alg h = (alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int));
     1064  alg h = (alg)Alloc0(napMonomSize);
    10641065  int i=0,j;
    10651066
    … …  
    10681069    if (napDivPoly (naI->liste[i], q))
    10691070    {
    1070       mmTestP((ADDRESS)q,RECA_SIZE + naNumbOfPar * sizeof(int));
     1071      mmTestP((ADDRESS)q,napMonomSize);
    10711072      //StringSetS("");
    10721073      //napWrite(q);
    … …  
    13331334  alg x;
    13341335
    1335   naTest(la);
    1336   naTest(lb);
    1337   mmTestP(a,sizeof(rnumber));
    1338   mmTestP(b,sizeof(rnumber));
    1339   naTest(la);
    1340   naTest(lb);
    1341   alg tp=napCopy(a->z);
    1342   naTest(la);
    1343   naTest(lb);
    1344   napDelete(&tp);
    1345   naTest(la);
    1346   naTest(lb);
    1347   tp=napCopy(b->z);
    1348   naTest(la);
    1349   naTest(lb);
    1350   napDelete(&tp);
    1351   tp=napCopy(a->z);
    1352   naTest(la);
    1353   naTest(lb);
    1354   napDelete(&tp);
    1355   naTest(la);
    1356   naTest(lb);
    1357   tp=napCopy(b->z);
    1358   naTest(la);
    1359   naTest(lb);
    1360   napDelete(&tp);
    1361   naTest(la);
    1362   naTest(lb);
    13631336  lo = (lnumber)Alloc(sizeof(rnumber));
    13641337  lo->z = napMult(napCopy(a->z), napCopy(b->z));
    … …  
    21722145  lnumber l=(lnumber)Alloc(sizeof(rnumber));
    21732146  l->s=2;
    2174   l->z=(alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int));
     2147  l->z=(alg)Alloc0(napMonomSize);
    21752148  int i=(int)c;
    21762149  if (i>(naPrimeM>>2)) i-=naPrimeM;
    … …  
    21882161  lnumber l=(lnumber)Alloc(sizeof(rnumber));
    21892162  l->s=0;
    2190   l->z=(alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int));
     2163  l->z=(alg)Alloc0(napMonomSize);
    21912164  l->z->ko=nlCopy(c);
    21922165  l->n=NULL;
    … …  
    22022175  lnumber l=(lnumber)Alloc(sizeof(rnumber));
    22032176  l->s=2;
    2204   l->z=(alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int));
     2177  l->z=(alg)Alloc0(napMonomSize);
    22052178  l->z->ko=c; /* omit npCopy, because npCopy is a no-op */
    22062179  l->n=NULL;
    … …  
    22202193  lnumber l=(lnumber)Alloc(sizeof(rnumber));
    22212194  l->s=2;
    2222   l->z=(alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int));
     2195  l->z=(alg)Alloc0(napMonomSize);
    22232196  l->z->ko=n;
    22242197  l->n=NULL;
    … …  
    22362209  lnumber l=(lnumber)Alloc(sizeof(rnumber));
    22372210  l->s=2;
    2238   l->z=(alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int));
     2211  l->z=(alg)Alloc0(napMonomSize);
    22392212  l->z->ko=n;
    22402213  l->n=NULL;
    … …  
    22492222
    22502223  if (p==NULL) return NULL;
    2251   a = w = (alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int));
    2252   memcpy(a->e, p->e, naParsToCopy * sizeof(int));
     2224  a = w = (alg)Alloc0(napMonomSize);
     2225  memcpy(a->e, p->e, naParsToCopy * SIZEOF_PARAMETER);
    22532226  w->ko = nacMap(p->ko);
    22542227  loop
    … …  
    22562229    p=p->ne;
    22572230    if (p==NULL) break;
    2258     a->ne = (alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int));
     2231    a->ne = (alg)Alloc0(napMonomSize);
    22592232    a = a->ne;
    2260     memcpy(a->e, p->e, naParsToCopy * sizeof(int));
     2233    memcpy(a->e, p->e, naParsToCopy * SIZEOF_PARAMETER);
    22612234    a->ko = nacMap(p->ko);
    22622235  }
    … …  
    24762449      return FALSE;
    24772450#ifdef MDEBUG
    2478     mmDBTestBlock(p,RECA_SIZE+naNumbOfPar*sizeof(int),f,l);
     2451    mmDBTestBlock(p,napMonomSize,f,l);
    24792452#endif
    24802453    p = p->ne;
    … …  
    24862459      return FALSE;
    24872460#ifdef MDEBUG
    2488     if (!mmDBTestBlock(p,RECA_SIZE+naNumbOfPar*sizeof(int),f,l))
     2461    if (!mmDBTestBlock(p,napMonomSize,f,l))
    24892462      return FALSE;
    24902463#endif
Note: See TracChangeset for help on using the changeset viewer.