Changeset b7b08c in git for Singular/ring.cc


Ignore:
Timestamp:
Oct 14, 1999, 4:27:35 PM (25 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
548777d246af408b77296a71c16c980b2cef5b35
Parents:
e960943ba1dcfcb333014a2aee474750e8fafe10
Message:
* us short exponent vectors in divisbility tests
* AllocSizeOf
* garbage collection
* scanner/gmp: allow .0 and 1. input of reals


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

Legend:

Unmodified
Added
Removed

  • Singular/ring.cc

    re960943 rb7b08c  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ring.cc,v 1.69 1999-10-14 12:50:28 Singular Exp $ */
     4/* $Id: ring.cc,v 1.70 1999-10-14 14:27:28 obachman Exp $ */
    55
    66/*
    … …  
    1111#include <math.h>
    1212#include "mod2.h"
     13#include "structs.h"
    1314#include "mmemory.h"
    1415#include "tok.h"
    … …  
    113114      }
    114115
    115     /*------------ set spolys ------------------------------------------*/
     116      /*------------ Garbage Collection -----------------------------------*/
     117      mmGarbageCollectHeaps(2);
    116118    }
    117119  }
    … …  
    203205  /*r->P     = 0; Alloc0 in idhdl::set, ipid.cc*/
    204206  /*names*/
    205   r->names = (char **) Alloc(3 * sizeof(char *));
     207  r->names = (char **) Alloc(3 * sizeof(char_ptr));
    206208  r->names[0]  = mstrdup("x");
    207209  r->names[1]  = mstrdup("y");
    208210  r->names[2]  = mstrdup("z");
    209211  /*weights: entries for 3 blocks: NULL*/
    210   r->wvhdl = (int **)Alloc0(3 * sizeof(int *));
     212  r->wvhdl = (int **)Alloc0(3 * sizeof(int_ptr));
    211213  /*order: dp,C,0*/
    212   r->order = (int *) Alloc(3 * sizeof(int *));
    213   r->block0 = (int *)Alloc(3 * sizeof(int *));
    214   r->block1 = (int *)Alloc(3 * sizeof(int *));
     214  r->order = (int *) Alloc(3 * sizeof(int_ptr));
     215  r->block0 = (int *)Alloc(3 * sizeof(int_ptr));
     216  r->block1 = (int *)Alloc(3 * sizeof(int_ptr));
    215217  /* ringorder dp for the first block: var 1..3 */
    216218  r->order[0]  = ringorder_dp;
    … …  
    321323  R->block0=(int *)Alloc0(n*sizeof(int));
    322324  R->block1=(int *)Alloc0(n*sizeof(int));
    323   R->wvhdl=(int**)Alloc0(n*sizeof(int*));
     325  R->wvhdl=(int**)Alloc0(n*sizeof(int_ptr));
    324326
    325327  // init order, so that rBlocks works correctly
    … …  
    519521    if ((pn->next==NULL) && complex_flag)
    520522    {
    521       pn->next=(leftv)Alloc0(sizeof(sleftv));
     523      pn->next=(leftv)Alloc0SizeOf(sleftv);
    522524      pn->next->name=mstrdup("i");
    523525    }
    … …  
    572574  }
    573575  // allocated ring and set ch
    574   R = (ring) Alloc0(sizeof(sip_sring));
     576  R = (ring) Alloc0SizeOf(sip_sring);
    575577  R->ch = ch;
    576578  if (ch == -1)
    … …  
    589591      goto rInitError;
    590592    }
    591     R->parameter=(char**)Alloc0(R->P*sizeof(char *));
     593    R->parameter=(char**)Alloc0(R->P*sizeof(char_ptr));
    592594    if (rSleftvList2StringArray(pn, R->parameter))
    593595    {
    … …  
    612614  /* names and number of variables-------------------------------------*/
    613615  R->N = rv->listLength();
    614   R->names   = (char **)Alloc0(R->N * sizeof(char *));
     616  R->names   = (char **)Alloc0(R->N * sizeof(char_ptr));
    615617  if (rSleftvList2StringArray(rv, R->names))
    616618  {
    … …  
    643645
    644646  // try to enter the ring into the name list //
     647  // need to clean up sleftv here, before this ring can be set to
     648  // new currRing or currRing can be killed beacuse new ring has
     649  // same name
     650  if (pn != NULL) pn->CleanUp();
     651  if (rv != NULL) rv->CleanUp();
     652  if (ord != NULL) ord->CleanUp();
    645653  if ((tmp = enterid(s, myynest, RING_CMD, &IDROOT))==NULL)
    646654    goto rInitError;
    … …  
    648656  memcpy(IDRING(tmp),R,sizeof(*R));
    649657  // set current ring
    650   Free(R,  sizeof(ip_sring));
     658  FreeSizeOf(R,  ip_sring);
    651659  return tmp;
    652660
    … …  
    654662  rInitError:
    655663  if  (R != NULL) rDelete(R);
     664  if (pn != NULL) pn->CleanUp();
     665  if (rv != NULL) rv->CleanUp();
     666  if (ord != NULL) ord->CleanUp();
    656667  return NULL;
    657668}
    … …  
    691702  mmTestP(r->block0,nblocks*sizeof(int));
    692703  mmTestP(r->block1,nblocks*sizeof(int));
    693   mmTestP(r->wvhdl,nblocks*sizeof(int *));
    694   mmTestP(r->names,r->N*sizeof(char *));
     704  mmTestP(r->wvhdl,nblocks*sizeof(int_ptr));
     705  mmTestP(r->names,r->N*sizeof(char_ptr));
    695706
    696707  nblocks--;
    … …  
    835846      if (r->names[i] != NULL) FreeL((ADDRESS)r->names[i]);
    836847    }
    837     Free((ADDRESS)r->names,r->N*sizeof(char *));
     848    Free((ADDRESS)r->names,r->N*sizeof(char_ptr));
    838849  }
    839850
    … …  
    849860      j++;
    850861    }
    851     Free((ADDRESS)r->parameter,rPar(r)*sizeof(char *));
    852   }
    853   Free(r, sizeof(ip_sring));
     862    Free((ADDRESS)r->parameter,rPar(r)*sizeof(char_ptr));
     863  }
     864  FreeSizeOf(r, ip_sring);
    854865}
    855866
    … …  
    12781289        if (strcmp(r1->parameter[0],r2->parameter[0])==0) /* 1 char */
    12791290        {
    1280           tmpR.parameter=(char **)Alloc(sizeof(char *));
     1291          tmpR.parameter=(char **)AllocSizeOf(char_ptr);
    12811292          tmpR.parameter[0]=mstrdup(r1->parameter[0]);
    12821293          tmpR.P=1;
    … …  
    12991310              && naEqual(r1->minpoly,r2->minpoly))
    13001311          {
    1301             tmpR.parameter=(char **)Alloc(sizeof(char *));
     1312            tmpR.parameter=(char **)AllocSizeOf(char_ptr);
    13021313            tmpR.parameter[0]=mstrdup(r1->parameter[0]);
    13031314            tmpR.minpoly=naCopy(r1->minpoly);
    … …  
    13171328              && (rPar(r2)==1))
    13181329          {
    1319             tmpR.parameter=(char **)Alloc0(sizeof(char *));
     1330            tmpR.parameter=(char **)Alloc0SizeOf(char_ptr);
    13201331            tmpR.parameter[0]=mstrdup(r1->parameter[0]);
    13211332            tmpR.P=1;
    … …  
    13381349              && (rPar(r1)==1))
    13391350          {
    1340             tmpR.parameter=(char **)Alloc(sizeof(char *));
     1351            tmpR.parameter=(char **)AllocSizeOf(char_ptr);
    13411352            tmpR.parameter[0]=mstrdup(r1->parameter[0]);
    13421353            tmpR.P=1;
    … …  
    13541365        {
    13551366          int len=rPar(r1)+rPar(r2);
    1356           tmpR.parameter=(char **)Alloc(len*sizeof(char *));
     1367          tmpR.parameter=(char **)Alloc(len*sizeof(char_ptr));
    13571368          int i;
    13581369          for (i=0;i<rPar(r1);i++)
    … …  
    13761387          if (i!=len)
    13771388          {
    1378             ReAlloc(tmpR.parameter,len*sizeof(char *),i*sizeof(char *));
     1389            ReAlloc(tmpR.parameter,len*sizeof(char_ptr),i*sizeof(char_ptr));
    13791390          }
    13801391        }
    … …  
    13901401      {
    13911402        tmpR.ch=rInternalChar(r1);
    1392         tmpR.parameter=(char **)Alloc(rPar(r1)*sizeof(char *));
     1403        tmpR.parameter=(char **)Alloc(rPar(r1)*sizeof(char_ptr));
    13931404        tmpR.P=rPar(r1);
    1394         memcpy(tmpR.parameter,r1->parameter,rPar(r1)*sizeof(char *));
     1405        memcpy(tmpR.parameter,r1->parameter,rPar(r1)*sizeof(char_ptr));
    13951406        if (r1->minpoly!=NULL)
    13961407        {
    … …  
    14171428        tmpR.ch=rInternalChar(r2);
    14181429        tmpR.P=rPar(r2);
    1419         tmpR.parameter=(char **)Alloc(rPar(r2)*sizeof(char *));
    1420         memcpy(tmpR.parameter,r2->parameter,rPar(r2)*sizeof(char *));
     1430        tmpR.parameter=(char **)Alloc(rPar(r2)*sizeof(char_ptr));
     1431        memcpy(tmpR.parameter,r2->parameter,rPar(r2)*sizeof(char_ptr));
    14211432        if (r2->minpoly!=NULL)
    14221433        {
    … …  
    14311442        if (r2->parameter!=NULL)
    14321443        {
    1433           tmpR.parameter=(char **)Alloc(sizeof(char *));
     1444          tmpR.parameter=(char **)AllocSizeOf(char_ptr);
    14341445          tmpR.P=1;
    14351446          tmpR.parameter[0]=mstrdup(r2->parameter[0]);
    … …  
    14481459        tmpR.ch=rInternalChar(r1);
    14491460        tmpR.P=rPar(r1);
    1450         tmpR.parameter=(char **)Alloc0(rPar(r1)*sizeof(char *));
     1461        tmpR.parameter=(char **)Alloc0(rPar(r1)*sizeof(char_ptr));
    14511462        int i;
    14521463        for(i=0;i<rPar(r1);i++)
    … …  
    14771488        tmpR.ch=rInternalChar(r2);
    14781489        tmpR.P=rPar(r2);
    1479         tmpR.parameter=(char **)Alloc(rPar(r2)*sizeof(char *));
     1490        tmpR.parameter=(char **)Alloc(rPar(r2)*sizeof(char_ptr));
    14801491        int i;
    14811492        for(i=0;i<rPar(r2);i++)
    … …  
    15001511  int i,j,k;
    15011512  int l=r1->N+r2->N;
    1502   char **names=(char **)Alloc0(l*sizeof(char*));
     1513  char **names=(char **)Alloc0(l*sizeof(char_ptr));
    15031514  k=0;
    15041515
    … …  
    15901601    tmpR.block0=(int*)Alloc(3*sizeof(int));
    15911602    tmpR.block1=(int*)Alloc(3*sizeof(int));
    1592     tmpR.wvhdl=(int**)Alloc0(3*sizeof(int*));
     1603    tmpR.wvhdl=(int**)Alloc0(3*sizeof(int_ptr));
    15931604    tmpR.order[0]=ringorder_unspec;
    15941605    tmpR.order[1]=ringorder_C;
    … …  
    16231634    tmpR.block0=(int*)Alloc0(b*sizeof(int));
    16241635    tmpR.block1=(int*)Alloc0(b*sizeof(int));
    1625     tmpR.wvhdl=(int**)Alloc0(b*sizeof(int*));
     1636    tmpR.wvhdl=(int**)Alloc0(b*sizeof(int_ptr));
    16261637    /* weights not implemented yet ...*/
    16271638    if (rb!=NULL)
    … …  
    16871698    tmpR.block0=(int*)Alloc0(b*sizeof(int));
    16881699    tmpR.block1=(int*)Alloc0(b*sizeof(int));
    1689     tmpR.wvhdl=(int**)Alloc0(b*sizeof(int*));
     1700    tmpR.wvhdl=(int**)Alloc0(b*sizeof(int_ptr));
    16901701    /* weights not implemented yet ...*/
    16911702    for (i=0;i<b;i++)
    … …  
    17061717  {
    17071718    for(i=0;i<k;i++) FreeL((ADDRESS)tmpR.names[i]);
    1708     Free((ADDRESS)names,tmpR.N*sizeof(char *));
     1719    Free((ADDRESS)names,tmpR.N*sizeof(char_ptr));
    17091720    Werror("difficulties with variables: %d,%d -> %d",r1->N,r2->N,k);
    17101721    return -1;
    17111722  }
    1712   sum=(ring)Alloc(sizeof(ip_sring));
     1723  sum=(ring)AllocSizeOf(ip_sring);
    17131724  memcpy(sum,&tmpR,sizeof(ip_sring));
    17141725  rComplete(sum);
    … …  
    17271738  int i,j;
    17281739  int *pi;
    1729   ring res=(ring)Alloc(sizeof(ip_sring));
     1740  ring res=(ring)AllocSizeOf(ip_sring);
    17301741
    17311742  memcpy4(res,r,sizeof(ip_sring));
    … …  
    17351746    res->minpoly=nCopy(r->minpoly);
    17361747    int l=rPar(r);
    1737     res->parameter=(char **)Alloc(l*sizeof(char *));
     1748    res->parameter=(char **)Alloc(l*sizeof(char_ptr));
    17381749    int i;
    17391750    for(i=0;i<rPar(r);i++)
    … …  
    17421753    }
    17431754  }
    1744   res->names   = (char **)Alloc(r->N * sizeof(char *));
     1755  res->names   = (char **)Alloc(r->N * sizeof(char_ptr));
    17451756  i=1;
    17461757  pi=r->order;
    17471758  while ((*pi)!=0) { i++;pi++; }
    1748   res->wvhdl   = (int **)Alloc(i * sizeof(int *));
     1759  res->wvhdl   = (int **)Alloc(i * sizeof(int_ptr));
    17491760  res->order   = (int *) Alloc(i * sizeof(int));
    17501761  res->block0  = (int *) Alloc(i * sizeof(int));
    … …  
    19681979  mmTestP(r->block0,i*sizeof(int));
    19691980  mmTestP(r->block1,i*sizeof(int));
    1970   mmTestP(r->wvhdl,i*sizeof(int *));
     1981  mmTestP(r->wvhdl,i*sizeof(int_ptr));
    19711982#endif
    19721983  if (r->VarOffset == NULL)
    … …  
    24592470  r->ExpLSize=j/(sizeof(long)/sizeof(Exponent_t));
    24602471  r->mm_specHeap = mmGetSpecHeap(POLYSIZE + (r->ExpLSize)*sizeof(long));
     2472  assume(r->m_specHeap != NULL);
    24612473
    24622474  // ----------------------------
    … …  
    29212933  r->ExpLSize=j/(sizeof(long)/sizeof(Exponent_t));
    29222934  r->mm_specHeap = mmGetSpecHeap(POLYSIZE + (r->ExpLSize)*sizeof(long));
    2923   if (r->mm_specHeap == NULL)
    2924   {
    2925     // monomial too large, clean up
    2926     Free((ADDRESS)tmp_ordsgn,(2*(n+r->N)*sizeof(long)));
    2927     Free((ADDRESS)tmp_typ,(2*(n+r->N)*sizeof(sro_ord)));
    2928     Free((ADDRESS)v,(r->N+1)*sizeof(int));
    2929     return TRUE;
    2930   }
    2931 
     2935  assume(r->mm_specHeap != NULL);
    29322936
    29332937  // ----------------------------
    … …  
    30243028void rUnComplete(ring r)
    30253029{
     3030  if (r->mm_specHeap != NULL)
     3031    mmUnGetSpecHeap(&(r->mm_specHeap));
    30263032  Free((ADDRESS)r->VarOffset, (r->N +1)*sizeof(int));
    30273033  if (r->OrdSize!=0)
    … …  
    30443050  int i,j;
    30453051  int *pi;
    3046   ring res=(ring)Alloc(sizeof(ip_sring));
     3052  ring res=(ring)AllocSizeOf(ip_sring);
    30473053
    30483054  memcpy4(res,r,sizeof(ip_sring));
    … …  
    30523058    res->minpoly=nCopy(r->minpoly);
    30533059    int l=rPar(r);
    3054     res->parameter=(char **)Alloc(l*sizeof(char *));
     3060    res->parameter=(char **)Alloc(l*sizeof(char_ptr));
    30553061    int i;
    30563062    for(i=0;i<r->P;i++)
    … …  
    30593065    }
    30603066  }
    3061   res->names   = (char **)Alloc(r->N * sizeof(char *));
     3067  res->names   = (char **)Alloc(r->N * sizeof(char_ptr));
    30623068  i=1; // ringorder_C ->  ringorder_S
    30633069  pi=r->order;
    30643070  while ((*pi)!=0) { i++;pi++; }
    3065   res->wvhdl   = (int **)Alloc(i * sizeof(int *));
     3071  res->wvhdl   = (int **)Alloc(i * sizeof(int_ptr));
    30663072  res->order   = (int *) Alloc(i * sizeof(int));
    30673073  res->block0  = (int *) Alloc(i * sizeof(int));
Note: See TracChangeset for help on using the changeset viewer.