Changeset bc36a0 in git


Ignore:
Timestamp:
Oct 18, 2004, 8:57:46 PM (20 years ago)
Author:
Viktor Levandovskyy <levandov@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
33e05d5d4685ba91116795ac35796c03917339bd
Parents:
b39bc1f12466f3f82f8543a8e01764c4e63c6c15
Message:
*levandov: new commands oppose, opposite and envelope are available in interpreter


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

Legend:

Unmodified
Added
Removed

  • Singular/extra.cc

    rb39bc1f rbc36a0  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: extra.cc,v 1.213 2004-10-11 09:06:52 bricken Exp $ */
     4/* $Id: extra.cc,v 1.214 2004-10-18 18:57:43 levandov Exp $ */
    55/*
    66* ABSTRACT: general interface to internals of Singular ("system" command)
    … …  
    955955    }
    956956    else
     957/*==================== opp ==================================*/
     958    if (strcmp(sys_cmd, "opp")==0)
     959    {
     960      if ((h!=NULL) && (h->Typ()==RING_CMD))
     961      {
     962        ring r=(ring)h->Data();
     963        res->data=rOpposite(r);
     964        res->rtyp=RING_CMD;
     965        return FALSE;
     966      }
     967      else
     968      {
     969        WerrorS("`system(\"opp\",<ring>)` expected");
     970        return TRUE;
     971      }
     972    }
     973    else
     974/*==================== env ==================================*/
     975    if (strcmp(sys_cmd, "env")==0)
     976    {
     977      if ((h!=NULL) && (h->Typ()==RING_CMD))
     978      {
     979        ring r = (ring)h->Data();
     980        res->data = rEnvelope(r);
     981        res->rtyp = RING_CMD;
     982        return FALSE;
     983      }
     984      else
     985      {
     986        WerrorS("`system(\"env\",<ring>)` expected");
     987        return TRUE;
     988      }
     989    }
     990    else
     991/*==================== oppose ==================================*/
     992    if (strcmp(sys_cmd, "oppose")==0)
     993    {
     994      ring Rop;
     995      if ((h!=NULL) && (h->Typ()==RING_CMD))
     996      {
     997        Rop = (ring)h->Data();
     998        h   = h->next;
     999      }
     1000      if ((h!=NULL))
     1001      {
     1002        idhdl w;
     1003        if ((w=Rop->idroot->get(h->Name(),myynest))!=NULL)
     1004        {
     1005          poly p = (poly)IDDATA(w);
     1006          res->data = pOppose(Rop,p);
     1007          res->rtyp = POLY_CMD;
     1008          return FALSE;
     1009        }
     1010       }
     1011      else
     1012      {
     1013        WerrorS("`system(\"oppose\",<ring>,<poly>)` expected");
     1014        return TRUE;
     1015      }
     1016    }
     1017    else
    9571018#endif
    9581019/*================= Extended system call ========================*/
    … …  
    16721733    }
    16731734    else
    1674 /*==================== opp ==================================*/
    1675     if (strcmp(sys_cmd, "opp")==0)
    1676     {
    1677       if ((h!=NULL) && (h->Typ()==RING_CMD))
    1678       {
    1679         ring r=(ring)h->Data();
    1680         res->data=rOpposite(r);
    1681         res->rtyp=RING_CMD;
    1682         return FALSE;
    1683       }
    1684       else
    1685       {
    1686         WerrorS("`system(\"opp\",<ring>)` expected");
    1687         return TRUE;
    1688       }
    1689     }
    1690     else
    1691 /*==================== env ==================================*/
    1692     if (strcmp(sys_cmd, "env")==0)
    1693     {
    1694       if ((h!=NULL) && (h->Typ()==RING_CMD))
    1695       {
    1696         ring r=(ring)h->Data();
    1697         res->data=rEnvelope(r);
    1698         res->rtyp=RING_CMD;
    1699         return FALSE;
    1700       }
    1701       else
    1702       {
    1703         WerrorS("`system(\"env\",<ring>)` expected");
    1704         return TRUE;
    1705       }
    1706     }
    1707     else
    1708 /*==================== oppose ==================================*/
    1709     if (strcmp(sys_cmd, "oppose")==0)
    1710     {
    1711       ring Rop;
    1712       if ((h!=NULL) && (h->Typ()==RING_CMD))
    1713       {
    1714         Rop =(ring)h->Data();
    1715         h=h->next;
    1716       }
    1717       if ((h!=NULL))
    1718       {
    1719         idhdl w;
    1720         if ((w=Rop->idroot->get(h->Name(),myynest))!=NULL)
    1721         {
    1722           poly p = (poly)IDDATA(w);
    1723           res->data = p_Oppose(Rop,p);
    1724           res->rtyp = POLY_CMD;
    1725           return FALSE;
    1726         }
    1727        }
    1728       else
    1729       {
    1730         WerrorS("`system(\"oppose\",<ring>,<poly>)` expected");
    1731         return TRUE;
    1732       }
    1733     }
    1734     else
    17351735/*==================== Error =================*/
    17361736      Werror( "system(\"%s\",...) %s", sys_cmd, feNotImplemented );

  • Singular/iparith.cc

    rb39bc1f rbc36a0  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: iparith.cc,v 1.328 2004-10-05 13:00:29 Singular Exp $ */
     4/* $Id: iparith.cc,v 1.329 2004-10-18 18:57:44 levandov Exp $ */
    55
    66/*
    … …  
    187187  { "eliminate",   0, ELIMINATION_CMD,    CMD_23},
    188188  { "else",        0, ELSE_CMD ,          ELSE_CMD},
     189  #ifdef HAVE_PLURAL
     190  { "envelope",    0, ENVELOPE_CMD ,       CMD_1},
     191  #endif
    189192  { "eval",        0, EVAL ,              EVAL},
    190193  { "example",     0, EXAMPLE_CMD ,       EXAMPLE_CMD},
    … …  
    277280  { "nvars",       0, NVARS_CMD ,         CMD_1},
    278281  { "open",        0, OPEN_CMD ,          CMD_1},
     282  #ifdef HAVE_PLURAL
     283  { "oppose",      0, OPPOSE_CMD ,        CMD_2},
     284  { "opposite",    0, OPPOSITE_CMD ,      CMD_1},
     285  #endif
    279286  { "option",      0, OPTION_CMD ,        CMD_M},
    280287  { "or",          0, '|' ,               LOGIC_OP},
    … …  
    20282035}
    20292036
    2030 static BOOLEAN jjTWOSTD(leftv res, leftv a)
    2031 {
    2032   if (rIsPluralRing(currRing))  res->data=(ideal)twostd((ideal)a->Data());
    2033   else  res->data=(ideal)a->Data();
    2034   setFlag(res,FLAG_STD);
    2035   setFlag(res,FLAG_TWOSTD);
    2036   return FALSE;
    2037 }
    2038 
    2039 #endif
     2037static BOOLEAN jjOPPOSE(leftv res, leftv a, leftv b)
     2038{
     2039  /* int, number, poly, vector, intvec  */
     2040  /* if (rIsPluralRing(currRing)) -- skipped! */
     2041  ring  r = (ring)a->Data();
     2042  if (r == currRing)
     2043  {
     2044    res->data = b->Data();
     2045    res->rtyp  = b->rtyp;
     2046    return FALSE;
     2047  }
     2048  if (!rIsLikeOpposite(currRing, r))
     2049  {
     2050    Werror("%s is not an opposite ring to current ring",a->Fullname());
     2051    return TRUE;
     2052  }
     2053  idhdl w;
     2054  if( ((w=r->idroot->get(b->Name(),myynest))!=NULL) && (b->e==NULL))
     2055  {
     2056    int argtype = IDTYP(w);
     2057    switch (argtype)
     2058    {
     2059    case NUMBER_CMD:
     2060      {
     2061        /* since basefields are equal, we can apply nCopy */
     2062        res->data = nCopy((number)IDDATA(w));
     2063        res->rtyp = argtype;
     2064        break;
     2065      }
     2066    case POLY_CMD:
     2067    case VECTOR_CMD:
     2068      {
     2069        poly    q = (poly)IDDATA(w);
     2070        res->data = pOppose(r,q);
     2071        res->rtyp = argtype;
     2072        break;
     2073      }
     2074    case IDEAL_CMD:
     2075    case MODUL_CMD: 
     2076      {
     2077        ideal   Q = (ideal)IDDATA(w);
     2078        res->data = idOppose(r,Q);
     2079        res->rtyp = argtype;
     2080        break;
     2081      }
     2082    default: 
     2083      {       
     2084        Werror("unsupported type in oppose");
     2085        return TRUE;
     2086      }
     2087    }
     2088  }
     2089  else
     2090  {
     2091    Werror("identifier %s not found in %s",b->Fullname(),a->Fullname());
     2092    return TRUE;
     2093  }
     2094  return FALSE;
     2095}
     2096
     2097// static BOOLEAN jjOPPOSE_ideal(leftv res, leftv a, leftv b)
     2098// {
     2099//   /* int, number, poly, vector, intvec  */
     2100//   ring    A = (ring)a->Data();
     2101//   ideal   Q = (ideal)b->Data();
     2102//   // if (rIsPluralRing(currRing))
     2103//   {
     2104//     res->data = idOppose(A,Q);
     2105//   }
     2106//   return FALSE;
     2107// }
     2108
     2109// static BOOLEAN jjOPPOSE(leftv res, leftv a, leftv b)
     2110// {
     2111//   if (rIsPluralRing(currRing))
     2112//   {
     2113//     int btype = (int)b->rtyp;
     2114//     ring    A = (ring)a->Data();
     2115//     switch (btype)
     2116//     {
     2117//     case INT_CMD:
     2118//     case POLY_CMD:
     2119//     case VECTOR_CMD:
     2120//     case INTVEC_CMD:
     2121//     case NUMBER_CMD:
     2122//       {
     2123//      poly    q = (poly)b->Data();
     2124//      res->data = pOppose(A,q);
     2125//      res->rtyp = b->rtyp;
     2126//       }
     2127//     case IDEAL_CMD:   
     2128//     case MATRIX_CMD:
     2129//     case MODUL_CMD: 
     2130//     case INTMAT_CMD:
     2131//       {
     2132//      ideal   Q = (ideal)b->Data();
     2133//      res->data = idOppose(A,Q);
     2134//      res->rtyp = b->rtyp;
     2135//       }
     2136//       // TODO   case RESOLUTION_CMD:
     2137//     default:       return FALSE;
     2138//     }
     2139//   }
     2140//   else res->data=NULL;
     2141//   return FALSE;
     2142// }
     2143#endif /* HAVE_PLURAL */
    20402144
    20412145static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
    … …  
    25512655#ifdef HAVE_PLURAL
    25522656,{jjBRACKET,   BRACKET_CMD,    POLY_CMD,       POLY_CMD,   POLY_CMD ALLOW_PLURAL}
     2657,{jjOPPOSE,    OPPOSE_CMD,     ANY_TYPE/*set by p*/, RING_CMD,   POLY_CMD ALLOW_PLURAL}
     2658,{jjOPPOSE,    OPPOSE_CMD,     ANY_TYPE/*set by p*/, RING_CMD,   DEF_CMD ALLOW_PLURAL}
     2659// ,{jjOPPOSE_poly,    OPPOSE_CMD,     NUMBER_CMD,     RING_CMD,   NUMBER_CMD ALLOW_PLURAL}
     2660// ,{jjOPPOSE_poly,    OPPOSE_CMD,     POLY_CMD,       RING_CMD,   POLY_CMD ALLOW_PLURAL}
     2661// ,{jjOPPOSE_poly,    OPPOSE_CMD,     VECTOR_CMD,     RING_CMD,   VECTOR_CMD ALLOW_PLURAL}
     2662// ,{jjOPPOSE_ideal,   OPPOSE_CMD,     IDEAL_CMD,      RING_CMD,   IDEAL_CMD ALLOW_PLURAL}
     2663// ,{jjOPPOSE_ideal,   OPPOSE_CMD,     MODUL_CMD,      RING_CMD,   MODUL_CMD  ALLOW_PLURAL}
     2664// ,{jjOPPOSE_ideal,   OPPOSE_CMD,     MATRIX_CMD,     RING_CMD,   MATRIX_CMD ALLOW_PLURAL}
    25532665#endif
    25542666,{jjCOEF,      COEF_CMD,       MATRIX_CMD,     POLY_CMD,   POLY_CMD ALLOW_PLURAL}
    … …  
    35263638  return FALSE;
    35273639}
     3640
     3641#ifdef HAVE_PLURAL
     3642
     3643static BOOLEAN jjOPPOSITE(leftv res, leftv a)
     3644{
     3645  ring    r = (ring)a->Data();
     3646  if (rIsPluralRing(currRing))
     3647  { 
     3648    res->data = rOpposite(r);
     3649  }
     3650  else res->data = rCopy(r);
     3651  return FALSE;
     3652}
     3653
     3654static BOOLEAN jjENVELOPE(leftv res, leftv a)
     3655{
     3656  ring    r = (ring)a->Data();
     3657  if (rIsPluralRing(currRing))
     3658  { 
     3659    //    ideal   i;
     3660//     if (a->rtyp == QRING_CMD)
     3661//     {
     3662//       i = r->qideal;
     3663//       r->qideal = NULL;
     3664//     }
     3665    ring s = rEnvelope(r);
     3666//     if (a->rtyp == QRING_CMD)
     3667//     {
     3668//       ideal is  = idOppose(r,i); /* twostd? */
     3669//       is        = idAdd(is,i);
     3670//       s->qideal = i;
     3671//     }
     3672    res->data = s;
     3673  }
     3674  else  res->data = rCopy(r);
     3675  return FALSE;
     3676}
     3677
     3678static BOOLEAN jjTWOSTD(leftv res, leftv a)
     3679{
     3680  if (rIsPluralRing(currRing))  res->data=(ideal)twostd((ideal)a->Data());
     3681  else  res->data=(ideal)a->Data();
     3682  setFlag(res,FLAG_STD);
     3683  setFlag(res,FLAG_TWOSTD);
     3684  return FALSE;
     3685}
     3686#endif
     3687
    35283688static BOOLEAN jjTYPEOF(leftv res, leftv v)
    35293689{
    … …  
    40734233,{jjSYZYGY,     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD      ALLOW_PLURAL}
    40744234#ifdef HAVE_PLURAL
     4235,{jjENVELOPE,   ENVELOPE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
     4236,{jjOPPOSITE,   OPPOSITE_CMD,    RING_CMD,       RING_CMD       ALLOW_PLURAL}
    40754237,{jjTWOSTD,     TWOSTD_CMD,      IDEAL_CMD,      IDEAL_CMD      ALLOW_PLURAL}
    40764238#endif

  • Singular/tok.h

    rb39bc1f rbc36a0  
    77* ABSTRACT: tokens, types for interpreter; general macros
    88*/
    9 /* $Id: tok.h,v 1.58 2004-04-23 13:52:00 Singular Exp $ */
     9/* $Id: tok.h,v 1.59 2004-10-18 18:57:46 levandov Exp $ */
    1010
    1111#ifndef MYYSTYPE
    … …  
    7575  DUMP_CMD,
    7676  END_GRAMMAR,
     77  ENVELOPE_CMD,
    7778  ERROR_CMD,
    7879  EXECUTE_CMD,
    … …  
    114115  NVARS_CMD,
    115116  OPEN_CMD,
     117  OPPOSE_CMD,
     118  OPPOSITE_CMD,
    116119  OPTION_CMD,
    117120  ORDSTR_CMD,
Note: See TracChangeset for help on using the changeset viewer.