Changeset 4b2155 in git


Ignore:
Timestamp:
Apr 16, 1999, 9:53:44 AM (24 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
0df02761ea5104747ff923eee578ddb4d27f4a45
Parents:
04d56fffcf5bd9bd7b214fdec1609e8a293fd986
Message:
*string() implemented for all types -- no line breaks
*inmtat(intvec, n, m) implemented


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

Legend:

Unmodified
Added
Removed

  • Singular/grammar.y

    r04d56f r4b2155  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: grammar.y,v 1.58 1999-04-15 17:28:03 Singular Exp $ */
     4/* $Id: grammar.y,v 1.59 1999-04-16 07:53:32 obachman Exp $ */
    55/*
    66* ABSTRACT: SINGULAR shell grammatik
    … …  
    638638            if(iiExprArith1(&$$,&$3,MATRIX_CMD)) YYERROR;
    639639          }
     640        | INTMAT_CMD '(' expr ',' expr ',' expr ')'
     641          {
     642            if(iiExprArith3(&$$,INTMAT_CMD,&$3,&$5,&$7)) YYERROR;
     643          }
    640644        | INTMAT_CMD '(' expr ')'
    641645          {

  • Singular/intvec.cc

    r04d56f r4b2155  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: intvec.cc,v 1.10 1998-09-24 09:59:43 Singular Exp $ */
     4/* $Id: intvec.cc,v 1.11 1999-04-16 07:53:33 obachman Exp $ */
    55/*
    66* ABSTRACT: class intvec: lists/vectors of integers
    … …  
    7777}
    7878
    79 char * intvec::ivString(int mat,int spaces)
     79char * intvec::ivString(int mat,int spaces, int dim)
    8080{
    8181  StringSetS("");
    … …  
    112112      if (j+1<row)
    113113      {
    114         StringAppend("\n");
     114        if (dim > 1) StringAppend("\n");
    115115        if (spaces>0) StringAppend("%-*.*s",spaces,spaces," ");
    116116      }
    … …  
    120120}
    121121
    122 char * intvec::String()
    123 {
    124   return mstrdup(ivString());
     122char * intvec::String(int dim)
     123{
     124  return mstrdup(ivString(0, 0, dim));
    125125}
    126126

  • Singular/intvec.h

    r04d56f r4b2155  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: intvec.h,v 1.6 1999-03-16 13:43:38 Singular Exp $ */
     6/* $Id: intvec.h,v 1.7 1999-04-16 07:53:34 obachman Exp $ */
    77/*
    88* ABSTRACT: class intvec: lists/vectors of integers
    … …  
    5555    // keiner (ausser obachman) darf das folgenden benutzen !!!
    5656    int * ivGetVec() { return v; }
    57     char * String();
    58     char * ivString(int mat=0,int spaces=0);
     57    char * String(int dim = 2);
     58    char * ivString(int mat=0,int spaces=0, int dim=2);
    5959    ~intvec()
    6060       {

  • Singular/iparith.cc

    r04d56f r4b2155  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: iparith.cc,v 1.141 1999-04-15 09:57:03 obachman Exp $ */
     4/* $Id: iparith.cc,v 1.142 1999-04-16 07:53:37 obachman Exp $ */
    55
    66/*
    … …  
    29522952  return FALSE;
    29532953}
    2954 static BOOLEAN jjSTRING(leftv res, leftv v)
    2955 {
    2956   res->data = (char *)v->String();
    2957   if (res->data==NULL)
    2958   {
    2959     Werror("cannot convert %s to string",Tok2Cmdname(v->Typ()));
    2960     return TRUE;
    2961   }
    2962   return FALSE;
    2963 }
    29642954static BOOLEAN jjSort_Id(leftv res, leftv v)
    29652955{
    29662956  res->data = (char *)idSort((ideal)v->Data());
    2967   return FALSE;
    2968 }
    2969 static BOOLEAN jjSTRING_PROC(leftv res, leftv v)
    2970 {
    2971   procinfov pi = IDPROC((idhdl)v->data);
    2972   if((pi->language == LANG_SINGULAR) && (pi->data.s.body!=NULL))
    2973   //if(pi->language == LANG_SINGULAR)
    2974   {
    2975     //if(pi->data.s.body==NULL)
    2976     //  iiGetLibProcBuffer(IDPROC((idhdl)v->data));
    2977     res->data=mstrdup(pi->data.s.body);
    2978   }
    2979   else
    2980     res->data=mstrdup("");
    29812957  return FALSE;
    29822958}
    … …  
    35593535,{jjSTD,        STD_CMD,         MODUL_CMD,      MODUL_CMD }
    35603536,{jjDUMMY,      STRING_CMD,      STRING_CMD,     STRING_CMD }
    3561 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     INT_CMD }
    3562 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     POLY_CMD }
    3563 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     VECTOR_CMD }
    3564 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     NUMBER_CMD }
    3565 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     MATRIX_CMD }
    3566 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     MODUL_CMD }
    3567 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     IDEAL_CMD }
    3568 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     MAP_CMD }
    3569 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     INTVEC_CMD }
    3570 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     INTMAT_CMD }
    3571 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     LINK_CMD }
    3572 ,{jjSTRING_PROC,STRING_CMD,      STRING_CMD,     PROC_CMD }
    3573 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     RING_CMD }
    3574 ,{jjSTRING,     STRING_CMD,      STRING_CMD,     QRING_CMD }
    35753537,{jjSYSTEM,     SYSTEM_CMD,      NONE,           STRING_CMD }
    35763538,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD }
    … …  
    39263888  return FALSE;
    39273889}
     3890static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
     3891{
     3892  intvec* im= new intvec((int)v->Data(),(int)w->Data(), 0);
     3893  intvec* arg = (intvec*) u->Data();
     3894  int i, n = min(im->cols()*im->rows(), arg->cols()*arg->rows());
     3895 
     3896  for (i=0; i<n; i++)
     3897  {
     3898    (*im)[i] = (*arg)[i];
     3899  }
     3900 
     3901  res->data = (char *)im;
     3902  return FALSE;
     3903}
    39283904static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
    39293905{
    … …  
    42274203//,{jjCALL3MANY,      INTERSECT_CMD,  NONE,   DEF_CMD,    DEF_CMD,    DEF_CMD }
    42284204,{lInsert3,         INSERT_CMD, LIST_CMD,   LIST_CMD,   DEF_CMD,    INT_CMD }
     4205,{jjINTMAT3,        INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD,    INT_CMD}
    42294206,{jjCALL3MANY,      INTVEC_CMD, INTVEC_CMD, DEF_CMD,    DEF_CMD,    DEF_CMD }
    42304207,{jjJET_P_IV,       JET_CMD,    POLY_CMD,   POLY_CMD,   INT_CMD,    INTVEC_CMD }
    … …  
    45874564static BOOLEAN jjSTRING_PL(leftv res, leftv v)
    45884565{
    4589   if ((v!=NULL)&&(v->next==NULL))
    4590     return iiExprArith1(res,v,iiOp);
    4591   int sl=0;
    4592   leftv h=v,nachher;
    4593   sleftv tmpR;
    4594   BOOLEAN bo;
    4595   char *sum=NULL;
    4596   while(h!=NULL)
    4597   {
    4598     /* convert to string =================================*/
    4599     nachher=h->next;
    4600     h->next=NULL;
    4601     bo=iiExprArith1(&tmpR,h,iiOp);
    4602     if(bo)
    4603     {
    4604       h->next=nachher;
    4605       FreeL(sum);
    4606       return TRUE;
    4607     }
    4608     /* append to 'sum' =================================*/
    4609     if(sum==NULL)
    4610     {
    4611       sum=(char *)tmpR.data;
    4612       sl=strlen(sum);
    4613     }
    4614     else
    4615     {
    4616       int nl=strlen((char *)tmpR.data);
    4617       char *s=(char *)AllocL(sl+nl+1);
    4618       memcpy(s,sum,sl);
    4619       memcpy(s+sl,(char *)tmpR.data,nl);
    4620       s[sl+nl]='\0';
    4621       sl+=nl;
    4622       FreeL(sum);
    4623       sum=s;
    4624     }
    4625     /* next sleftv =================================*/
    4626     h->next=nachher;
    4627     h=nachher;
    4628   }
    4629   if (sum==NULL) sum=mstrdup("");
    4630   res->data=(char *)sum;
     4566  if (v == NULL)
     4567  {
     4568    res->data = mstrdup("");
     4569    return FALSE;
     4570  }
     4571  int n = v->listLength();
     4572  if (n == 1)
     4573  {
     4574    res->data = v->String();
     4575    return FALSE;
     4576  }
     4577 
     4578  char** slist = (char**) Alloc(n*sizeof(char*));
     4579  int i, j;
     4580 
     4581  for (i=0, j=0; i<n; i++, v = v ->next)
     4582  {
     4583    slist[i] = v->String();
     4584    assume(slist[i] != NULL);
     4585    j+=strlen(slist[i]);
     4586  }
     4587  char* s = (char*) AllocL((j+1)*sizeof(char));
     4588  *s='\0';
     4589  for (i=0;i<n;i++)
     4590  {
     4591    strcat(s, slist[i]);
     4592    FreeL(slist[i]);
     4593  }
     4594  Free(slist, n*sizeof(char*));
     4595  res->data = s;
    46314596  return FALSE;
    46324597}

  • Singular/ipshell.cc

    r04d56f r4b2155  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipshell.cc,v 1.38 1999-03-15 16:18:53 Singular Exp $ */
     4/* $Id: ipshell.cc,v 1.39 1999-04-16 07:53:38 obachman Exp $ */
    55/*
    66* ABSTRACT:
    … …  
    505505    {
    506506      pString0(*pp++);
    507       s=StringAppend("%c\n",ch);
    508     }
    509   }
    510   s[strlen(s)-2]='\0';
     507      s=StringAppend("%c",ch);
     508      if (dim > 1) s = StringAppend("\n");
     509    }
     510  }
     511  s[strlen(s)- (dim > 1 ? 2 : 1)]='\0';
    511512  return s;
    512513}

  • Singular/lists.cc

    r04d56f r4b2155  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: lists.cc,v 1.12 1998-10-21 10:25:39 krueger Exp $ */
     4/* $Id: lists.cc,v 1.13 1999-04-16 07:53:39 obachman Exp $ */
    55/*
    66* ABSTRACT: handling of the list type
    … …  
    354354}
    355355
     356char* lString(lists l)
     357{
     358  if (l->nr == -1) return mstrdup("");
     359  char** slist = (char**) Alloc((l->nr+1) * sizeof(char*));
     360  int i, j, k;
     361  char *s;
     362  for (i=0, j = 0, k = 0; i<=l->nr; i++)
     363  {
     364    slist[i] = l->m[i].String();
     365    assume(slist[i] != NULL);
     366    if (*(slist[i]) != '\0')
     367    {
     368      j += strlen(slist[i]);
     369      k++;
     370    }
     371  }
     372  s = (char*) AllocL(j+k+1);
     373  *s = '\0';
     374  for (i=0; i<=l->nr; i++)
     375  {
     376    if (*(slist[i]) != '\0')
     377    {
     378      strcat(s, slist[i]);
     379      strcat(s, ",");
     380    }
     381    FreeL(slist[i]);
     382  }
     383  if (k > 0) s[strlen(s) - 1] = '\0';
     384  Free(slist, (l->nr+1) * sizeof(char*));
     385  return s;
     386}

  • Singular/lists.h

    r04d56f r4b2155  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: lists.h,v 1.6 1998-10-21 10:25:38 krueger Exp $ */
     6/* $Id: lists.h,v 1.7 1999-04-16 07:53:40 obachman Exp $ */
    77/*
    88* ABSTRACT: handling of the list type
    … …  
    5656BOOLEAN lAdd(leftv res, leftv u, leftv v);
    5757BOOLEAN lRingDependend(lists L);
     58char* lString(lists L);
     59
    5860
    5961lists liMakeResolv(resolvente r, int length, int reallen, int typ0, intvec ** weights);

  • Singular/ring.cc

    r04d56f r4b2155  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ring.cc,v 1.49 1999-03-25 20:18:32 Singular Exp $ */
     4/* $Id: ring.cc,v 1.50 1999-04-16 07:53:41 obachman Exp $ */
    55
    66/*
    … …  
    17361736ring rCopy(ring r)
    17371737{
     1738  if (r == NULL) return NULL;
    17381739  int i,j;
    17391740  int *pi;

  • Singular/subexpr.cc

    r04d56f r4b2155  
    638638}
    639639
    640 char *  sleftv::String(void *d)
     640char *  sleftv::String(void *d, BOOLEAN func)
    641641{
    642642#ifdef SIQ
    … …  
    658658  {
    659659    /* create a string, which may be freed by FreeL
    660     * leave the switch with return
    661     * or with break, which copies the string s*/
     660     * leave the switch with return
     661     * or with break, which copies the string s*/
    662662    char *s;
    663663    const char *n;
    … …  
    666666    switch (Typ())
    667667    {
    668       case INT_CMD:
    669         s=(char *)AllocL(MAX_INT_LEN+2);
    670         sprintf(s,"%d",(int)d);
    671         return s;
    672       case STRING_CMD:
    673         return (char *)CopyD(STRING_CMD);
    674       case POLY_CMD:
    675       case VECTOR_CMD:
    676         s = pString((poly)d);
    677         break;
    678       case NUMBER_CMD:
    679         StringSetS("");
    680         if ((rtyp==IDHDL)&&(IDTYP((idhdl)data)==NUMBER_CMD))
    681         {
    682           nWrite(IDNUMBER((idhdl)data));
    683         }
    684         else if (rtyp==NUMBER_CMD)
    685         {
    686           number n=(number)data;
    687           nWrite(n);
    688           data=(char *)n;
    689         }
    690         else if((rtyp==VMINPOLY)&&(rField_is_GF()))
    691         {
    692           nfShowMipo();
    693         }
    694         else
    695         {
    696           number n=nCopy((number)d);
    697           nWrite(n);
    698           nDelete(&n);
    699         }
    700         s = StringAppend("");
    701         break;
    702       case MATRIX_CMD:
    703         s= iiStringMatrix((matrix)d,2);
    704         break;
    705       case MODUL_CMD:
    706       case IDEAL_CMD:
    707       case MAP_CMD:
    708         s= iiStringMatrix((matrix)d,1);
    709         break;
    710       case INTVEC_CMD:
    711       case INTMAT_CMD:
    712       {
    713         intvec *v=(intvec *)d;
    714         return v->String();
    715       }
    716       case RING_CMD:
    717       case QRING_CMD:
    718       {
    719         return rString((ring)d);
    720       }
     668        case INT_CMD:
     669          s=(char *)AllocL(MAX_INT_LEN+2);
     670          sprintf(s,"%d",(int)d);
     671          return s;
     672        case STRING_CMD:
     673          if (d != NULL) return mstrdup((char*)d);
     674          return mstrdup("");
     675        case POLY_CMD:
     676        case VECTOR_CMD:
     677          s = pString((poly)d);
     678          break;
     679        case NUMBER_CMD:
     680          StringSetS("");
     681          if ((rtyp==IDHDL)&&(IDTYP((idhdl)data)==NUMBER_CMD))
     682          {
     683            nWrite(IDNUMBER((idhdl)data));
     684          }
     685          else if (rtyp==NUMBER_CMD)
     686          {
     687            number n=(number)data;
     688            nWrite(n);
     689            data=(char *)n;
     690          }
     691          else if((rtyp==VMINPOLY)&&(rField_is_GF()))
     692          {
     693            nfShowMipo();
     694          }
     695          else
     696          {
     697            number n=nCopy((number)d);
     698            nWrite(n);
     699            nDelete(&n);
     700          }
     701          s = StringAppend("");
     702          break;
     703        case MATRIX_CMD:
     704          s= iiStringMatrix((matrix)d,1);
     705          break;
     706        case MODUL_CMD:
     707        case IDEAL_CMD:
     708        case MAP_CMD:
     709          s= iiStringMatrix((matrix)d,1);
     710          break;
     711        case INTVEC_CMD:
     712        case INTMAT_CMD:
     713        {
     714          intvec *v=(intvec *)d;
     715          return v->String(1);
     716        }
     717        case RING_CMD:
     718        {
     719          return rString((ring)d);
     720        }
     721        case QRING_CMD:
     722        {
     723          char* r = rString((ring)d);
     724          char* i = iiStringMatrix((matrix) ((ring) d)->qideal, 1);
     725          s = (char*) AllocL(strlen(r) + strlen(i) + 4);
     726          sprintf(s, "%s,(%s)", r, i);
     727          FreeL(r);
     728          return s;
     729        }
     730       
     731        case RESOLUTION_CMD:
     732        {
     733          lists l = syConvRes((syStrategy)d);
     734          s = lString(l);
     735          l->Clean();
     736          return (s);
     737        }
     738        case PROC_CMD:
     739        {
     740          procinfo* pi = (procinfo*) d;
     741          if((pi->language == LANG_SINGULAR) && (pi->data.s.body!=NULL))
     742            return mstrdup(pi->data.s.body);
     743          else
     744            return mstrdup("");
     745        }
     746         
    721747        case LINK_CMD:
    722748        {
    723749          return slString((si_link) d);
    724750        }
     751        case DEF_CMD:
     752        {
     753          return mstrdup("");
     754        }
    725755       
    726       default:
    727         #ifdef TEST
    728         ::Print("String:unknown type %s(%d)", Tok2Cmdname(Typ()),Typ());
    729         #endif
    730         return NULL;
     756        case LIST_CMD:
     757        {
     758          return lString((lists) d);
     759        }
     760        default:
     761#ifdef TEST
     762          ::Print("String:unknown type %s(%d)", Tok2Cmdname(Typ()),Typ());
     763#endif
     764          return mstrdup("");
    731765    } /* end switch: (Typ()) */
    732766    return mstrdup(s);
    733767  }
    734   return NULL;
     768  return mstrdup("");
    735769}
    736770

  • Singular/subexpr.h

    r04d56f r4b2155  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: subexpr.h,v 1.15 1999-03-16 15:33:15 Singular Exp $ */
     6/* $Id: subexpr.h,v 1.16 1999-04-16 07:53:44 obachman Exp $ */
    77/*
    88* ABSTRACT: handling of leftv
    … …  
    6060    void Print(leftv store=NULL,int spaces=0);
    6161    void CleanUp();
    62     char * String(void *d=NULL);
     62    char * String(void *d=NULL, BOOLEAN func = FALSE);
    6363    void Copy(leftv e);
    6464    void * CopyD();
Note: See TracChangeset for help on using the changeset viewer.