Changeset feaddd in git


Ignore:
Timestamp:
Apr 10, 1997, 3:08:40 PM (27 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'c7af8613769b29c741d6c338945669719f1fc4f8')
Children:
91882f721049d2a9b2c3a5acda3db060a136600a
Parents:
6ae4f5a3079ec71b3f884bb50eb22a3919c9f9fb
Message:
Thu Apr 10 11:59:41 1997  Olaf Bachmann
<obachman@ratchwum.mathematik.uni-kl.de (Olaf Bachmann)>

	* remote quit is now arranged using MP_CopMpQuit

	* Updated mpsr_* files for new naming convention of MP v:1.1.2


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

Legend:

Unmodified
Added
Removed
  • Singular/ChangeLog

    r6ae4f5 rfeaddd  
     1Thu Apr 10 11:59:41 1997  Olaf Bachmann  <obachman@ratchwum.mathematik.uni-kl.de (Olaf Bachmann)>
     2
     3        * remote quit is now arranged using MP_CopMpQuit
     4
     5        * Updated mpsr_* files for new naming convention of MP v:1.1.2
     6
     7Tue Apr  8 10:43:48 1997  Olaf Bachmann  <obachman@ratchwum.mathematik.uni-kl.de (Olaf Bachmann)>
     8
     9        * Reimplemented link structures. Cleaned it up. Introduced assignment
     10link = link. Fixed some bugs in asciidump. Made proc's work for MP links.
     11
    112Sat Mar 29 16:01:39 1997  Olaf Bachmann  <obachman@ratchwum.mathematik.uni-kl.de (Olaf Bachmann)>
    213
  • Singular/mpsr.h

    r6ae4f5 rfeaddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mpsr.h,v 1.4 1997-04-09 12:20:01 Singular Exp $ */
     4/* $Id: mpsr.h,v 1.5 1997-04-10 13:08:35 obachman Exp $ */
    55/***************************************************************
    66 *
     
    121121#define MP_AnnotSingularGalois  1
    122122// String used to indicate the end of a communication
    123 #define MPSR_QUIT_STRING    "MPSR::Quit"
    124 #define MPSR_DEFAULT_DUMP_FILE "mpsr_dump.mp"
     123#define MPSR_QUIT_STRING    "MPtcp:quit"
    125124
    126125// some handy Macros for error handlings
  • Singular/mpsr_Get.cc

    r6ae4f5 rfeaddd  
    33****************************************/
    44
    5 /* $Id: mpsr_Get.cc,v 1.7 1997-04-08 08:43:24 obachman Exp $ */
     5/* $Id: mpsr_Get.cc,v 1.8 1997-04-10 13:08:36 obachman Exp $ */
    66/***************************************************************
    77 *
     
    3535#include "MP_BasicDict.h"
    3636#include "MP_ProtoDict.h"
     37#include "MP_MpDict.h"
    3738
    3839#include <limits.h>
     
    8283  MPT_Tree_pt tree = MPT_GetProtoTypespec(node);
    8384  return tree != NULL && NodeCheck(tree->node, MP_CommonMetaType,
    84                                    MP_ProtoDict, MP_CmtProtoSint32);
     85                                   MP_ProtoDict, MP_CmtProtoIMP_Sint32);
    8586}
    8687
     
    9192  MPT_Tree_pt tree = MPT_GetProtoTypespec(node);
    9293  return tree != NULL && NodeCheck(tree->node, MP_CommonMetaType,
    93                                    MP_ProtoDict, MP_CmtProtoSint32);
     94                                   MP_ProtoDict, MP_CmtProtoIMP_Sint32);
    9495}
    9596
     
    160161}
    161162
     163inline BOOLEAN IsQuitNode(MPT_Node_pt node)
     164{
     165  return NodeCheck(node, MP_MpDict, MP_CopMpEndSession);
     166}
     167
    162168//
    163169// Init*Leftv functions
     
    279285}
    280286
     287inline mpsr_Status_t GetQuitLeftv(mpsr_leftv mlv)
     288{
     289  mlv->lv = mpsr_InitLeftv(STRING_CMD, (void *) mstrdup(MPSR_QUIT_STRING));
     290  return mpsr_Success;
     291}
     292
    281293/***************************************************************
    282294 *
     
    293305  mlv1.r = NULL;
    294306
    295   MP_SkipMsg(link);
    296  
    297   if (! MP_TestEofMsg(link))
     307  status = (MP_InitMsg(link) == MP_Success ? mpsr_Success : mpsr_MP_Failure);
     308 
     309  if (status == mpsr_Success && ! MP_TestEofMsg(link))
    298310    status = mpsr_GetLeftv(link, &mlv, 0);
    299311  else
    300312  {
    301313    lv = mpsr_InitLeftv(NONE, NULL);
    302     return mpsr_Success;
    303   }
    304  
     314    return status;
     315  }
    305316
    306317  // handle more than one leftv (ie. chains of leftv's)
     
    329340    lv = mlv.lv;
    330341  }
    331   else lv = NULL;
     342  else lv = mpsr_InitLeftv(NONE, NULL);
    332343 
    333344  return status;
     
    429440  else if (IsMatrixNode(node, mlv->r))
    430441    return GetMatrixLeftv(link, node, mlv);
     442  else if (IsQuitNode(node))
     443    return GetQuitLeftv(mlv);
    431444  // Map
    432445  else
     
    754767}
    755768
     769 
    756770/***************************************************************
    757771 *
  • Singular/mpsr_GetPoly.cc

    r6ae4f5 rfeaddd  
    33****************************************/
    44
    5 /* $Id: mpsr_GetPoly.cc,v 1.4 1997-04-02 15:07:39 Singular Exp $ */
     5/* $Id: mpsr_GetPoly.cc,v 1.5 1997-04-10 13:08:37 obachman Exp $ */
    66
    77/***************************************************************
     
    1616
    1717#ifdef HAVE_MPSR
     18#include "limits.h"
    1819
    1920#include "mpsr_Get.h"
     
    3839#include "MP_ProtoDict.h"
    3940
    40 #include "limits.h"
    4141
    4242#ifdef PARI_BIGINT_TEST
     
    176176  MP_Boolean_t      req = 0;
    177177 
    178   mp_failr(IMP_GetNodeHeader(link,&node,&cvalue,&dict, &num_annots,
     178  mp_failr(IMP_GetNodeHeader(link,&node,&dict, &cvalue, &num_annots,
    179179                             &num_child));
    180180
     
    226226  MP_Boolean_t      req;
    227227
    228   mp_failr(IMP_GetNodeHeader(link,&node,&cvalue,&dict, &num_annots, &num_child));
     228  mp_failr(IMP_GetNodeHeader(link,&node,&dict, &cvalue, &num_annots,
     229                             &num_child));
    229230
    230231  // start with the most frequent cases
     
    630631 
    631632  node = val->node;
    632   falser(NodeCheck(node, MP_CommonMetaType, MP_ProtoDict, MP_CmtProtoSint32));
     633  falser(NodeCheck(node, MP_CommonMetaType, MP_ProtoDict, MP_CmtProtoIMP_Sint32));
    633634
    634635  // consider the first arg -- which specify the coeffs
     
    638639  {
    639640    // char 0
    640     if (MP_COMMON_T(node->nvalue) == MP_CmtNumberRational &&
     641    if (MP_COMMON_T(node->nvalue) == MP_CmtNumberMP_Rational &&
    641642        node->dict == MP_NumberDict)
    642643    {
     
    644645      // Hmm ... we should check for the normalized annot
    645646    }
    646     else if (MP_COMMON_T(node->nvalue) == MP_CmtProtoUint32 &&
     647    else if (MP_COMMON_T(node->nvalue) == MP_CmtProtoIMP_Uint32 &&
    647648             node->dict == MP_ProtoDict &&
    648649             (annot = MPT_FindAnnot(node,MP_NumberDict,MP_AnnotNumberModulos))
     
    667668      }
    668669    }
    669     else if (MP_COMMON_T(node->nvalue) == MP_CmtProtoReal32 &&
     670    else if (MP_COMMON_T(node->nvalue) == MP_CmtProtoIMP_Real32 &&
    670671             node->dict == MP_ProtoDict)
    671672    {
     
    727728      if (val != NULL &&
    728729          NodeCheck(val->node, MP_CommonMetaType, MP_ProtoDict,
    729                     MP_CmtProtoIdentifier))
     730                    MP_CmtProtoIMP_Identifier))
    730731      {
    731732        MPT_Arg_pt arg_pt = annot->value->args;       
     
    886887  if (annot2 == NULL ||
    887888      ! NodeCheck(annot2->value->node, MP_CommonMetaType, MP_ProtoDict,
    888                  MP_CmtProtoSint32))
     889                 MP_CmtProtoIMP_Sint32))
    889890    return mpsr_Failure;
    890891
  • Singular/mpsr_Put.cc

    r6ae4f5 rfeaddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mpsr_Put.cc,v 1.5 1997-04-02 15:07:40 Singular Exp $ */
     4/* $Id: mpsr_Put.cc,v 1.6 1997-04-10 13:08:37 obachman Exp $ */
    55
    66
     
    101101        return mpsr_PutDefLeftv(link, v);
    102102
    103     // now potentially ring-dependent types
     103        // now potentially ring-dependent types
    104104      case LIST_CMD:
    105105        return mpsr_PutListLeftv(link,v, cring);
     
    147147  // Put the Vector Operator
    148148  mp_failr(MP_PutCommonOperatorPacket(link,
    149                                    MP_CopMatrixDenseVector,
    150                                    MP_MatrixDict,
    151                                    1,
    152                                    length));
     149                                      MP_MatrixDict,
     150                                      MP_CopMatrixDenseVector,
     151                                      1,
     152                                      length));
    153153  // Prototype Annot
    154154  mp_failr(MP_PutAnnotationPacket(link,
     155                                  MP_ProtoDict,
    155156                                  MP_AnnotProtoPrototype,
    156                                   MP_ProtoDict,
    157                                   MP_AnnotReqValNode));
    158   // Together with the CommonMetaPacket specifying that each element of
     157                                  MP_AnnotReqValNode));
     158  // Together with the CommonMetaTypePacket specifying that each element of
    159159  // the vector is an Sint32
    160   mp_failr(MP_PutCommonMetaPacket(link, MP_CmtProtoSint32,
    161                                   MP_ProtoDict, 0));
     160  mp_failr(MP_PutCommonMetaTypePacket(link,
     161                                      MP_ProtoDict,
     162                                      MP_CmtProtoIMP_Sint32,
     163                                      0));
    162164 
    163165  // Now we finally put the data
     
    172174  // First, we put the Matrix operator
    173175  mp_failr(MP_PutCommonOperatorPacket(link,
    174                                    MP_CopMatrixDenseMatrix,
    175                                    MP_MatrixDict,
    176                                    2,
    177                                    length));
     176                                      MP_MatrixDict,
     177                                      MP_CopMatrixDenseMatrix,
     178                                      2,
     179                                      length));
    178180  // Put the two annotations
    179181  // First, the prototype annot
    180182  mp_failr(MP_PutAnnotationPacket(link,
    181                                MP_AnnotProtoPrototype,
    182                                MP_ProtoDict,
    183                                MP_AnnotReqValNode));
    184   mp_failr(MP_PutCommonMetaPacket(link, MP_CmtProtoSint32, MP_ProtoDict, 0));
     183                                  MP_ProtoDict,
     184                                  MP_AnnotProtoPrototype,
     185                                  MP_AnnotReqValNode));
     186  mp_failr(MP_PutCommonMetaTypePacket(link,
     187                                  MP_ProtoDict,
     188                                  MP_CmtProtoIMP_Sint32,
     189                                  0));
    185190  // And second, the dimension annot
    186191  mp_failr(MP_PutAnnotationPacket(link,
    187                                MP_AnnotMatrixDimension,
    188                                MP_MatrixDict,
    189                                MP_AnnotReqValNode));
     192                                  MP_MatrixDict,
     193                                  MP_AnnotMatrixDimension,
     194                                  MP_AnnotReqValNode));
    190195  // which specifies the dimesnion of the matrix
    191196  mp_failr(MP_PutCommonOperatorPacket(link,
    192                                    MP_CopBasicList,
    193                                    MP_BasicDict,
    194                                    0, 2));
     197                                      MP_BasicDict,
     198                                      MP_CopBasicList,
     199                                      0,
     200                                      2));
    195201  mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) r, 0));
    196202  mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) c, 0));
     
    204210{
    205211  mp_failr(MP_PutCommonOperatorPacket(link,
    206                                    MP_CopPolyRing,
    207                                    MP_PolyDict,
    208                                    mpsr_GetNumOfRingAnnots(cring, 1),
    209                                    0));
     212                                      MP_PolyDict,
     213                                      MP_CopPolyRing,
     214                                      mpsr_GetNumOfRingAnnots(cring, 1),
     215                                      0));
    210216  return mpsr_PutRingAnnots(link, cring, 1);
    211217}
     
    220226  // A Singular- procedure is sent as a cop with the string as arg
    221227  mp_failr(MP_PutCommonOperatorPacket(link,
    222                                    cop,
    223                                    dict,
    224                                    0,
    225                                    2));
    226   mp_failr(MP_PutIdentifierPacket(link, pname, MP_BasicDict, 1));
    227   mp_failr(MP_PutAnnotationPacket(link, MP_AnnotSingularProcDef,
    228                                   MP_SingularDict, 0));
     228                                      dict,
     229                                      cop,
     230                                      0,
     231                                      2));
     232  mp_failr(MP_PutIdentifierPacket(link, MP_SingularDict, pname,1));
     233  mp_failr(MP_PutAnnotationPacket(link,
     234                                  MP_SingularDict,
     235                                  MP_AnnotSingularProcDef,
     236                                  0));
    229237  mp_return(MP_PutStringPacket(link, proc, 0));
    230238}
     
    251259
    252260  mp_failr(MP_PutCommonOperatorPacket(link,
    253                                    MP_CopBasicList,
    254                                    MP_BasicDict,
    255                                    0,
    256                                    nl));
     261                                      MP_BasicDict,
     262                                      MP_CopBasicList,
     263                                      0,
     264                                      nl));
    257265  for (i=0; i<nl; i++)
    258266    failr(mpsr_PutLeftv(link, &(l->m[i]), cring));
     
    273281
    274282  // and put the common operator
    275   mp_failr(MP_PutCommonOperatorPacket(link, cop, dict, 0, nc));
     283  mp_failr(MP_PutCommonOperatorPacket(link, dict, cop, 0, nc));
    276284
    277285  // now we Put the arguments
     
    298306{
    299307  mp_failr(MP_PutOperatorPacket(link,
    300                              (char *) (cmd->arg1.Data()),
    301                              MP_SingularDict,
    302                              0,
    303                              (cmd->argc <= 1 ? 0 :(cmd->arg2).listLength())));
     308                                MP_SingularDict,
     309                                (char *) (cmd->arg1.Data()),
     310                                0,
     311                                (cmd->argc <= 1 ? 0 :(cmd->arg2).listLength())));
    304312  if (cmd->argc > 1)
    305313    return PutLeftvChain(link, &(cmd->arg2), cring);
     
    337345{
    338346  mp_failr(MP_PutCommonOperatorPacket(link,
    339                                    MP_CopPolyDenseDistPoly,
    340                                    MP_PolyDict,
    341                                    mpsr_GetNumOfRingAnnots(cring, 0),
    342                                    pLength(p)));
     347                                      MP_PolyDict,
     348                                      MP_CopPolyDenseDistPoly,
     349                                      mpsr_GetNumOfRingAnnots(cring, 0),
     350                                      pLength(p)));
    343351  failr(mpsr_PutRingAnnots(link, cring, 0));
    344352  return mpsr_PutPolyData(link, p, cring);
     
    349357{
    350358  mp_failr(MP_PutCommonOperatorPacket(link,
    351                                    MP_CopPolyDenseDistPoly,
    352                                    MP_PolyDict,
    353                                    mpsr_GetNumOfRingAnnots(cring,1),
    354                                    pLength(p)));
     359                                      MP_PolyDict,
     360                                      MP_CopPolyDenseDistPoly,
     361                                      mpsr_GetNumOfRingAnnots(cring,1),
     362                                      pLength(p)));
    355363  failr(mpsr_PutRingAnnots(link, cring, 1));
    356364  return mpsr_PutPolyVectorData(link, p, cring);
     
    363371
    364372  mp_failr(MP_PutCommonOperatorPacket(link,
    365                                    MP_CopPolyIdeal,
    366                                    MP_PolyDict,
    367                                    1,
    368                                    idn));
    369   mp_failr(MP_PutAnnotationPacket(link,
    370                                MP_AnnotProtoPrototype,
    371                                MP_ProtoDict,
    372                                MP_AnnotReqValNode));
     373                                      MP_PolyDict,
     374                                      MP_CopPolyIdeal,
     375                                      1,
     376                                      idn));
     377  mp_failr(MP_PutAnnotationPacket(link,
     378                                  MP_ProtoDict,
     379                                  MP_AnnotProtoPrototype,
     380                                  MP_AnnotReqValNode));
    373381  mp_failr(MP_PutCommonMetaOperatorPacket(link,
    374                                        MP_CopPolyDenseDistPoly,
    375                                        MP_PolyDict,
    376                                        mpsr_GetNumOfRingAnnots(cring, 0),
    377                                        0));
     382                                          MP_PolyDict,
     383                                          MP_CopPolyDenseDistPoly,
     384                                          mpsr_GetNumOfRingAnnots(cring, 0),
     385                                          0));
    378386  failr(mpsr_PutRingAnnots(link, cring, 0));
    379387
     
    391399
    392400  mp_failr(MP_PutCommonOperatorPacket(link,
    393                                    MP_CopPolyModule,
    394                                    MP_PolyDict,
    395                                    1,
    396                                    idn));
    397   mp_failr(MP_PutAnnotationPacket(link,
    398                                MP_AnnotProtoPrototype,
    399                                MP_ProtoDict,
    400                                MP_AnnotReqValNode));
     401                                      MP_PolyDict,
     402                                      MP_CopPolyModule,
     403                                      1,
     404                                      idn));
     405  mp_failr(MP_PutAnnotationPacket(link,
     406                                  MP_ProtoDict,
     407                                  MP_AnnotProtoPrototype,
     408                                  MP_AnnotReqValNode));
    401409  mp_failr(MP_PutCommonMetaOperatorPacket(link,
    402                                        MP_CopPolyDenseDistPoly,
    403                                        MP_PolyDict,
    404                                        mpsr_GetNumOfRingAnnots(cring, 1),
    405                                        0));
     410                                          MP_PolyDict,
     411                                          MP_CopPolyDenseDistPoly,
     412                                          mpsr_GetNumOfRingAnnots(cring, 1),
     413                                          0));
    406414  failr(mpsr_PutRingAnnots(link, cring, 1));
    407415
     
    421429  // First, we put the Matrix operator
    422430  mp_failr(MP_PutCommonOperatorPacket(link,
    423                                    MP_CopMatrixDenseMatrix,
    424                                    MP_MatrixDict,
    425                                    2,
    426                                    n));
     431                                      MP_MatrixDict,
     432                                      MP_CopMatrixDenseMatrix,
     433                                      2,
     434                                      n));
    427435  // Put the two annotations
    428436  // First, the prototype annot
    429437  mp_failr(MP_PutAnnotationPacket(link,
    430                                MP_AnnotProtoPrototype,
    431                                MP_ProtoDict,
    432                                MP_AnnotReqValNode));
     438                                  MP_ProtoDict,
     439                                  MP_AnnotProtoPrototype,
     440                                  MP_AnnotReqValNode));
    433441  mp_failr(MP_PutCommonMetaOperatorPacket(link,
    434                                        MP_CopPolyDenseDistPoly,
    435                                        MP_PolyDict,
    436                                        mpsr_GetNumOfRingAnnots(cring, 0),
    437                                        0));
     442                                          MP_PolyDict,
     443                                          MP_CopPolyDenseDistPoly,
     444                                          mpsr_GetNumOfRingAnnots(cring, 0),
     445                                          0));
    438446  failr(mpsr_PutRingAnnots(link, cring, 0));
    439447
    440448  // second, the matrix dim annot
    441449  mp_failr(MP_PutAnnotationPacket(link,
    442                                MP_AnnotMatrixDimension,
    443                                MP_MatrixDict,
    444                                MP_AnnotReqValNode));
     450                                  MP_MatrixDict,
     451                                  MP_AnnotMatrixDimension,
     452                                  MP_AnnotReqValNode));
    445453  // which specifies the dimesnion of the matrix
    446454  mp_failr(MP_PutCommonOperatorPacket(link,
    447                                    MP_CopBasicList,
    448                                    MP_BasicDict,
    449                                    0, 2));
     455                                      MP_BasicDict,
     456                                      MP_CopBasicList,
     457                                      0, 2));
    450458  mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) nrows, 0));
    451459  mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) ncols, 0));
     
    472480
    473481  mp_failr(MP_PutCommonOperatorPacket(link,
    474                                    cop,
    475                                    dict,
    476                                    0,
    477                                    3));
     482                                      dict,
     483                                      cop,
     484                                      0,
     485                                      3));
    478486  // First, is the ring
    479487  failr(mpsr_PutRingLeftv(link, (leftv) idroot->get(m->preimage, 1)));
     
    539547          if (mpsr_PutLeftv(link, lv, r) != mpsr_Success) break;
    540548#ifdef MPSR_DEBUG
    541       Print("Dumped %s\n", IDID(h2));
     549          Print("Dumped %s\n", IDID(h2));
    542550#endif
    543551          h2 = h2->next;
  • Singular/mpsr_Put.h

    r6ae4f5 rfeaddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mpsr_Put.h,v 1.2 1997-04-09 12:20:03 Singular Exp $ */
     4/* $Id: mpsr_Put.h,v 1.3 1997-04-10 13:08:38 obachman Exp $ */
    55/***************************************************************
    66 *
     
    3232#include"MP_NumberDict.h"
    3333#include"MP_ProtoDict.h"
    34 
     34#include"MP_MpDict.h"
    3535
    3636
     
    7575inline mpsr_Status_t mpsr_PutString(MP_Link_pt link, char *str)
    7676{
    77   mp_return(MP_PutStringPacket(link, str, 0));
     77  if (strcmp(str, MPSR_QUIT_STRING) == 0)
     78    mp_return(MP_PutCommonOperatorPacket(link,
     79                                         MP_MpDict,
     80                                         MP_CopMpEndSession,
     81                                         0, 0));
     82  else
     83    mp_return(MP_PutStringPacket(link, str, 0));
    7884}
    7985extern mpsr_Status_t mpsr_PutRing(MP_Link_pt link, ring r);
     
    8187inline mpsr_Status_t mpsr_PutDef(MP_Link_pt link, char *name)
    8288{
    83   mp_return(MP_PutIdentifierPacket(link, name, 0, 0));
     89  mp_return(MP_PutIdentifierPacket(link, MP_SingularDict, name, 0));
    8490}
    8591// next, ring-dependent data
  • Singular/mpsr_PutPoly.cc

    r6ae4f5 rfeaddd  
    33****************************************/
    44
    5 /* $Id: mpsr_PutPoly.cc,v 1.4 1997-04-02 15:07:41 Singular Exp $ */
     5/* $Id: mpsr_PutPoly.cc,v 1.5 1997-04-10 13:08:39 obachman Exp $ */
    66
    77/***************************************************************
     
    165165  // send number itself
    166166  mp_failr(MP_PutCommonOperatorPacket(link,
    167                                    MP_CopBasicDiv,
    168                                    MP_BasicDict,
    169                                    0,
    170                                    2));
    171     // and now sent nominator and denominator
     167                                      MP_BasicDict,
     168                                      MP_CopBasicDiv,
     169                                      0,
     170                                      2));
     171  // and now sent nominator and denominator
    172172  mp_failr(MP_MyPutApIntPacket(link, (MP_ApInt_t) &(a->z), 0));
    173173  mp_return(MP_MyPutApIntPacket(link, (MP_ApInt_t) &(a->n), 0));
     
    251251
    252252  if (cring != CurrPutRing)
    253      SetPutFuncs(cring);
     253    SetPutFuncs(cring);
    254254
    255255#ifdef MPSR_DEBUG
     
    339339  if (mv)
    340340    mp_failr(MP_PutAnnotationPacket(link,
    341                                  MP_AnnotPolyModuleVector,
    342                                  MP_PolyDict,
    343                                  MP_AnnotRequired));
     341                                    MP_PolyDict,
     342                                    MP_AnnotPolyModuleVector,
     343                                    MP_AnnotRequired));
    344344  // Hmm .. this is not according to a "proper" Singular ring,
    345345  // but to be used in a recursive call of mpsr_PutRingAnnots
     
    354354
    355355static mpsr_Status_t PutProtoTypeAnnot(MP_Link_pt link, ring r,
    356                                      BOOLEAN mv)
     356                                       BOOLEAN mv)
    357357{
    358358  // each element of the poly is a
    359359  mp_failr(MP_PutAnnotationPacket(link,
    360                                MP_AnnotProtoPrototype,
    361                                MP_ProtoDict,
    362                                MP_AnnotReqValNode));
     360                                  MP_ProtoDict,
     361                                  MP_AnnotProtoPrototype,
     362                                  MP_AnnotReqValNode));
    363363  // Monom represented as a struct of 2 elements
    364364  mp_failr(MP_PutCommonOperatorPacket(link,
    365                                    MP_CopProtoStruct,
    366                                    MP_ProtoDict,
    367                                    0,
    368                                    2));
     365                                      MP_ProtoDict,
     366                                      MP_CopProtoStruct,
     367                                      0,
     368                                      2));
    369369
    370370  // First element is the coefficient
     
    372372  {
    373373    // rational numbers
    374     mp_failr(MP_PutCommonMetaPacket(link,
    375                                  MP_CmtNumberRational,
    376                                  MP_NumberDict,
    377                                  1));
     374    mp_failr(MP_PutCommonMetaTypePacket(link,
     375                                        MP_NumberDict,
     376                                        MP_CmtNumberMP_Rational,
     377                                        1));
    378378    // are always normalized (and made that way, if necessary)
    379379    mp_failr(MP_PutAnnotationPacket(link,
    380                                  MP_AnnotNumberIsNormalized,
    381                                  MP_NumberDict,
    382                                  0));
     380                                    MP_NumberDict,
     381                                    MP_AnnotNumberIsNormalized,
     382                                    0));
    383383  }
    384384  else if ((r->ch) > 1)
     
    386386    // modulo p numbers
    387387    // are communicated as IMP_Uint32's
    388     mp_failr(MP_PutCommonMetaPacket(link,
    389                                  MP_CmtProtoUint32,
    390                                  MP_ProtoDict,
    391                                  1));
     388    mp_failr(MP_PutCommonMetaTypePacket(link,
     389                                    MP_ProtoDict,
     390                                    MP_CmtProtoIMP_Uint32,
     391                                    1));
    392392    // but are taken as modulo numbers
    393393    mp_failr(MP_PutAnnotationPacket(link,
    394                                  MP_AnnotNumberModulos,
    395                                  MP_NumberDict,
    396                                  MP_AnnotValuated));
     394                                    MP_NumberDict,
     395                                    MP_AnnotNumberModulos,
     396                                    MP_AnnotValuated));
    397397    // with Modulo
    398398    mp_failr(MP_PutUint32Packet(link, r->ch, 1));
     
    401401      // which is (in our case) always a prime number
    402402      mp_failr(MP_PutAnnotationPacket(link,
    403                                    MP_AnnotNumberIsPrime,
    404                                    MP_NumberDict,
    405                                    0));
     403                                      MP_NumberDict,
     404                                      MP_AnnotNumberIsPrime,
     405                                      0));
    406406    }
    407407    else
    408408    {
    409409      mp_failr(MP_PutAnnotationPacket(link,
    410                                    MP_AnnotSingularGalois,
    411                                    129,
    412                                    MP_AnnotValuated));
     410                                      MP_SingularDict,
     411                                      MP_AnnotSingularGalois,
     412                                      MP_AnnotValuated));
    413413      mp_failr(MP_PutStringPacket(link, r->parameter[0], 0));
    414414    }
     
    417417  {
    418418    // floats
    419     mp_failr(MP_PutCommonMetaPacket(link,
    420                                  MP_CmtProtoReal32,
    421                                  MP_ProtoDict,
    422                                  0));
     419    mp_failr(MP_PutCommonMetaTypePacket(link,
     420                                    MP_ProtoDict,
     421                                    MP_CmtProtoIMP_Real32,
     422                                    0));
    423423  }
    424424  else
     
    440440    // a fraction of two Dense Dist Polys
    441441    mp_failr(MP_PutCommonMetaOperatorPacket(link,
    442                                          MP_CopPolyDenseDistPolyFrac,
    443                                          MP_PolyDict,
    444                                          mpsr_GetNumOfRingAnnots(alg_r,0),
    445                                          0));
     442                                            MP_PolyDict,
     443                                            MP_CopPolyDenseDistPolyFrac,
     444                                            mpsr_GetNumOfRingAnnots(alg_r,0),
     445                                            0));
    446446    failr(mpsr_PutRingAnnots(link, alg_r, 0));
    447447
     
    453453  // second element is the exponent vector
    454454  mp_failr(MP_PutCommonMetaOperatorPacket(link,
    455                                        MP_CopProtoArray,
    456                                        MP_ProtoDict,
    457                                        1,
    458                                        (mv ? r->N + 1 : r->N)));
    459   mp_failr(MP_PutAnnotationPacket(link,
    460                                MP_AnnotProtoPrototype,
    461                                MP_ProtoDict,
    462                                MP_AnnotReqValNode));
    463   mp_return(MP_PutCommonMetaPacket(link,
    464                                 MP_CmtProtoSint32,
    465                                 MP_ProtoDict,
    466                                 0));
     455                                          MP_ProtoDict,
     456                                          MP_CopProtoArray,
     457                                          1,
     458                                          (mv ? r->N + 1 : r->N)));
     459  mp_failr(MP_PutAnnotationPacket(link,
     460                                  MP_ProtoDict,
     461                                  MP_AnnotProtoPrototype,
     462                                  MP_AnnotReqValNode));
     463  mp_return(MP_PutCommonMetaTypePacket(link,
     464                                   MP_ProtoDict,
     465                                   MP_CmtProtoIMP_Sint32,
     466                                   0));
    467467}
    468468
     
    472472  // first, we put the annot packet, with flags (1, 0, 1, 0)
    473473  mp_failr(MP_PutAnnotationPacket(link,
    474                                MP_AnnotPolyVarNames,
    475                                MP_PolyDict,
    476                                MP_AnnotValuated));
     474                                  MP_PolyDict,
     475                                  MP_AnnotPolyVarNames,
     476                                  MP_AnnotValuated));
    477477  // now, the varnames follow
    478478  if ((r->N) == 1)
    479479  {
    480480    // only 1 varname
    481     mp_return(MP_PutIdentifierPacket(link, *(r->names), 0, 0));
     481    mp_return(MP_PutIdentifierPacket(link, MP_SingularDict, *(r->names), 0));
    482482  }
    483483  else
     
    488488
    489489    mp_failr(MP_PutCommonOperatorPacket(link,
    490                                      MP_CopProtoArray,
    491                                      MP_ProtoDict,
    492                                      1,
    493                                      r->N));
     490                                        MP_ProtoDict,
     491                                        MP_CopProtoArray,
     492                                        1,
     493                                        r->N));
    494494    mp_failr(MP_PutAnnotationPacket(link,
    495                                  MP_AnnotProtoPrototype,
    496                                  MP_ProtoDict,
    497                                  MP_AnnotReqValNode));
     495                                    MP_ProtoDict,
     496                                    MP_AnnotProtoPrototype,
     497                                    MP_AnnotReqValNode));
    498498                                 
    499     mp_failr(MP_PutCommonMetaPacket(link,
    500                                  MP_CmtProtoIdentifier,
    501                                  MP_ProtoDict,
    502                                  0));
     499    mp_failr(MP_PutCommonMetaTypePacket(link,
     500                                    MP_ProtoDict,
     501                                    MP_CmtProtoIMP_Identifier,
     502                                    0));
    503503    for (i=0; i<n; i++)
    504504      mp_failr(IMP_PutString(link, names[i]));
     
    511511{
    512512  mp_failr(MP_PutAnnotationPacket(link,
    513                                MP_AnnotPolyVarNumber,
    514                                MP_PolyDict,
    515                                MP_AnnotValuated));
     513                                  MP_PolyDict,
     514                                  MP_AnnotPolyVarNumber,
     515                                  MP_AnnotValuated));
    516516  mp_return(MP_PutUint32Packet(link, (mv ? r->N + 1 : r->N), 0));
    517517}
     
    524524
    525525  mp_failr(MP_PutAnnotationPacket(link,
    526                                MP_AnnotPolyOrdering,
    527                                MP_PolyDict,
    528                                MP_AnnotValuated));
     526                                  MP_PolyDict,
     527                                  MP_AnnotPolyOrdering,
     528                                  MP_AnnotValuated));
    529529
    530530  // let's see whether we have a simple ordering to sent
     
    545545  // the vector ordering
    546546  mp_failr(MP_PutCommonOperatorPacket(link,
    547                                    MP_CopBasicList,
    548                                    MP_BasicDict,
    549                                    0,
    550                                    (mv ? nblocks : nblocks - 1)));
     547                                      MP_BasicDict,
     548                                      MP_CopBasicList,
     549                                      0,
     550                                      (mv ? nblocks : nblocks - 1)));
    551551
    552552  for (index = 0; index < nblocks; index ++)
     
    557557      // a product ordering is sent as triple
    558558      mp_failr(MP_PutCommonOperatorPacket(link,
    559                                        MP_CopBasicList,
    560                                        MP_BasicDict,
    561                                        0,
    562                                        3));
     559                                          MP_BasicDict,
     560                                          MP_CopBasicList,
     561                                          0,
     562                                          3));
    563563      // first element is the simple ordering
    564564      failr(PutSimpleOrdering(link, r, index));
     
    581581
    582582  mp_failr(MP_PutCommonConstantPacket(link,
    583                                    mpsr_ord2mp(r->order[index]),
    584                                    MP_PolyDict,
    585                                    (vlength == 0 ? 0 : 1)));
     583                                      MP_PolyDict,
     584                                      mpsr_ord2mp(r->order[index]),
     585                                      (vlength == 0 ? 0 : 1)));
    586586
    587587  if (vlength == 0) return mpsr_Success;
     
    589589  // deal with the weights
    590590  mp_failr(MP_PutAnnotationPacket(link,
    591                                MP_AnnotPolyWeights,
    592                                MP_PolyDict,
    593                                MP_AnnotValuated));
     591                                  MP_PolyDict,
     592                                  MP_AnnotPolyWeights,
     593                                  MP_AnnotValuated));
    594594  if (r->order[index] == ringorder_M)
    595595  {
    596596    // put the matrix header
    597597    mp_failr(MP_PutCommonOperatorPacket(link,
    598                                      MP_CopMatrixDenseMatrix,
    599                                      MP_MatrixDict,
    600                                      2,
    601                                      vlength*vlength));
     598                                        MP_MatrixDict,
     599                                        MP_CopMatrixDenseMatrix,
     600                                        2,
     601                                        vlength*vlength));
    602602    mp_failr(MP_PutAnnotationPacket(link,
    603                                  MP_AnnotProtoPrototype,
    604                                  MP_ProtoDict,
    605                                  MP_AnnotReqValNode));
    606     mp_failr(MP_PutCommonMetaPacket(link, MP_CmtProtoSint32, MP_ProtoDict, 0));
     603                                    MP_ProtoDict,
     604                                    MP_AnnotProtoPrototype,
     605                                    MP_AnnotReqValNode));
     606    mp_failr(MP_PutCommonMetaTypePacket(link,
     607                                    MP_ProtoDict,
     608                                    MP_CmtProtoIMP_Sint32,
     609                                    0));
    607610    mp_failr(MP_PutAnnotationPacket(link,
    608                                  MP_AnnotMatrixDimension,
    609                                  MP_MatrixDict,
    610                                  MP_AnnotReqValNode));
     611                                    MP_MatrixDict,
     612                                    MP_AnnotMatrixDimension,
     613                                    MP_AnnotReqValNode));
    611614    mp_failr(MP_PutCommonOperatorPacket(link,
    612                                      MP_CopBasicList,
    613                                      MP_BasicDict,
    614                                      0, 2));
     615                                        MP_BasicDict,
     616                                        MP_CopBasicList,
     617                                        0, 2));
    615618    mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) vlength, 0));
    616619    mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) vlength, 0));
     
    621624    // vector header
    622625    mp_failr(MP_PutCommonOperatorPacket(link,
    623                                      MP_CopMatrixDenseVector,
    624                                      MP_MatrixDict,
    625                                      1,
    626                                      vlength));
     626                                        MP_MatrixDict,
     627                                        MP_CopMatrixDenseVector,
     628                                        1,
     629                                        vlength));
    627630    mp_failr(MP_PutAnnotationPacket(link,
    628                                  MP_AnnotProtoPrototype,
    629                                  MP_ProtoDict,
    630                                  MP_AnnotReqValNode));
    631     mp_failr(MP_PutCommonMetaPacket(link, MP_CmtProtoSint32, MP_ProtoDict, 0));
     631                                    MP_ProtoDict,
     632                                    MP_AnnotProtoPrototype,
     633                                    MP_AnnotReqValNode));
     634    mp_failr(MP_PutCommonMetaTypePacket(link,
     635                                    MP_ProtoDict,
     636                                    MP_CmtProtoIMP_Sint32,
     637                                    0));
    632638  }
    633639
     
    647653
    648654  mp_failr(MP_PutAnnotationPacket(link,
    649                                MP_AnnotPolyDefRel,
    650                                MP_PolyDict,
    651                                MP_AnnotValuated));
     655                                  MP_PolyDict,
     656                                  MP_AnnotPolyDefRel,
     657                                  MP_AnnotValuated));
    652658  mp_failr(MP_PutCommonOperatorPacket(link,
    653                                    MP_CopPolyDenseDistPoly,
    654                                    MP_PolyDict,
    655                                    5,
    656                                    GetPlength( ((lnumber) minpoly)->z)));
     659                                      MP_PolyDict,
     660                                      MP_CopPolyDenseDistPoly,
     661                                      5,
     662                                      GetPlength( ((lnumber) minpoly)->z)));
    657663  failr(PutProtoTypeAnnot(link, r, 0));
    658664  failr(PutVarNamesAnnot(link, r));
     
    660666  failr(PutOrderingAnnot(link, r, 0));
    661667  mp_failr(MP_PutAnnotationPacket(link,
    662                                MP_AnnotPolyIrreducible,
    663                                MP_PolyDict,
    664                                0));
     668                                  MP_PolyDict,
     669                                  MP_AnnotPolyIrreducible,
     670                                  0));
    665671
    666672  // need to set PutAlgAlgnumber and gNalgVars
     
    686692
    687693  mp_failr(MP_PutAnnotationPacket(link,
    688                                MP_AnnotPolyDefRel,
    689                                MP_PolyDict,
    690                                MP_AnnotValuated));
     694                                  MP_PolyDict,
     695                                  MP_AnnotPolyDefRel,
     696                                  MP_AnnotValuated));
    691697  failr(mpsr_PutIdeal(link, id, r));
    692698  r->qideal = id;
  • Singular/mptest.sr

    r6ae4f5 rfeaddd  
    1 proc asciidump
    2 {
    3   list l = names();
    4   list lr;
    5   int ll = size(l);
    6   int llr;
    7   int i;
    8   int j;
    9   def el;
    10   def elr;
    11  
    12   for (i=1; i<= ll; i++)
    13   {
    14     el = l[i];
    15     el;
    16     " = ";
    17     if (typeof(`el`) == "proc")
    18     {
    19       string(`el`);
    20     }
    21     else
    22     {
    23       `el`;
    24     }
    25     " ";
    26     if (typeof(`el`) == "ring")
    27     {
    28       lr = names(`el`);
    29       llr = size(lr);
    30       j;
    31      
    32       setring(`el`);
    33       for (j=1; j<llr; j++)
    34       {
    35         elr = lr[j];
    36         elr;
    37         " = ";
    38         `elr`;
    39         " ";
    40       }
    41     }
    42   }
    43   return();
    44 }
    45  
    46        
    471proc mptest (lv)
    482{
    493  print(lv);
    50   write("t.mp MP:file", lv);
    51   return(lv == read("t.mp MP:file"));
     4  write("MPfile:w /tmp/t.mp", lv);
     5  return(lv == read("MPfile: /tmp/t.mp"));
    526};
    537
     
    559{
    5610  lv;
    57   write("t.mp MP:file", lv);
    58   def r = read("t.mp MP:file");
     11  write("MPfile:w /tmp/t.mp", lv);
     12  def r = read("MPfile: /tmp/t.mp");
    5913  r;
    6014};
     
    11468poly p13 = p12^4;
    11569
     70ring rtm = 32003, (x,y,z,t), dp;
     71ideal ex = t3y7z4 + 9x8 + 5t2x4y2 + 2t2xy2z3,
     722t2x5y4+7txy6+9y8 + 2t2x2yz3,  3t4x2y3z2 + 9z8, 3x2y9 +
     73y9 + 5x4;
     74
     75ring rt0 = 0, (x,y,z,t), dp;
     76ideal ex = t3y7z4 + 9x8 + 5t2x4y2 + 2t2xy2z3,
     772t2x5y4+7txy6+9y8 + 2t2x2yz3,  3t4x2y3z2 + 9z8, 3x2y9 +
     78y9 + 5x4;
    11679
    11780
  • Singular/sing_mp.cc

    r6ae4f5 rfeaddd  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: sing_mp.cc,v 1.8 1997-04-09 12:20:10 Singular Exp $ */
     4/* $Id: sing_mp.cc,v 1.9 1997-04-10 13:08:40 obachman Exp $ */
    55
    66/*
     
    270270BOOLEAN slWriteMP(si_link l, leftv v)
    271271{
     272  leftv next = (v != NULL ? v->next : NULL);
    272273  mpsr_ClearError();
     274
     275  // writing is done with one leftv at a time
     276  if (v != NULL) v->next = NULL; // hence, we need to set next to NULL
    273277  if (mpsr_PutMsg((MP_Link_pt) l->data, v) != mpsr_Success)
    274278  {
    275279    mpsr_PrintError((MP_Link_pt) l->data);
    276     return TRUE;
    277   }
    278   else
    279     return FALSE;
     280    if (v != NULL) v->next = next;
     281    return TRUE;
     282  }
     283
     284  // take care of the remaining leftv's
     285  while (next != NULL)
     286  {
     287    v->next = next;
     288    v = next;
     289    next = v->next;
     290    if (mpsr_PutMsg((MP_Link_pt) l->data, v) != mpsr_Success)
     291    {
     292      mpsr_PrintError((MP_Link_pt) l->data);
     293      v->next = next;
     294      return TRUE;
     295    }
     296  }
     297  return FALSE;
    280298}
    281299
     
    298316
    299317  v->rtyp = STRING_CMD;
    300   v->data = "MP:Quit";
     318  v->data = MPSR_QUIT_STRING;
    301319  slWriteMP(l, v);
    302320  Free(v, sizeof(sleftv));
     
    425443
    426444    // no need to evaluate -- it is done in the read
    427     if (v->Typ() == STRING_CMD && (strcmp((char *)v->Data(), "MP:Quit") == 0))
     445    if (v->Typ() == STRING_CMD &&
     446        (strcmp((char *)v->Data(), MPSR_QUIT_STRING)  == 0))
    428447    {
    429448      slKill(silink);
Note: See TracChangeset for help on using the changeset viewer.