Changeset 550b4c in git


Ignore:
Timestamp:
Apr 21, 1998, 12:59:29 PM (26 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b52fc4b2495505785981d640dcf7eb3e456778ef')
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
Location:
Singular
Files:
5 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
  • Singular/longalg.h

    raaafeb r550b4c  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: longalg.h,v 1.5 1998-02-17 15:05:53 obachman Exp $ */
     6/* $Id: longalg.h,v 1.6 1998-04-21 10:59:26 obachman Exp $ */
    77/*
    88* ABSTRACT:   algebraic numbers
     
    1010#include "structs.h"
    1111#include "longrat.h"
     12#include "polys-impl.h"
    1213
    1314struct slnumber;
    1415typedef struct slnumber * lnumber;
     16
     17//make parameter type same as exponent type
     18#if 1
     19#define PARAMETER_TYPE EXPONENT_TYPE
     20#define SIZEOF_PARAMETER SIZEOF_EXPONENT
     21#else
     22#define PARAMETER_TYPE int
     23#define SIZEOF_PARAMETER SIZOF_EXPONENT
     24#endif
     25
    1526struct reca
    1627{
    1728  alg ne;
    1829  number ko;
    19   int e[1];
     30  PARAMETER_TYPE e[1];
    2031};
     32
    2133struct slnumber
    2234{
     
    2941extern alg naMinimalPoly;
    3042extern char **naParNames;
     43extern int napMonomSize;
    3144
    3245void naSetChar(int p, BOOLEAN complete, char ** param, int pars);
     
    8396#define napGetCoeff(p) (p->ko)
    8497#define napGetExp(p,i) (p->e[(i)-1])
    85 #define napNew() ((alg)Alloc0(RECA_SIZE + naNumbOfPar * sizeof(int)))
     98#define napNew() ((alg)Alloc0(napMonomSize))
    8699#define nanumber lnumber
    87100#define naGetNom(na)  (((nanumber)(na))->z)
  • Singular/mpsr.h

    raaafeb r550b4c  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mpsr.h,v 1.7 1997-08-08 12:59:25 obachman Exp $ */
     4/* $Id: mpsr.h,v 1.8 1998-04-21 10:59:27 obachman Exp $ */
    55/***************************************************************
    66 *
     
    110110}
    111111
     112extern MP_Sint32_t *gTa;
     113extern MP_Sint32_t gTa_Length;
     114
     115
     116inline void mpsr_InitTempArray(int length)
     117{
     118  if (gTa_Length < length)
     119    {
     120      Free(gTa, gTa_Length*sizeof(MP_Sint32_t));
     121      gTa = (MP_Sint32_t *) Alloc((length)*sizeof(MP_Sint32_t));
     122      gTa_Length = length;
     123    }
     124}
     125
    112126/***************************************************************
    113127 *
  • Singular/mpsr_GetPoly.cc

    raaafeb r550b4c  
    33****************************************/
    44
    5 /* $Id: mpsr_GetPoly.cc,v 1.15 1998-04-07 18:35:26 obachman Exp $ */
     5/* $Id: mpsr_GetPoly.cc,v 1.16 1998-04-21 10:59:28 obachman Exp $ */
    66
    77/***************************************************************
     
    6363static MP_Sint32_t gNalgvars = 0;
    6464static MP_Sint32_t gNvars = 0;
    65 static MP_Sint32_t *gTa = NULL;
    6665static ring        currGetRing = NULL;
    6766
     
    103102  currGetRing = r;
    104103  // first, we set the PutNumber function
    105   if (r->N != gNvars)
    106   {
    107     if (gTa != NULL)
    108       Free(gTa, (gNvars+1)*sizeof(MP_Sint32_t));
    109 
    110     gNvars = r->N;
    111     if (gNvars > 1)
    112       gTa = (MP_Sint32_t *) Alloc((gNvars+1)*sizeof(MP_Sint32_t));
    113     else
    114       gTa = NULL;
    115   }
     104  gNvars = r->N;
     105  mpsr_InitTempArray(gNvars + 1);
    116106
    117107  if ((r->ch) == 0)
     
    131121    // now we come to algebraic numbers
    132122    gNalgvars = rPar(r);
     123    mpsr_InitTempArray(gNalgvars);
    133124    GetCoeff = GetAlgNumber;
    134125    if ((r->ch) < 0)
     
    315306{
    316307  MP_Uint32_t j, nm;
    317   int *exp;
     308  int *exp, i;
    318309  alg a;
    319310
     
    329320
    330321  failr(GetAlgNumberNumber(link, &(a->ko)));
     322#if SIZEOF_INT == SIZEOF_PARAMETER
    331323  exp = &(a->e[0]);
    332324  mp_failr(IMP_GetSint32Vector(link, (MP_Sint32_t **) &exp, naNumbOfPar));
     325#else
     326  mp_failr(IMP_GetSint32Vector(link, (MP_Sint32_t **) &gTa, naNumbOfPar));
     327  for (i=0; i<naNumbOfPar; i++)
     328    a->e[i] = (PARAMETER_TYPE) gTa[i];
     329#endif 
    333330
    334331  for (j=1; j<nm; j++)
     
    337334    a = a->ne;
    338335    failr(GetAlgNumberNumber(link, &(a->ko)));
     336#if SIZEOF_INT == SIZEOF_PARAMETER
    339337    exp = &(a->e[0]);
    340338    mp_failr(IMP_GetSint32Vector(link, (MP_Sint32_t **) &exp, naNumbOfPar));
     339#else
     340  mp_failr(IMP_GetSint32Vector(link, (MP_Sint32_t **) &gTa, naNumbOfPar));
     341  for (i=0; i<naNumbOfPar; i++)
     342    a->e[i] = (PARAMETER_TYPE) gTa[i];
     343#endif 
    341344  }
    342345  a->ne = NULL;
  • Singular/mpsr_PutPoly.cc

    raaafeb r550b4c  
    33****************************************/
    44
    5 /* $Id: mpsr_PutPoly.cc,v 1.11 1998-04-16 16:10:22 obachman Exp $ */
     5/* $Id: mpsr_PutPoly.cc,v 1.12 1998-04-21 10:59:29 obachman Exp $ */
    66
    77/***************************************************************
     
    4949 ***************************************************************/
    5050
    51 mpsr_Status_t (*PutCoeff)(MP_Link_pt link, number x);
    52 mpsr_Status_t (*PutAlgAlgNumber)(MP_Link_pt link, number x);
    53 MP_Uint32_t gNalgvars = 0;
    54 MP_Sint32_t gNvars = 0;
     51static mpsr_Status_t (*PutCoeff)(MP_Link_pt link, number x);
     52static mpsr_Status_t (*PutAlgAlgNumber)(MP_Link_pt link, number x);
     53static MP_Uint32_t gNalgvars = 0;
     54static MP_Sint32_t gNvars = 0;
     55static ring        CurrPutRing = NULL;
     56
    5557MP_Sint32_t *gTa = NULL;
    56 ring        CurrPutRing = NULL;
    57 
     58MP_Sint32_t gTa_Length = 0;
    5859
    5960/***************************************************************
     
    7778static mpsr_Status_t PutDefRelsAnnot(MP_Link_pt link, ring r);
    7879
     80
    7981/***************************************************************
    8082 *
     
    8688  CurrPutRing = r;
    8789  // first, we set the PutNumber function
    88   if (r->N != gNvars)
    89   {
    90     if (gTa != NULL)
    91       Free(gTa, (gNvars+1)*sizeof(MP_Sint32_t));
    92 
    93     gNvars = r->N;
    94     if (gNvars > 1)
    95       gTa = (MP_Sint32_t *) Alloc((gNvars+1)*sizeof(MP_Sint32_t));
    96     else
    97       gTa = NULL;
    98   }
     90  gNvars = r->N;
     91  mpsr_InitTempArray(gNvars+1);
    9992
    10093  if ((r->ch) == 0)
     
    111104    // now we come to algebraic numbers
    112105    gNalgvars = rPar(r);
     106    mpsr_InitTempArray(gNalgvars);
    113107    PutCoeff = PutAlgNumber;
    114108    if ((r->ch) < 0)
     
    223217static mpsr_Status_t PutAlgPoly(MP_Link_pt link, alg a)
    224218{
    225   int i;
     219  unsigned int i;
    226220  int *exp;
    227221
     
    230224    {
    231225      failr(PutAlgAlgNumber(link, a->ko));
     226#if (SIZEOF_INT == SIZEOF_PARAMETER)
    232227      mp_failr(IMP_PutSint32Vector(link, (MP_Sint32_t *) a->e, gNalgvars));
     228#else
     229      for (i=0; i<gNalgvars; i++)
     230        gTa[i] = a->e[i];
     231      mp_failr(IMP_PutSint32Vector(link, gTa, gNalgvars));
     232#endif
    233233      a = a->ne;
    234234    }
Note: See TracChangeset for help on using the changeset viewer.