Changeset c7ae4d in git


Ignore:
Timestamp:
Aug 31, 2016, 12:30:31 AM (7 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'f875bbaccd0831e36aaed09ff6adeb3eb45aeb94')
Children:
e180f5613c396d33aa3316cd450d3a1e80d69129
Parents:
7e2307f3485ab92e550254c1212dafc2940b41ea
Message:
Singular_4_1: parent(..)
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • Singular/ipassign.cc

    r7e2307 rc7ae4d  
    512512    {
    513513      number2 nn=(number2)res->data;
    514       if (currRing->cf==nn->cf)
    515       {
    516         number2 n=(number2)omAlloc(sizeof(*n));
    517         n->cf=currRing->cf; n->cf++;
    518         n->n=(number)a->CopyD(NUMBER_CMD);
    519         n2Delete(nn);
    520         res->data=(void *)n;
    521       }
    522       else
    523       {
    524         WerrorS("different base");
    525         return TRUE;
    526       }
     514      number2 n=(number2)omAlloc(sizeof(*n));
     515      n->cf=currRing->cf; n->cf->ref++;
     516      n->n=(number)a->CopyD(NUMBER_CMD);
     517      n2Delete(nn);
     518      res->data=(void *)n;
    527519    }
    528520    else
    529521    {
    530       WerrorS("no (c)ring avialable for conversion from number");
    531       return TRUE;
    532     }
     522      number2 n=(number2)omAlloc(sizeof(*n));
     523      n->cf=currRing->cf; n->cf->ref++;
     524      n->n=(number)a->CopyD(NUMBER_CMD);
     525      res->data=(void *)n;
     526    }
     527  }
     528  else return TRUE; // TODO: list elements
     529  return FALSE;
     530}
     531static BOOLEAN jiA_POLY2(leftv res, leftv a, Subexpr e)
     532{
     533  poly2 n=(poly2)a->CopyD(CPOLY_CMD);
     534  if (e==NULL)
     535  {
     536    if (res->data!=NULL)
     537    {
     538      poly2 nn=(poly2)res->data;
     539      p2Delete(nn);
     540    }
     541    res->data=(void *)n;
     542    jiAssignAttr(res,a);
    533543  }
    534544  else
    … …  
    540550      return TRUE;
    541551    }
    542     bigintmat *iv=(bigintmat *)res->data;
    543     if (e->next==NULL)
    544     {
    545       WerrorS("only one index given");
    546       return TRUE;
     552    WerrorS("not yet"); // TODO: list elem
     553    return TRUE;
     554  }
     555  jiAssignAttr(res,a);
     556  return FALSE;
     557}
     558static BOOLEAN jiA_POLY2_P(leftv res, leftv a, Subexpr e)
     559{
     560  if (e==NULL)
     561  {
     562    if (res->data!=NULL)
     563    {
     564      poly2 nn=(poly2)res->data;
     565      poly2 n=(poly2)omAlloc(sizeof(*n));
     566      n->cf=currRing; n->cf->ref++;
     567      n->n=(poly)a->CopyD(POLY_CMD);
     568      p2Delete(nn);
     569      res->data=(void *)n;
    547570    }
    548571    else
    549572    {
    550       int c=e->next->start;
    551       if ((i>=iv->rows())||(c<1)||(c>iv->cols()))
    552       {
    553         Werror("wrong range [%d,%d] in cmatrix %s(%d,%d)",i+1,c,res->Name(),iv->rows(),iv->cols());
    554         return TRUE;
    555       }
    556       else if (iv->basecoeffs()==currRing->cf)
    557       {
    558         n_Delete((number *)&BIMATELEM(*iv,i+1,c),iv->basecoeffs());
    559         BIMATELEM(*iv,i+1,c) = (number)(a->CopyD(NUMBER_CMD));
    560       }
    561       else
    562       {
    563         WerrorS("different base");
    564         return TRUE;
    565       }
    566     }
    567   }
     573      poly2 n=(poly2)omAlloc(sizeof(*n));
     574      n->cf=currRing; n->cf->ref++;
     575      n->n=(poly)a->CopyD(POLY_CMD);
     576      res->data=(void *)n;
     577    }
     578  }
     579  else return TRUE; // TODO: list elements
    568580  return FALSE;
    569581}

  • Singular/ipconv.cc

    r7e2307 rc7ae4d  
    185185  }
    186186  number n=nInit((int)(long)data);
    187   number2 nn=(number2)omAlloc(sizeof*nn);
     187  number2 nn=(number2)omAlloc(sizeof(*nn));
    188188  nn->cf=currRing->cf; nn->cf->ref++;
    189189  nn->n=n;
    190190  return (void *)nn;
    191191}
     192static void * iiI2CP(void *data)
     193{
     194  if (currRing==NULL)
     195  {
     196    WerrorS("missing basering while converting int to Poly");
     197    return NULL;
     198  }
     199  poly n=pISet((int)(long)data);
     200  poly2 nn=(poly2)omAlloc(sizeof(*nn));
     201  nn->cf=currRing; nn->cf->ref++;
     202  nn->n=n;
     203  return (void *)nn;
     204}
    192205#endif
    193206
    … …  
    222235  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
    223236  n_Delete((number *)&data, coeffs_BIGINT);
    224   number2 nn=(number2)omAlloc(sizeof*nn);
     237  number2 nn=(number2)omAlloc(sizeof(*nn));
    225238  nn->cf=currRing->cf; nn->cf->ref++;
     239  nn->n=n;
     240  return (void*)nn;
     241}
     242static void * iiBI2CP(void *data)
     243{
     244  if (currRing==NULL)
     245  {
     246    WerrorS("missing basering while converting bigint to Poly");
     247    return NULL;
     248  }
     249  nMapFunc nMap=n_SetMap(coeffs_BIGINT,currRing->cf);
     250  if (nMap==NULL)
     251  {
     252    Werror("no conversion from bigint to %s",currRing->cf->cfCoeffString(currRing->cf));
     253    return NULL;
     254  }
     255  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
     256  n_Delete((number *)&data, coeffs_BIGINT);
     257  poly2 nn=(poly2)omAlloc(sizeof(*nn));
     258  nn->cf=currRing; nn->cf->ref++;
     259  nn->n=pNSet(n);
     260  return (void*)nn;
     261}
     262static void * iiP2CP(void *data)
     263{
     264  poly2 nn=(poly2)omAlloc(sizeof(*nn));
     265  nn->cf=currRing; nn->cf->ref++;
     266  nn->n=(poly)data;
    226267  return (void*)nn;
    227268}

  • Singular/ipid.cc

    r7e2307 rc7ae4d  
    138138    case CNUMBER_CMD:
    139139      return (void*)n2Init(0,NULL);
     140    case CPOLY_CMD:
     141      return (void*)p2Init(0,NULL);
    140142    case CMATRIX_CMD:
    141143#endif

  • Singular/misc_ip.cc

    r7e2307 rc7ae4d  
    12621262    n_coeffType type;
    12631263    #ifdef SINGULAR_4_1
    1264     type = nRegister(n_polyExt, naInitChar);
     1264    type = nRegister(n_polyExt, n2pInitChar);
    12651265    assume(type == n_polyExt);
    12661266    #endif

  • Singular/number2.cc

    r7e2307 rc7ae4d  
    77#include <coeffs/bigintmat.h> // bigintmat
    88#include <coeffs/longrat.h> // BIGINTs: nlGMP
     9#include <polys/ext_fields/algext.h> // AlgExtInfo
    910#include <misc/prime.h> // IsPrime
    1011#include <Singular/blackbox.h> // blackbox type
    1112#include <Singular/ipshell.h> // IsPrime
     13#include <Singular/ipconv.h> // iiConvert etc.
    1214
    1315#include <Singular/ipid.h> // for SModulFunctions, leftv
    … …  
    7678// interpreter stuff for Number/number2
    7779// -----------------------------------------------------------
     80BOOLEAN jjNUMBER2_POW(leftv res, leftv a, leftv b)
     81{
     82  number2 a2=(number2)a->Data();
     83  if (a2->cf==NULL) return TRUE;
     84  number2 r=(number2)omAlloc0(sizeof(*r));
     85  r->cf=a2->cf;
     86  n_Power(a2->n,(int)(long)b->Data(),&(r->n),r->cf);
     87  return FALSE;
     88}
    7889BOOLEAN jjNUMBER2_OP2(leftv res, leftv a, leftv b)
    7990{
    … …  
    8495  number2 b2=NULL;
    8596  number bb=NULL;
    86   if (a->Typ()==CNUMBER_CMD)
    87   {
    88     a2=(number2)a->Data();
    89     aa=a2->n;
    90   }
    91   if (b->Typ()==CNUMBER_CMD)
    92   {
    93     b2=(number2)b->Data();
    94     if ((a2!=NULL) && (a2->cf!=b2->cf))
    95     {
    96       WerrorS("Number not compatible");
     97  leftv an = (leftv)omAlloc0Bin(sleftv_bin);
     98  leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
     99  int ai,bi;
     100  int at=a->Typ();
     101  int bt=b->Typ();
     102  if ((ai=iiTestConvert(at,CNUMBER_CMD,dConvertTypes))!=0)
     103  {
     104    if ((bi=iiTestConvert(bt,CNUMBER_CMD,dConvertTypes))!=0)
     105    {
     106      iiConvert(at,CNUMBER_CMD,ai,a,an);
     107      iiConvert(bt,CNUMBER_CMD,bi,b,bn);
     108      a2=(number2)an->Data();
     109      b2=(number2)bn->Data();
     110      if (((a2!=NULL) && (b2!=NULL) && (a2->cf!=b2->cf))
     111      || (a2==NULL)
     112      || (b2==NULL))
     113      {
     114        an->CleanUp();
     115        bn->CleanUp();
     116        omFreeBin((ADDRESS)an, sleftv_bin);
     117        omFreeBin((ADDRESS)bn, sleftv_bin);
     118        WerrorS("Number not compatible");
     119        return TRUE;
     120      }
     121      aa=a2->n;
     122      bb=b2->n;
     123      number2 r=(number2)omAlloc0(sizeof(*r));
     124      r->cf=a2->cf;
     125      if (r->cf==NULL) op=0; // force error
     126      switch(op)
     127      {
     128        case '+': r->n=n_Add(aa,bb,r->cf);break;
     129        case '-': r->n=n_Sub(aa,bb,r->cf);break;
     130        case '*': r->n=n_Mult(aa,bb,r->cf);break;
     131        case '/': r->n=n_Div(aa,bb,r->cf);break;
     132        case '%': r->n=n_IntMod(aa,bb,r->cf);break;
     133        default: Werror("unknown binary operation %s(%d)",Tok2Cmdname(op),op);
     134             omFree(r);
     135             an->CleanUp();
     136             bn->CleanUp();
     137             omFreeBin((ADDRESS)an, sleftv_bin);
     138             omFreeBin((ADDRESS)bn, sleftv_bin);
     139             return TRUE;
     140      }
     141      res->data=(void*)r;
     142      r->cf->ref++;
     143      return FALSE;
     144    }
     145    else
     146    {
     147      an->CleanUp();
     148      omFreeBin((ADDRESS)an, sleftv_bin);
     149      Werror("cannot convert second operand (%s) to Number",b->Name());
    97150      return TRUE;
    98151    }
    99     bb=b2->n;
    100   }
    101   number2 r=(number2)omAlloc(sizeof(*r));
    102   if (a2!=NULL) r->cf=a2->cf;
    103   else          r->cf=b2->cf;
    104   if (r->cf==NULL) op=0; // force error
     152  }
    105153  else
    106   if (a2==NULL)
    107   {
    108     if (a->Typ()==INT_CMD) aa=n_Init((long)a->Data(),r->cf);
    109     else if (a->Typ()==BIGINT_CMD)
    110     {
    111       //aa=n_Init_bigint((number)a->Data(),coeffs_BIGINT,r->cf);
    112       nMapFunc nMap=n_SetMap(coeffs_BIGINT,r->cf);
    113       aa=nMap((number)a->Data(),coeffs_BIGINT,r->cf);
    114     }
    115     else op=0;
    116   }
    117   if ((b2==NULL) &&(op!='^') &&(op!=0))
    118   {
    119     if (b->Typ()==INT_CMD) bb=n_Init((long)b->Data(),r->cf);
    120     else if (b->Typ()==BIGINT_CMD)
    121     {
    122       //bb=n_Init_bigint((number)b->Data(),coeffs_BIGINT,r->cf);
    123       nMapFunc nMap=n_SetMap(coeffs_BIGINT,r->cf);
    124       bb=nMap((number)b->Data(),coeffs_BIGINT,r->cf);
    125     }
    126     else op=0;
    127   }
    128   switch(op)
    129   {
    130     case '+': r->n=n_Add(aa,bb,r->cf);break;
    131     case '-': r->n=n_Sub(aa,bb,r->cf);break;
    132     case '*': r->n=n_Mult(aa,bb,r->cf);break;
    133     case '/': r->n=n_Div(aa,bb,r->cf);break;
    134     case '%': r->n=n_IntMod(aa,bb,r->cf);break;
    135 
    136     case '^': n_Power(aa,(int)(long)b->Data(),&(r->n),r->cf); break;
    137 
    138     default: Werror("unknown binary operation %s(%d)",Tok2Cmdname(op),op);
    139              omFree(r);
    140              return TRUE;
    141   }
    142   res->data=(void*)r;
    143   r->cf->ref++;
    144   return FALSE;
     154  {
     155    Werror("cannot convert first operand (%s) to Number",a->Name());
     156    return TRUE;
     157  }
    145158}
    146159BOOLEAN jjNUMBER2_OP1(leftv res, leftv a)
    … …  
    155168  {
    156169    case '-': r->n=n_Copy(a2->n,a2->cf);r->n=n_InpNeg(r->n,a2->cf);break;
     170    default: Werror("unknown unary operation %s(%d)",Tok2Cmdname(op),op);
     171             omFree(r);
     172             return TRUE;
     173  }
     174  res->data=(void*)r;
     175  r->cf->ref++;
     176  return FALSE;
     177}
     178
     179BOOLEAN jjPOLY2_POW(leftv res, leftv a, leftv b)
     180{
     181  poly2 a2=(poly2)a->Data();
     182  if (a2->cf==NULL) return TRUE;
     183  poly2 r=(poly2)omAlloc0(sizeof(*r));
     184  r->cf=a2->cf;
     185  r->n=p_Power(p_Copy(a2->n,r->cf),(int)(long)b->Data(),r->cf);
     186  return FALSE;
     187}
     188BOOLEAN jjPOLY2_OP2(leftv res, leftv a, leftv b)
     189{
     190  int op=iiOp;
     191  // binary operations for poly2
     192  poly2 a2=NULL;
     193  poly aa=NULL;
     194  poly2 b2=NULL;
     195  poly bb=NULL;
     196  leftv an = (leftv)omAlloc0Bin(sleftv_bin);
     197  leftv bn = (leftv)omAlloc0Bin(sleftv_bin);
     198  int ai,bi;
     199  int at=a->Typ();
     200  int bt=b->Typ();
     201  if ((ai=iiTestConvert(at,CPOLY_CMD,dConvertTypes))!=0)
     202  {
     203    if ((bi=iiTestConvert(bt,CPOLY_CMD,dConvertTypes))!=0)
     204    {
     205      iiConvert(at,CPOLY_CMD,ai,a,an);
     206      iiConvert(bt,CPOLY_CMD,bi,b,bn);
     207      a2=(poly2)an->Data();
     208      b2=(poly2)bn->Data();
     209      if (((a2!=NULL) && (b2!=NULL) && (a2->cf!=b2->cf))
     210      || (a2==NULL)
     211      || (b2==NULL))
     212      {
     213        an->CleanUp();
     214        bn->CleanUp();
     215        omFreeBin((ADDRESS)an, sleftv_bin);
     216        omFreeBin((ADDRESS)bn, sleftv_bin);
     217        WerrorS("Poly not compatible");
     218        return TRUE;
     219      }
     220      aa=a2->n;
     221      bb=b2->n;
     222      poly2 r=(poly2)omAlloc0(sizeof(*r));
     223      r->cf=a2->cf;
     224      if (r->cf==NULL) op=0; // force error
     225      switch(op)
     226      {
     227        case '+': r->n=p_Add_q(p_Copy(aa,r->cf),p_Copy(bb,r->cf),r->cf);break;
     228        case '-': r->n=p_Sub(p_Copy(aa,r->cf),p_Copy(bb,r->cf),r->cf);break;
     229        case '*': r->n=pp_Mult_qq(aa,bb,r->cf);break;
     230        //case '/': r->n=n_Div(aa,bb,r->cf);break;
     231        //case '%': r->n=n_IntMod(aa,bb,r->cf);break;
     232        default: Werror("unknown binary operation %s(%d)",Tok2Cmdname(op),op);
     233             omFree(r);
     234             an->CleanUp();
     235             bn->CleanUp();
     236             omFreeBin((ADDRESS)an, sleftv_bin);
     237             omFreeBin((ADDRESS)bn, sleftv_bin);
     238             return TRUE;
     239      }
     240      res->data=(void*)r;
     241      r->cf->ref++;
     242      return FALSE;
     243    }
     244    else
     245    {
     246      an->CleanUp();
     247      omFreeBin((ADDRESS)an, sleftv_bin);
     248      Werror("cannot convert second operand (%s) to Poly",b->Name());
     249      return TRUE;
     250    }
     251  }
     252  else
     253  {
     254    Werror("cannot convert first operand (%s) to Poly",a->Name());
     255    return TRUE;
     256  }
     257}
     258BOOLEAN jjPOLY2_OP1(leftv res, leftv a)
     259{
     260  int op=iiOp;
     261  // unary operations for poly2
     262  poly2 a2=(poly2)a->Data();
     263  poly2 r=(poly2)omAlloc(sizeof(*r));
     264  r->cf=a2->cf;
     265  if (a2->cf==NULL) op=0; // force error
     266  switch(op)
     267  {
     268    case '-': r->n=p_Copy(a2->n,a2->cf);r->n=p_Neg(r->n,a2->cf);break;
    157269    default: Werror("unknown unary operation %s(%d)",Tok2Cmdname(op),op);
    158270             omFree(r);
    … …  
    221333}
    222334
     335BOOLEAN jjP2_R(leftv res, leftv a)              // poly2 ->ring
     336{
     337  poly2 n=(poly2)a->Data();
     338  n->cf->ref++;
     339  res->data=(void*)n->cf;
     340  return FALSE;
     341}
     342
    223343BOOLEAN jjCM_CR(leftv res, leftv a)              // cmatrix ->cring
    224344{
    … …  
    316436}
    317437
     438// -----------------------------------------------------------
     439// operations with Poly/poly2
     440// -----------------------------------------------------------
     441
     442poly2 p2Copy(const poly2 d)
     443{
     444  poly2 r=NULL;
     445  if ((d!=NULL)&&(d->cf!=NULL))
     446  {
     447    r=(poly2)omAlloc(sizeof(*r));
     448    d->cf->ref++;
     449    r->cf=d->cf;
     450    if (d->cf!=NULL)
     451      r->n=p_Copy(d->n,d->cf);
     452    else
     453      r->n=NULL;
     454  }
     455  return r;
     456}
     457void p2Delete(poly2 &d)
     458{
     459  if (d!=NULL)
     460  {
     461    if (d->cf!=NULL)
     462    {
     463      p_Delete(&d->n,d->cf);
     464      rKill(d->cf);
     465    }
     466    omFreeSize(d,sizeof(*d));
     467    d=NULL;
     468  }
     469}
     470char *p2String(poly2 d, BOOLEAN typed)
     471{
     472  StringSetS("");
     473  if ((d!=NULL) && (d->cf!=NULL))
     474  {
     475    if (typed) StringAppendS("Poly(");
     476    p_Write0(d->n,d->cf);
     477    if (typed) StringAppendS(")");
     478  }
     479  else StringAppendS("oo");
     480  return StringEndS();
     481}
     482
     483void p2Print(poly2 d)
     484{
     485  char *s=p2String(d,FALSE);
     486  PrintS(s);
     487  omFree(s);
     488}
     489
     490// ---------------------------------------------------------------------
    318491#include <coeffs/bigintmat.h>
    319492BOOLEAN jjBIM2_CR(leftv res, leftv a)              // bigintmat ->cring
    … …  
    321494  bigintmat *b=(bigintmat*)a->Data();
    322495  coeffs cf=b->basecoeffs();
     496  if (cf==NULL) return TRUE;
    323497  cf->ref++;
    324498  res->data=(void*)cf;
    … …  
    329503{
    330504  ring r=(ring)a->Data();
    331   coeffs cf=r->cf;
    332   cf->ref++;
     505  AlgExtInfo extParam;
     506  extParam.r = r;
     507  coeffs cf=nInitChar(n_polyExt,&extParam);
    333508  res->data=(void*)cf;
    334509  return FALSE;

  • Singular/number2.h

    r7e2307 rc7ae4d  
    99#include <kernel/structs.h>
    1010struct snumber2;
     11struct spoly2;
    1112typedef struct snumber2 *   number2;
     13typedef struct spoly2 *     poly2;
    1214struct snumber2
    1315{ coeffs cf;
    … …  
    1517};
    1618
     19struct spoly2
     20{ ring cf;
     21  poly n;
     22};
     23
    1724static inline number2 n2Init(long i, coeffs c)
    1825{ number2 N=(number2)omAlloc0(sizeof(snumber2)); if (c!=NULL) { N->cf=c; N->n=n_Init(i,c);} return N;}
     26
     27static inline poly2 p2Init(long i, ring c)
     28{ poly2 N=(poly2)omAlloc0(sizeof(spoly2)); if (c!=NULL) { N->cf=c; N->n=p_ISet(i,c);} return N;}
    1929
    2030char *crString(coeffs c);
    … …  
    3141BOOLEAN jjN2_CR(leftv res, leftv a);              // number2 ->cring
    3242BOOLEAN jjCM_CR(leftv res, leftv a);              // cmatrix ->cring
    33 BOOLEAN jjBIM2_CR(leftv res, leftv a);              // bigint ->cring
     43BOOLEAN jjBIM2_CR(leftv res, leftv a);            // bigint ->cring
    3444BOOLEAN jjR2_CR(leftv res, leftv a);              // ring ->cring
    35 BOOLEAN jjN2_N(leftv res, leftv a);             // number2 ->number
    36 
     45BOOLEAN jjN2_N(leftv res, leftv a);               // number2 ->number
     46BOOLEAN jjP2_R(leftv res, leftv a);              // poly2 ->ring
    3747// operations:
    3848BOOLEAN jjNUMBER2_OP1(leftv res, leftv a);
    3949BOOLEAN jjNUMBER2_OP2(leftv res, leftv a, leftv b);
     50BOOLEAN jjNUMBER2_POW(leftv res, leftv a, leftv b);
     51BOOLEAN jjPOLY2_OP1(leftv res, leftv a);
     52BOOLEAN jjPOLY2_OP2(leftv res, leftv a, leftv b);
     53BOOLEAN jjPOLY2_POW(leftv res, leftv a, leftv b);
    4054
    4155number2 n2Copy(const number2 d);
    … …  
    4458void n2Print(number2 d);
    4559
     60poly2 p2Copy(const poly2 d);
     61void p2Delete(poly2 &d);
     62char *p2String(poly2 d, BOOLEAN typed);
     63void p2Print(poly2 d);
     64
    4665BOOLEAN jjCMATRIX_3(leftv, leftv, leftv,leftv);
    4766#endif

  • Singular/subexpr.cc

    r7e2307 rc7ae4d  
    112112        case CNUMBER_CMD:
    113113          n2Print((number2)d);
     114          break;
     115        case CPOLY_CMD:
     116          p2Print((poly2)d);
    114117          break;
    115118        case CMATRIX_CMD: // like BIGINTMAT
    … …  
    414417    case CNUMBER_CMD:
    415418      return (void*)n2Copy((number2)d);
     419    case CPOLY_CMD:
     420      return (void*)p2Copy((poly2)d);
    416421    case CMATRIX_CMD: // like BIGINTMAT
    417422#endif
    … …  
    495500        break;
    496501      }
     502    case CPOLY_CMD:
     503      {
     504        poly2 n=(poly2)d;
     505        p2Delete(n);
     506        break;
     507      }
    497508    case CMATRIX_CMD: //like BIGINTMAT
    498509#endif

  • Singular/table.h

    r7e2307 rc7ae4d  
    2828#ifdef SINGULAR_4_1
    2929,{D(jjNUMBER2_OP1),'-',             CNUMBER_CMD,    CNUMBER_CMD   , ALLOW_PLURAL |ALLOW_RING}
     30,{D(jjPOLY2_OP1),  '-',             CPOLY_CMD,      CPOLY_CMD     , ALLOW_PLURAL |ALLOW_RING}
    3031#endif
    3132,{D(jjUMINUS_P),   '-',             POLY_CMD,       POLY_CMD      , ALLOW_PLURAL |ALLOW_RING}
    … …  
    8788,{D(jjCM_CR),      CRING_CMD,       CRING_CMD,      CMATRIX_CMD   , ALLOW_PLURAL |ALLOW_RING}
    8889,{D(jjBIM2_CR),    CRING_CMD,       CRING_CMD,      BIGINTMAT_CMD , ALLOW_PLURAL |ALLOW_RING}
     90,{D(jjP2_R),       CRING_CMD,       CRING_CMD,      CPOLY_CMD ,     ALLOW_PLURAL |ALLOW_RING}
    8991,{D(jjR2_CR),      CRING_CMD,       CRING_CMD,      RING_CMD      , ALLOW_PLURAL |ALLOW_RING}
    9092#endif
    … …  
    203205,{D(jjPAR1),       PAR_CMD,         NUMBER_CMD,     INT_CMD       , ALLOW_PLURAL |ALLOW_RING}
    204206,{D(jjPARDEG),     PARDEG_CMD,      INT_CMD,        NUMBER_CMD    , ALLOW_PLURAL |ALLOW_RING}
     207#ifdef SINGULAR_4_1
     208,{D(jjN2_CR),      PARENT_CMD,      CRING_CMD,      CNUMBER_CMD    , ALLOW_PLURAL |ALLOW_RING}
     209,{D(jjP2_R),       PARENT_CMD,      RING_CMD,       CPOLY_CMD      , ALLOW_PLURAL |ALLOW_RING}
     210,{D(jjCM_CR),      PARENT_CMD,      CRING_CMD,      CMATRIX_CMD      , ALLOW_PLURAL |ALLOW_RING}
     211#endif
    205212,{D(jjPARSTR1),    PARSTR_CMD,      STRING_CMD,     INT_CMD       , ALLOW_PLURAL |ALLOW_RING}
    206213,{D(jjrParStr),    PARSTR_CMD,      STRING_CMD,     RING_CMD      , ALLOW_PLURAL |ALLOW_RING}
    … …  
    228235,{D(jjN2_CR),      RING_CMD,        CRING_CMD,      CNUMBER_CMD   , ALLOW_PLURAL |ALLOW_RING}
    229236,{D(jjCM_CR),      RING_CMD,        CRING_CMD,      CMATRIX_CMD   , ALLOW_PLURAL |ALLOW_RING}
     237,{D(jjP2_R),       RING_CMD,        RING_CMD,       CPOLY_CMD     , ALLOW_PLURAL |ALLOW_RING}
    230238#endif
    231239,{D(jjDUMMY),      RING_CMD,        RING_CMD,       RING_CMD      , ALLOW_PLURAL |ALLOW_RING}
    … …  
    298306,{D(jjPLUS_BI),   '+',            BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
    299307,{D(jjPLUS_N),    '+',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    300 #ifdef SINGULAR_4_1
    301 ,{D(jjNUMBER2_OP2),'+',           CNUMBER_CMD,    CNUMBER_CMD,CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    302 ,{D(jjNUMBER2_OP2),'+',           CNUMBER_CMD,    INT_CMD,    CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    303 ,{D(jjNUMBER2_OP2),'+',           CNUMBER_CMD,    CNUMBER_CMD,INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    304 ,{D(jjNUMBER2_OP2),'+',           CNUMBER_CMD,    BIGINT_CMD, CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    305 ,{D(jjNUMBER2_OP2),'+',           CNUMBER_CMD,    CNUMBER_CMD,BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
    306 #endif
    307308,{D(jjPLUS_P),    '+',            POLY_CMD,       POLY_CMD,   POLY_CMD, ALLOW_PLURAL | ALLOW_RING}
    308309,{D(jjPLUS_P),    '+',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD, ALLOW_PLURAL | ALLOW_RING}
    … …  
    325326,{D(jjPLUS_IV),   '+',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD, ALLOW_PLURAL | ALLOW_RING}
    326327#ifdef SINGULAR_4_1
     328,{D(jjNUMBER2_OP2),'+',           CNUMBER_CMD,    CNUMBER_CMD,CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
     329,{D(jjNUMBER2_OP2),'+',           CNUMBER_CMD,    DEF_CMD,    CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
     330,{D(jjNUMBER2_OP2),'+',           CNUMBER_CMD,    CNUMBER_CMD,DEF_CMD, ALLOW_PLURAL | ALLOW_RING}
     331,{D(jjPOLY2_OP2), '+',            CPOLY_CMD,      CPOLY_CMD,  DEF_CMD, ALLOW_PLURAL | ALLOW_RING}
     332,{D(jjPOLY2_OP2), '+',            CPOLY_CMD,      DEF_CMD,    CPOLY_CMD,  ALLOW_PLURAL | ALLOW_RING}
    327333,{D(jjPLUS_BIM),  '+',            CMATRIX_CMD,    CMATRIX_CMD, CMATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
    328334#endif
    … …  
    332338,{D(jjMINUS_BI),  '-',            BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
    333339,{D(jjMINUS_N),   '-',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    334 #ifdef SINGULAR_4_1
    335 ,{D(jjNUMBER2_OP2),'-',           CNUMBER_CMD,    CNUMBER_CMD,CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    336 ,{D(jjNUMBER2_OP2),'-',           CNUMBER_CMD,    INT_CMD,    CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    337 ,{D(jjNUMBER2_OP2),'-',           CNUMBER_CMD,    CNUMBER_CMD,INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    338 ,{D(jjNUMBER2_OP2),'-',           CNUMBER_CMD,    BIGINT_CMD, CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    339 ,{D(jjNUMBER2_OP2),'-',           CNUMBER_CMD,    CNUMBER_CMD,BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
    340 #endif
    341340,{D(jjMINUS_P),   '-',            POLY_CMD,       POLY_CMD,   POLY_CMD, ALLOW_PLURAL | ALLOW_RING}
    342341,{D(jjMINUS_P),   '-',            VECTOR_CMD,     VECTOR_CMD, VECTOR_CMD, ALLOW_PLURAL | ALLOW_RING}
    … …  
    353352,{D(jjMINUS_IV),  '-',            INTMAT_CMD,     INTMAT_CMD, INTMAT_CMD, ALLOW_PLURAL | ALLOW_RING}
    354353#ifdef SINGULAR_4_1
     354,{D(jjNUMBER2_OP2),'-',           CNUMBER_CMD,    CNUMBER_CMD,CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
     355,{D(jjNUMBER2_OP2),'-',           CNUMBER_CMD,    INT_CMD,    CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
     356,{D(jjNUMBER2_OP2),'-',           CNUMBER_CMD,    CNUMBER_CMD,INT_CMD, ALLOW_PLURAL | ALLOW_RING}
     357,{D(jjNUMBER2_OP2),'-',           CNUMBER_CMD,    BIGINT_CMD, CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
     358,{D(jjNUMBER2_OP2),'-',           CNUMBER_CMD,    CNUMBER_CMD,BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
     359,{D(jjPOLY2_OP2), '-',            CPOLY_CMD,      CPOLY_CMD,  CPOLY_CMD, ALLOW_PLURAL | ALLOW_RING}
     360,{D(jjPOLY2_OP2), '-',            CPOLY_CMD,      CPOLY_CMD,  INT_CMD, ALLOW_PLURAL | ALLOW_RING}
     361,{D(jjPOLY2_OP2), '-',            CPOLY_CMD,      INT_CMD,    CPOLY_CMD,  ALLOW_PLURAL | ALLOW_RING}
    355362,{D(jjMINUS_BIM), '-',            CMATRIX_CMD,    CMATRIX_CMD,CMATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
    356363#endif
    … …  
    360367,{D(jjTIMES_BI),  '*',            BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
    361368,{D(jjTIMES_N),   '*',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    362 #ifdef SINGULAR_4_1
    363 ,{D(jjNUMBER2_OP2),'*',           CNUMBER_CMD,    CNUMBER_CMD,CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    364 ,{D(jjNUMBER2_OP2),'*',           CNUMBER_CMD,    INT_CMD,    CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    365 ,{D(jjNUMBER2_OP2),'*',           CNUMBER_CMD,    CNUMBER_CMD,INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    366 ,{D(jjNUMBER2_OP2),'*',           CNUMBER_CMD,    BIGINT_CMD, CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    367 ,{D(jjNUMBER2_OP2),'*',           CNUMBER_CMD,    CNUMBER_CMD,BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
    368 #endif
    369369,{D(jjTIMES_P),   '*',            POLY_CMD,       POLY_CMD,   POLY_CMD, ALLOW_PLURAL | ALLOW_RING}
    370370,{D(jjTIMES_P),   '*',            VECTOR_CMD,     POLY_CMD,   VECTOR_CMD, ALLOW_PLURAL | ALLOW_RING}
    … …  
    401401,{D(jjTIMES_IV),  '*',            INTMAT_CMD,     INTVEC_CMD, INTMAT_CMD, ALLOW_PLURAL | ALLOW_RING}
    402402#ifdef SINGULAR_4_1
     403,{D(jjNUMBER2_OP2),'*',           CNUMBER_CMD,    CNUMBER_CMD,CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
     404,{D(jjNUMBER2_OP2),'*',           CNUMBER_CMD,    INT_CMD,    CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
     405,{D(jjNUMBER2_OP2),'*',           CNUMBER_CMD,    CNUMBER_CMD,INT_CMD, ALLOW_PLURAL | ALLOW_RING}
     406,{D(jjNUMBER2_OP2),'*',           CNUMBER_CMD,    BIGINT_CMD, CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
     407,{D(jjNUMBER2_OP2),'*',           CNUMBER_CMD,    CNUMBER_CMD,BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
     408,{D(jjPOLY2_OP2), '*',            CPOLY_CMD,      CPOLY_CMD,  CPOLY_CMD, ALLOW_PLURAL | ALLOW_RING}
     409,{D(jjPOLY2_OP2), '*',            CPOLY_CMD,      CPOLY_CMD,  INT_CMD, ALLOW_PLURAL | ALLOW_RING}
     410,{D(jjPOLY2_OP2), '*',            CPOLY_CMD,      INT_CMD,    CPOLY_CMD,  ALLOW_PLURAL | ALLOW_RING}
    403411,{D(jjTIMES_BIM), '*',            CMATRIX_CMD,    CMATRIX_CMD, CMATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
    404412#endif
    405413,{D(jjDIV_N),     '/',            NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    406 #ifdef SINGULAR_4_1
    407 ,{D(jjNUMBER2_OP2),'/',           CNUMBER_CMD,    CNUMBER_CMD,CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    408 ,{D(jjNUMBER2_OP2),'/',           CNUMBER_CMD,    INT_CMD,    CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    409 ,{D(jjNUMBER2_OP2),'/',           CNUMBER_CMD,    CNUMBER_CMD,INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    410 ,{D(jjNUMBER2_OP2),'/',           CNUMBER_CMD,    BIGINT_CMD, CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
    411 ,{D(jjNUMBER2_OP2),'/',           CNUMBER_CMD,    CNUMBER_CMD,BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
    412 #endif
    413414,{D(jjDIV_P),     '/',            POLY_CMD,       POLY_CMD,   POLY_CMD, ALLOW_PLURAL | ALLOW_RING}
    414415,{D(jjDIV_P),     '/',            VECTOR_CMD,     VECTOR_CMD, POLY_CMD, ALLOW_PLURAL | ALLOW_RING}
    … …  
    421422,{D(jjCRING_Zp),  '/',            CRING_CMD,      CRING_CMD,  INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    422423,{D(jjCRING_Zm),  '/',            CRING_CMD,      CRING_CMD,  BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
     424,{D(jjNUMBER2_OP2),'/',           CNUMBER_CMD,    CNUMBER_CMD,CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
     425,{D(jjNUMBER2_OP2),'/',           CNUMBER_CMD,    INT_CMD,    CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
     426,{D(jjNUMBER2_OP2),'/',           CNUMBER_CMD,    CNUMBER_CMD,INT_CMD, ALLOW_PLURAL | ALLOW_RING}
     427,{D(jjNUMBER2_OP2),'/',           CNUMBER_CMD,    BIGINT_CMD, CNUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
     428,{D(jjNUMBER2_OP2),'/',           CNUMBER_CMD,    CNUMBER_CMD,BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
    423429#endif
    424430,{D(jjDIVMOD_I),  INTDIV_CMD,     INT_CMD,        INT_CMD,    INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    … …  
    441447,{D(jjPOWER_BI),   '^',           BIGINT_CMD,     BIGINT_CMD, INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    442448,{D(jjPOWER_N),   '^',            NUMBER_CMD,     NUMBER_CMD, INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    443 #ifdef SINGULAR_4_1
    444 ,{D(jjNUMBER2_OP2),'^',           CNUMBER_CMD,    CNUMBER_CMD,INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    445 #endif
    446449,{D(jjPOWER_P),   '^',            POLY_CMD,       POLY_CMD,   INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    447450,{D(jjPOWER_ID),  '^',            IDEAL_CMD,      IDEAL_CMD,  INT_CMD, ALLOW_PLURAL | ALLOW_RING}
     451#ifdef SINGULAR_4_1
     452,{D(jjNUMBER2_POW),'^',           CNUMBER_CMD,    CNUMBER_CMD,INT_CMD, ALLOW_PLURAL | ALLOW_RING}
     453,{D(jjPOLY2_POW), '^',            CPOLY_CMD,      CPOLY_CMD,  INT_CMD, ALLOW_PLURAL | ALLOW_RING}
     454#endif
    448455,{D(jjLE_I),      LE,             INT_CMD,        INT_CMD,    INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    449456,{D(jjLE_BI),     LE,             INT_CMD,        BIGINT_CMD, BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
    … …  
    480487,{D(jjAND_I),     '&',            INT_CMD,        INT_CMD,    INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    481488,{D(jjOR_I),      '|',            INT_CMD,        INT_CMD,    INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    482 #ifdef SINGULAR_4_1
    483 ,{D(jjEQUAL_CR),  EQUAL_EQUAL,    INT_CMD,        CRING_CMD,  CRING_CMD, ALLOW_PLURAL | ALLOW_RING}
    484 #endif
    485489,{D(jjEQUAL_I),   EQUAL_EQUAL,    INT_CMD,        INT_CMD,    INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    486490,{D(jjEQUAL_I),   EQUAL_EQUAL,    INT_CMD,        RING_CMD,   INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    … …  
    497501#ifdef SINGULAR_4_1
    498502,{D(jjCOMPARE_BIM),EQUAL_EQUAL,   INT_CMD,        CMATRIX_CMD, CMATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
     503,{D(jjEQUAL_CR),  EQUAL_EQUAL,    INT_CMD,        CRING_CMD,  CRING_CMD, ALLOW_PLURAL | ALLOW_RING}
    499504#endif
    500505,{D(jjEQUAL_Ma),  EQUAL_EQUAL,    INT_CMD,        MATRIX_CMD, MATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
    … …  
    717722,{D(jjBRACK_Im),       '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INT_CMD, ALLOW_PLURAL |ALLOW_RING}
    718723,{D(jjBRACK_Bim),      '[',        BIGINT_CMD, BIGINTMAT_CMD, INT_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
    719 #ifdef SINGULAR_4_1
    720 ,{D(jjBRACK_Bim),      '[',        CNUMBER_CMD, CMATRIX_CMD, INT_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
    721 #endif
    722724,{D(jjBRACK_Ma_I_IV),  '[',        INT_CMD,    INTMAT_CMD, INT_CMD,    INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
    723725,{D(jjBRACK_Ma_I_IV),  '[',        BIGINT_CMD, BIGINTMAT_CMD, INT_CMD,    INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
    … …  
    730732,{D(jjBRACK_Ma_IV_I),  '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
    731733,{D(jjBRACK_Ma_IV_IV), '[',        POLY_CMD,   MATRIX_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
     734#ifdef SINGULAR_4_1
     735,{D(jjBRACK_Bim),      '[',        CNUMBER_CMD, CMATRIX_CMD, INT_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
     736#endif
    732737,{D(jjPROC3),          '(',        ANY_TYPE,   PROC_CMD,   DEF_CMD,    DEF_CMD, ALLOW_PLURAL |ALLOW_RING}
    733738,{D(atATTRIB3),        ATTRIB_CMD, NONE,       IDHDL,      STRING_CMD, DEF_CMD, ALLOW_PLURAL |ALLOW_RING}
    … …  
    922927  { "Matrix",     0, CMATRIX_CMD ,       ROOT_DECL_LIST},
    923928  { "Number",     0, CNUMBER_CMD ,       ROOT_DECL_LIST},
     929  { "parent",     0, PARENT_CMD ,        CMD_1},
     930  { "Poly",       0, CPOLY_CMD ,         ROOT_DECL_LIST},
    924931#endif
    925932  { "coef",        0, COEF_CMD ,          CMD_M},
    … …  
    11901197   { INT_CMD,         NUMBER_CMD,     D(iiI2N) , NULL_VAL },
    11911198   { BIGINT_CMD,      NUMBER_CMD,     D(iiBI2N) , NULL_VAL },
    1192 #ifdef SINGULAR_4_1
    1193    { INT_CMD,         CNUMBER_CMD,    D(iiI2NN) , NULL_VAL },
    1194    { BIGINT_CMD,      CNUMBER_CMD,    D(iiBI2NN) , NULL_VAL },
    1195    { CNUMBER_CMD,     NUMBER_CMD,     D(iiNN2N) , NULL_VAL },
    1196    { CNUMBER_CMD,     POLY_CMD,       D(iiNN2P) , NULL_VAL },
    1197 #endif
    11981199//  int -> poly
    11991200   { INT_CMD,         POLY_CMD,       D(iiI2P) , NULL_VAL },
    … …  
    12521253// list -> resolution
    12531254   { LIST_CMD,        RESOLUTION_CMD, NULL_VAL ,  D(iiL2R) },
     1255#ifdef SINGULAR_4_1
     1256   { INT_CMD,         CNUMBER_CMD,    D(iiI2NN) , NULL_VAL },
     1257   { BIGINT_CMD,      CNUMBER_CMD,    D(iiBI2NN) , NULL_VAL },
     1258   { CNUMBER_CMD,     NUMBER_CMD,     D(iiNN2N) , NULL_VAL },
     1259   { CNUMBER_CMD,     POLY_CMD,       D(iiNN2P) , NULL_VAL },
     1260   { INT_CMD,         CPOLY_CMD,      D(iiI2CP), NULL_VAL },
     1261   { BIGINT_CMD,      CPOLY_CMD,      D(iiBI2CP), NULL_VAL },
     1262//   { NUMBER_CMD,      CPOLY_CMD,      D(iiN2CP), NULL_VAL },
     1263   { POLY_CMD,        CPOLY_CMD,      D(iiP2CP), NULL_VAL },
     1264#endif
    12541265//  end of list
    12551266   { 0,               0,              NULL_VAL , NULL_VAL }
    … …  
    12901301#ifdef SINGULAR_4_1
    12911302,{D(jiA_NUMBER2),  CNUMBER_CMD,    CNUMBER_CMD }
     1303//,{D(jiA_NUMBER2_I),CNUMBER_CMD,    INT_CMD }
     1304//,{D(jiA_NUMBER2_N),CNUMBER_CMD,    NUMBER_CMD }
     1305,{D(jiA_POLY2),    CPOLY_CMD,      CPOLY_CMD }
     1306//,{D(jiA_POLY2_P),  CPOLY_CMD,      POLY_CMD }
    12921307#endif
    12931308,{D(jiA_BIGINT),   BIGINT_CMD,     BIGINT_CMD }

  • Singular/tok.h

    r7e2307 rc7ae4d  
    4646  CMATRIX_CMD,
    4747  CNUMBER_CMD,
     48  CPOLY_CMD,
    4849  CLOSE_CMD,
    4950  COEFFS_CMD,
    … …  
    147148  PACKAGE_CMD,
    148149  PARDEG_CMD,
     150  PARENT_CMD,
    149151  PARSTR_CMD,
    150152  PFAC_CMD,

  • libpolys/coeffs/numbers.cc

    r7e2307 rc7ae4d  
    5555{
    5656  char *s=(char *)omAlloc(11);snprintf(s,11,"Coeffs(%d)",r->type);
     57  return s;
     58}
     59static char* ndCoeffName(const coeffs r)
     60{
     61  static char s[20];
     62  snprintf(s,11,"Coeffs(%d)",r->type);
    5763  return s;
    5864}
    … …  
    151157static number ndGetNumerator(number &a,const coeffs r) { return r->cfCopy(a,r); }
    152158static int    ndSize(number a, const coeffs r)         { return (int)r->cfIsZero(a,r)==FALSE; }
    153 static char * ndCoeffName(const coeffs r)              { return r->cfCoeffString(r); }
    154159
    155160static void ndClearContent(ICoeffsEnumerator& numberCollectionEnumerator, number& c, const coeffs r)
    … …  
    351356    n->cfAnn = ndAnn;
    352357    n->cfCoeffString = ndCoeffString; // should alway be changed!
     358    n->cfCoeffName = ndCoeffName; // should alway be changed!
    353359    n->cfInpMult=ndInpMult;
    354360    n->cfInpAdd=ndInpAdd;
    … …  
    362368    n->cfMPZ = ndMPZ;
    363369    n->cfPower = ndPower;
    364     n->cfCoeffName = ndCoeffName;
    365370
    366371    n->cfKillChar = ndKillChar; /* dummy */
    … …  
    419424    assume(n->cfSetChar!=NULL);
    420425    assume(n->cfCoeffString!=ndCoeffString);
     426    assume(n->cfCoeffName!=ndCoeffName);
    421427    assume(n->cfMult!=NULL);
    422428    assume(n->cfSub!=NULL);

  • libpolys/polys/ext_fields/algext.cc

    r7e2307 rc7ae4d  
    13611361}
    13621362
     1363char* naCoeffName(const coeffs r) // currently also for tranext.
     1364{
     1365  const char* const* p=n_ParameterNames(r);
     1366  int l=0;
     1367  int i;
     1368  for(i=0; i<n_NumberOfParameters(r);i++)
     1369  {
     1370    l+=(strlen(p[i])+1);
     1371  }
     1372  static char s[200];
     1373  s[0]='\0';
     1374  snprintf(s,10+1,"%d",r->ch); /* Fp(a) or Q(a) */
     1375  char tt[2];
     1376  tt[0]=',';
     1377  tt[1]='\0';
     1378  for(i=0; i<n_NumberOfParameters(r);i++)
     1379  {
     1380    strcat(s,tt);
     1381    strcat(s,p[i]);
     1382  }
     1383  return s;
     1384}
     1385
    13631386number  naChineseRemainder(number *x, number *q,int rl, BOOLEAN /*sym*/,CFArray &inv_cache,const coeffs cf)
    13641387{
    … …  
    14141437  #endif
    14151438
    1416   cf->cfCoeffString = naCoeffString;
     1439  cf->cfCoeffString  = naCoeffString;
     1440  cf->cfCoeffName    = naCoeffName;
    14171441
    14181442  cf->cfGreaterZero  = naGreaterZero;
    … …  
    15861610}
    15871611
    1588 char* n2pCoeffString(const coeffs r) // currently also for tranext.
    1589 {
    1590   const char* const* p=n_ParameterNames(r);
     1612char* n2pCoeffString(const coeffs cf)
     1613{
     1614  const char* const* p=n_ParameterNames(cf);
    15911615  int l=0;
    15921616  int i;
    1593   for(i=0; i<n_NumberOfParameters(r);i++)
     1617  for(i=0; i<rVar(n2pRing);i++)
    15941618  {
    15951619    l+=(strlen(p[i])+1);
    15961620  }
    1597   char *s=(char *)omAlloc(l+10+1);
     1621  char *cf_s=nCoeffString(n2pRing->cf);
     1622  char *s=(char *)omAlloc(l+5+strlen(cf_s));
    15981623  s[0]='\0';
    1599   snprintf(s,10+1,"%d",r->ch); /* Fp(a) or Q(a) */
     1624  snprintf(s,strlen(cf_s)+2,"%s",cf_s);
     1625  omFree(cf_s);
    16001626  char tt[2];
     1627  tt[0]='[';
     1628  tt[1]='\0';
     1629  strcat(s,tt);
    16011630  tt[0]=',';
     1631  for(i=0; i<rVar(n2pRing);i++)
     1632  {
     1633    strcat(s,p[i]);
     1634    if (i+1!=rVar(n2pRing)) strcat(s,tt);
     1635    else { tt[0]=']'; strcat(s,tt); }
     1636  }
     1637  return s;
     1638}
     1639
     1640char* n2pCoeffName(const coeffs cf)
     1641{
     1642  const char* const* p=n_ParameterNames(cf);
     1643  int l=0;
     1644  int i;
     1645  for(i=0; i<rVar(n2pRing);i++)
     1646  {
     1647    l+=(strlen(p[i])+1);
     1648  }
     1649  char *cf_s=nCoeffString(n2pRing->cf);
     1650  char s[200];
     1651  s[0]='\0';
     1652  snprintf(s,strlen(cf_s)+2,"%s",cf_s);
     1653  omFree(cf_s);
     1654  char tt[2];
     1655  tt[0]='[';
    16021656  tt[1]='\0';
    1603   for(i=0; i<n_NumberOfParameters(r);i++)
    1604   {
    1605     strcat(s,tt);
     1657  strcat(s,tt);
     1658  tt[0]=',';
     1659  for(i=0; i<rVar(n2pRing);i++)
     1660  {
    16061661    strcat(s,p[i]);
     1662    if (i+1!=rVar(n2pRing)) strcat(s,tt);
     1663    else { tt[0]=']'; strcat(s,tt); }
    16071664  }
    16081665  return s;
    … …  
    16591716  cf->is_domain=TRUE;
    16601717
    1661   cf->cfCoeffString = n2pCoeffString;
     1718  cf->cfCoeffString  = n2pCoeffString;
     1719  cf->cfCoeffName    = n2pCoeffName;
    16621720
    16631721  cf->cfGreaterZero  = naGreaterZero;

  • old_modgen/modgen/misc.cc

    r7e2307 rc7ae4d  
    3939
    4040typedef struct {
    41   unsigned long nCmdUsed;      /**< number of commands used */
    42   unsigned long nCmdAllocated; /**< number of commands-slots allocated */
    43   unsigned long nLastIdentifier;
     41  unsigned  nCmdUsed;          /**< number of commands used */
     42  unsigned nCmdAllocated;      /**< number of commands-slots allocated */
     43  unsigned nLastIdentifier;
    4444  cmdnames *sCmds;             /**< array of existing commands */
    4545
Note: See TracChangeset for help on using the changeset viewer.