Changeset 12310e in git


Ignore:
Timestamp:
Oct 15, 1998, 1:46:10 PM (26 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
eeb6f9aa3deb356d57afbd5decec3f7e1f2b4436
Parents:
17802ff73728d98f781855d9ecf15acd282636dd
Message:
* merged in changes from version 1.2.2
* mpsr stuff changes to reflect changes in MP


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/all.lib

    r17802f r12310e  
    1 // $Id: all.lib,v 1.14 1998-08-07 17:33:53 gorzel Exp $
     1// $Id: all.lib,v 1.15 1998-10-15 11:46:09 obachman Exp $
    22///////////////////////////////////////////////////////////////////////////////
    33
    4 version="$Id: all.lib,v 1.14 1998-08-07 17:33:53 gorzel Exp $";
     4version="$Id: all.lib,v 1.15 1998-10-15 11:46:09 obachman Exp $";
    55info="
    66LIBRARY:  all.lib   Load all libraries
    … …  
    2727  sing.lib      PROCEDURES FOR SINGULARITIES
    2828  standard.lib  PROCEDURES WHICH ARE ALWAYS LOADED AT START-UP
     29  latex.lib     PROCEDURES FOR TYPESET OF SINGULAROBJECTS IN TEX
     30  paramet.lib PROCEDURES FOR PARAMETRIZATION OF PRIMARY DECOMPOSITION
    2931";
    3032
    … …  
    5254LIB "ring.lib";
    5355LIB "sing.lib";
     56LIB "latex.lib";
     57LIB "paramet.lib";
     58
     59// LIB "tools.lib";

  • Singular/LIB/standard.lib

    r17802f r12310e  
    1 // $Id: standard.lib,v 1.25 1998-06-19 08:01:51 Singular Exp $
     1// $Id: standard.lib,v 1.26 1998-10-15 11:46:10 obachman Exp $
    22//////////////////////////////////////////////////////////////////////////////
    33
    4 version="$Id: standard.lib,v 1.25 1998-06-19 08:01:51 Singular Exp $";
     4version="$Id: standard.lib,v 1.26 1998-10-15 11:46:10 obachman Exp $";
    55info="
    66LIBRARY: standard.lib   PROCEDURES WHICH ARE ALWAYS LOADED AT START-UP
    … …  
    334334    {
    335335      "std with hilb in basering";
    336       i = std(i, hi);
    337     }
     336    }
     337    i = std(i, hi);
    338338  }
    339339  else

  • Singular/extra.cc

    r17802f r12310e  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: extra.cc,v 1.67 1998-09-08 07:51:38 Singular Exp $ */
     4/* $Id: extra.cc,v 1.68 1998-10-15 11:45:51 obachman Exp $ */
    55/*
    66* ABSTRACT: general interface to internals of Singular ("system" command)
    … …  
    3030#endif
    3131
     32#endif
    3233#include <unistd.h>
    33 #endif
    3434
    3535#include "tok.h"

  • Singular/febase.cc

    r17802f r12310e  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: febase.cc,v 1.67 1998-09-01 15:10:15 Singular Exp $ */
     4/* $Id: febase.cc,v 1.68 1998-10-15 11:45:53 obachman Exp $ */
    55/*
    66* ABSTRACT: i/o system
    … …  
    6868;}
    6969BOOLEAN errorreported = FALSE;
    70 BOOLEAN feBatch=FALSE;
     70BOOLEAN feBatch = FALSE;
    7171char *  feErrors=NULL;
    7272int     feErrorsLen=0;
     73BOOLEAN feWarn = TRUE;
     74BOOLEAN feOut = TRUE;
     75
     76#ifdef macintosh
     77static  int lines = 0;
     78static  int cols = 0;
     79#endif
    7380
    7481const char feNotImplemented[]="not implemented";
    … …  
    645652  }
    646653  char *res;
    647   int idat=strlen(SINGULAR_DATADIR),ipath=strlen(path);
     654  int idat=strlen(SINGULAR_DATADIR),
     655      ilib=strlen(VERSION_DIR),
     656      ipath=strlen(path);
     657  int ialloc = idat+ilib+ipath+1;
    648658  char *env=getenv("SINGULARPATH");
    649659  int ienv=0, ii=0;
    … …  
    660670    return f;
    661671  }
    662   res=(char*) AllocL(ii+ipath+1);
     672  res=(char*) AllocL(ialloc);
    663673  if (ienv!=0)
    664674  {
    … …  
    671681  {
    672682    memcpy(res,SINGULAR_DATADIR,idat);
     683    memcpy(res+idat,path,ipath);
     684    res[idat+ipath]='\0';
     685    f=myfopen(res,mode);
     686  }
     687  if ((f==NULL)&&(idat!=0))
     688  {
     689    memcpy(res,SINGULAR_DATADIR,idat);
     690    memcpy(res+idat,VERSION_DIR,ilib);
     691    idat += ilib;
    673692    memcpy(res+idat,path,ipath);
    674693    res[idat+ipath]='\0';
    … …  
    853872      feErrors=(char *)Alloc(256);
    854873      feErrorsLen=256;
    855       strcpy(feErrors,(char *)s);
     874      *feErrors = '\0';
    856875    }
    857876    else
    858877    {
    859       if (((int)(strlen((char *)s)+strlen(feErrors)))>=feErrorsLen)
     878      if (((int)(strlen((char *)s)+ 20 +strlen(feErrors)))>=feErrorsLen)
    860879      {
    861880        feErrors=(char *)ReAlloc(feErrors,feErrorsLen,feErrorsLen+256);
    862881        feErrorsLen+=256;
    863882      }
    864       strcat(feErrors,(char *)s);
    865     }
    866     strcat(feErrors,"\n");
     883    }
     884    strcat(feErrors, "Singular error: ");
     885    strcat(feErrors, (char *)s);
    867886  }
    868887  else
    … …  
    917936  else
    918937#endif
    919 #ifdef HAVE_MPSR
    920   if (!feBatch) /* ignore warnings in febatch-mode */
    921 #endif
     938  if (feWarn) /* ignore warnings in when optin --no-warn was given */
    922939  {
    923940    fwrite(warn_str,1,6,stdout);
    … …  
    980997void PrintS(char *s)
    981998{
     999  if (feOut) /* do not print when option --no-out was given */
     1000  {
     1001   
    9821002#ifdef macintosh
    983   char c;
    984   while ('\0' != (c = *s++))
    985   {
    986     mwrite(c);
    987   }
     1003    char c;
     1004    while ('\0' != (c = *s++))
     1005    {
     1006      mwrite(c);
     1007    }
    9881008#else
    9891009#ifdef HAVE_TCL
    990   if (tclmode)
    991   {
    992     PrintTCLS('N',s);
    993   }
    994   else
    995 #endif
    996   {
    997     int i=strlen(s);
    998     fwrite(s,1,i,stdout);
    999     fflush(stdout);
    1000     if (feProt&PROT_O)
    1001     {
    1002       fwrite(s,1,i,feProtFile);
    1003     }
    1004   }
    1005 #endif
     1010    if (tclmode)
     1011    {
     1012      PrintTCLS('N',s);
     1013    }
     1014    else
     1015#endif
     1016    {
     1017      fwrite(s,1,strlen(s),stdout);
     1018      fflush(stdout);
     1019      if (feProt&PROT_O)
     1020      {
     1021        fwrite(s,1,strlen(s),feProtFile);
     1022      }
     1023    }
     1024#endif
     1025  }
    10061026}
    10071027
    … …  
    10131033void Print(char *fmt, ...)
    10141034{
    1015   va_list ap;
    1016   va_start(ap, fmt);
     1035  if (feOut)
     1036  {
     1037    va_list ap;
     1038    va_start(ap, fmt);
    10171039#ifdef HAVE_TCL
    1018   if(tclmode)
     1040    if(tclmode)
    10191041#endif
    10201042#if (defined(HAVE_TCL) || defined(macintosh))
    1021   {
    1022     char *s=(char *)Alloc(strlen(fmt)+256);
    1023     vsprintf(s,fmt, ap);
     1043    {
     1044      char *s=(char *)Alloc(strlen(fmt)+256);
     1045      vsprintf(s,fmt, ap);
    10241046#ifdef HAVE_TCL
    1025     PrintTCLS('N',s);
     1047      PrintTCLS('N',s);
    10261048#endif
    10271049#ifdef macintosh
    1028   char c;
    1029   while ('\0' != (c = *s++))
    1030   {
    1031     mwrite(c);
    1032   }
    1033   if (feProt&PROT_O)
    1034   {
    1035     vfprintf(feProtFile,fmt,ap);
    1036   }
    1037 #endif
    1038   }
     1050      char c;
     1051      while ('\0' != (c = *s++))
     1052      {
     1053        mwrite(c);
     1054      }
     1055      if (feProt&PROT_O)
     1056      {
     1057        vfprintf(feProtFile,fmt,ap);
     1058      }
     1059#endif
     1060    }
    10391061#endif
    10401062#if !defined(macintosh) || defined(HAVE_TCL)
    10411063#ifdef HAVE_TCL
    1042   else
    1043 #endif
    1044   {
    1045     vfprintf(stdout, fmt, ap);
    1046     fflush(stdout);
    1047     if (feProt&PROT_O)
    1048     {
    1049       vfprintf(feProtFile,fmt,ap);
    1050     }
    1051   }
    1052 #endif
    1053   va_end(ap);
     1064    else
     1065#endif
     1066    {
     1067      vfprintf(stdout, fmt, ap);
     1068      fflush(stdout);
     1069      if (feProt&PROT_O)
     1070      {
     1071        vfprintf(feProtFile,fmt,ap);
     1072      }
     1073    }
     1074#endif
     1075    va_end(ap);
     1076  }
    10541077}
    10551078

  • Singular/febase.h

    r17802f r12310e  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: febase.h,v 1.22 1998-07-10 17:03:42 Singular Exp $ */
     6/* $Id: febase.h,v 1.23 1998-10-15 11:45:53 obachman Exp $ */
    77/*
    88* ABSTRACT
    … …  
    4747extern BOOLEAN feBatch;
    4848extern BOOLEAN feProt;
     49extern BOOLEAN feWarn;
     50extern BOOLEAN feOut;
     51
    4952
    5053#define PROT_NONE 0

  • Singular/ffields.cc

    r17802f r12310e  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ffields.cc,v 1.17 1998-09-29 12:00:54 Singular Exp $ */
     4/* $Id: ffields.cc,v 1.18 1998-10-15 11:45:54 obachman Exp $ */
    55/*
    66* ABSTRACT: finite fields with a none-prime number of elements (via tables)
    … …  
    627627    else     nfCharQ = -c;
    628628    char buf[100];
     629#ifdef macintosh
     630    sprintf(buf,"gftables:%d",nfCharQ);
     631#else
    629632    sprintf(buf,"gftables/%d",nfCharQ);
     633#endif
    630634    FILE * fp = feFopen(buf,"r",NULL,TRUE);
    631635    if (fp==NULL)

  • Singular/find_exec.c

    r17802f r12310e  
    117117        }
    118118
    119         strcat (tbuf, "/");
     119        if (tbuf[strlen(tbuf)-1] != '/') strcat(tbuf, "/");
    120120        strcat (tbuf, name);
    121 
     121       
    122122        /* If we can execute the named file, then return it. */
    123123        if (! access (tbuf, X_OK))

  • Singular/kstd2.cc

    r17802f r12310e  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kstd2.cc,v 1.21 1998-10-08 13:12:55 Singular Exp $ */
     4/* $Id: kstd2.cc,v 1.22 1998-10-15 11:45:56 obachman Exp $ */
    55/*
    66*  ABSTRACT -  Kernel: alg. of Buchberger
    … …  
    793793      if (pSDRING)
    794794      {
    795         p=spSpolyCreate(strat->T[j].p,(*h).p,strat->kNoether);
     795        p=spSpolyCreate(strat->T[j].p,(*h).p,strat->kNoether,strat->spSpolyLoop);
    796796        if (p!=NULL) pDelete(&pNext(p));
    797797      }
    … …  
    817817              if (pSDRING)
    818818              {
    819                 ph=spSpolyCreate(strat->T[j].p,(*h).p,strat->kNoether);
     819                ph=spSpolyCreate(strat->T[j].p,(*h).p,strat->kNoether,strat->spSpolyLoop);
    820820                if (ph!=NULL) pDelete(&pNext(ph));
    821821              }

  • Singular/kutil.cc

    r17802f r12310e  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kutil.cc,v 1.29 1998-09-24 17:13:10 Singular Exp $ */
     4/* $Id: kutil.cc,v 1.30 1998-10-15 11:45:57 obachman Exp $ */
    55/*
    66* ABSTRACT: kernel: utils for kStd
    … …  
    748748  if (pSDRING)
    749749  {
    750     Lp.p=spSpolyCreate(strat->S[i],p,strat->kNoether);
     750    Lp.p=spSpolyCreate(strat->S[i],p,strat->kNoether,strat->spSpolyLoop);
    751751    if (Lp.p!=NULL)
    752752      pDelete(&pNext(Lp.p));
    … …  
    864864  if (pSDRING)
    865865  {
    866     Lp.p=spSpolyCreate(strat->S[i],p,strat->kNoether);
     866    Lp.p=spSpolyCreate(strat->S[i],p,strat->kNoether,strat->spSpolyLoop);
    867867    if (Lp.p!=NULL)
    868868      pDelete(&pNext(Lp.p));

  • Singular/misc.cc

    r17802f r12310e  
    792792#endif
    793793#ifndef __OPTIMIZE__
     794#ifdef __MWERKS__
     795              StringAppend(" Codewarrior 2.0,");
     796#else
    794797              StringAppend("-g,");
     798#endif
    795799#endif
    796800              StringAppend("random=%d\n",siRandomStart);

  • Singular/mminit.cc

    r17802f r12310e  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mminit.cc,v 1.12 1998-05-27 17:14:09 Singular Exp $ */
     4/* $Id: mminit.cc,v 1.13 1998-10-15 11:46:00 obachman Exp $ */
    55/*
    66* ABSTRACT: init of memory management
    … …  
    1313#define __USE_MISC
    1414#include <unistd.h>
     15#ifdef macintosh
     16#include <types.h>
     17#else
    1518#include <sys/types.h>
     19#endif
    1620#include "mod2.h"
    1721#include "mmemory.h"
    … …  
    135139}
    136140
    137 #ifndef HAVE_SMALLGMP
    138141#ifdef MDEBUG
    139142void * mgAllocBlock( size_t t)
    … …  
    150153}
    151154#endif
    152 #endif
    153155
    154156#ifdef HAVE_SBRK
    … …  
    162164int mmInit( void )
    163165{
    164 #ifndef HAVE_SMALLGMP
    165166  if(mmIsInitialized==0)
    166167  {
    … …  
    171172#endif
    172173  }
    173 #endif
    174174  mmIsInitialized=1;
    175175  return 1;

  • Singular/mod2.h.in

    r17802f r12310e  
    200200#elif SIZEOF_EXPONENT == 2
    201201#define MAX_EXPONENT 0x7fff
    202 #else // SIZEOF_EXPONENT == 4
     202#else /* SIZEOF_EXPONENT == 4 */
    203203#define MAX_EXPONENT 0x7fffffff
    204204#endif

  • Singular/mpsr_Get.cc

    r17802f r12310e  
    33****************************************/
    44
    5 /* $Id: mpsr_Get.cc,v 1.18 1998-08-24 14:39:08 obachman Exp $ */
     5/* $Id: mpsr_Get.cc,v 1.19 1998-10-15 11:46:03 obachman Exp $ */
    66/***************************************************************
    77 *
    … …  
    4646                                mpsr_leftv mlv);
    4747static mpsr_Status_t GetPolyLeftv(MP_Link_pt link, MPT_Node_pt node,
    48                                 mpsr_leftv mlv);
     48                                mpsr_leftv mlv, BOOLEAN IsUnOrdered);
    4949static mpsr_Status_t GetPolyVectorLeftv(MP_Link_pt link, MPT_Node_pt node,
    50                                       mpsr_leftv mlv);
     50                                        mpsr_leftv mlv,
     51                                        BOOLEAN IsUnOrdered = FALSE);
    5152static mpsr_Status_t GetIdealLeftv(MP_Link_pt link, MPT_Node_pt node,
    52                                  mpsr_leftv mlv);
     53                                 mpsr_leftv mlv, BOOLEAN IsUnOrdered = FALSE);
    5354static mpsr_Status_t GetModuleLeftv(MP_Link_pt link, MPT_Node_pt node,
    54                                   mpsr_leftv mlv);
     55                                  mpsr_leftv mlv, BOOLEAN IsUnOrdered = FALSE);
    5556static mpsr_Status_t GetMatrixLeftv(MP_Link_pt link, MPT_Node_pt node,
    56                                   mpsr_leftv mlv);
     57                                  mpsr_leftv mlv, BOOLEAN IsUnOrdered = FALSE);
    5758static mpsr_Status_t GetMapLeftv(MP_Link_pt link, MPT_Node_pt node,
    5859                               mpsr_leftv mlv);
    … …  
    8990}
    9091
    91 inline BOOLEAN IsRingNode(MPT_Node_pt node, ring &r)
     92inline BOOLEAN IsRingNode(MPT_Node_pt node, ring &r, BOOLEAN &IsUnOrdered)
    9293{
    9394  BOOLEAN mv;
    9495  return
    9596    NodeCheck(node, MP_PolyDict, MP_CopPolyRing) &&
    96     mpsr_GetRingAnnots(node, r, mv) == MP_Success;
    97 }
    98 
    99 inline BOOLEAN IsPolyNode(MPT_Node_pt node, ring &r)
     97    mpsr_GetRingAnnots(node, r, mv, IsUnOrdered) == MP_Success;
     98}
     99
     100inline BOOLEAN IsPolyNode(MPT_Node_pt node, ring &r, BOOLEAN &IsUnOrdered)
    100101{
    101102  BOOLEAN mv;
    … …  
    105106    NodeCheck(node, MP_PolyDict, MP_CopPolyDenseDistPoly) &&
    106107    MPT_FindAnnot(node, MP_PolyDict, MP_AnnotPolyModuleVector) == NULL &&
    107     mpsr_GetRingAnnots(node, r, mv) == MP_Success;
    108 }
    109 
    110 inline BOOLEAN IsPolyVectorNode(MPT_Node_pt node, ring &r)
     108    mpsr_GetRingAnnots(node, r, mv, IsUnOrdered) == MP_Success;
     109}
     110
     111inline BOOLEAN IsPolyVectorNode(MPT_Node_pt node, ring &r,
     112                                BOOLEAN &IsUnOrdered)
    111113{
    112114  BOOLEAN mv;
    … …  
    116118    NodeCheck(node, MP_PolyDict, MP_CopPolyDenseDistPoly) &&
    117119    MPT_FindAnnot(node, MP_PolyDict, MP_AnnotPolyModuleVector) != NULL &&
    118     mpsr_GetRingAnnots(node, r, mv) == MP_Success;
    119 }
    120 
    121 inline BOOLEAN IsIdealNode(MPT_Node_pt node, ring &r)
     120    mpsr_GetRingAnnots(node, r, mv, IsUnOrdered) == MP_Success;
     121}
     122
     123inline BOOLEAN IsIdealNode(MPT_Node_pt node, ring &r,
     124                           BOOLEAN &IsUnOrdered)
    122125{
    123126  fr(NodeCheck(node, MP_PolyDict, MP_CopPolyIdeal));
    … …  
    128131    node->type == MP_CommonMetaOperatorType &&
    129132    node->numchild == 0 &&
    130     IsPolyNode(node, r);
    131 }
    132 
    133 inline BOOLEAN IsModuleNode(MPT_Node_pt node, ring &r)
     133    IsPolyNode(node, r, IsUnOrdered);
     134}
     135
     136inline BOOLEAN IsModuleNode(MPT_Node_pt node, ring &r, BOOLEAN &IsUnOrdered)
    134137{
    135138  fr(NodeCheck(node, MP_PolyDict, MP_CopPolyModule));
    … …  
    140143    node->type == MP_CommonMetaOperatorType &&
    141144    node->numchild == 0 &&
    142     IsPolyVectorNode(node, r);
    143 }
    144 
    145 inline BOOLEAN IsMatrixNode(MPT_Node_pt node, ring &r)
     145    IsPolyVectorNode(node, r, IsUnOrdered);
     146}
     147
     148inline BOOLEAN IsMatrixNode(MPT_Node_pt node, ring &r, BOOLEAN &IsUnOrdered)
    146149{
    147150  fr(NodeCheck(node, MP_MatrixDict, MP_CopMatrixDenseMatrix));
    … …  
    152155    node->type == MP_CommonMetaOperatorType &&
    153156    node->numchild == 0 &&
    154     IsPolyNode(node, r);
     157    IsPolyNode(node, r, IsUnOrdered);
    155158}
    156159
    … …  
    325328    // Now mlv is our leftv -- check whether r has an ordering set
    326329    if (mlv.r != NULL && mlv.r->order[0] == ringorder_unspec)
    327     {
    328       ring r = rCopy(mlv.r);
    329       r->order[0] = ringorder_lp;
    330       mpsr_rSetOrdSgn(r);
    331       mpsr_MapLeftv(mlv.lv, mlv.r, r);
    332       rKill(mlv.r);
    333       mlv.r = r;
    334     }
     330    {
     331        ring r = rCopy(mlv.r);
     332        r->order[0] = ringorder_lp;
     333        mpsr_rSetOrdSgn(r);
     334        mpsr_MapLeftv(mlv.lv, mlv.r, r);
     335        rKill(mlv.r);
     336        mlv.r = r;
     337    }
     338     
    335339    mpsr_SetCurrRingHdl(mlv.r);
    336340
    … …  
    406410 ***************************************************************/
    407411mpsr_Status_t mpsr_GetCommonOperatorLeftv(MP_Link_pt link,
    408                                         MPT_Node_pt node,
    409                                         mpsr_leftv mlv,
    410                                         short quote)
     412                                          MPT_Node_pt node,
     413                                          mpsr_leftv mlv,
     414                                          short quote)
    411415{
    412416  mpsr_assume(node->type == MP_CommonOperatorType);
    413 
     417  BOOLEAN IsUnOrdered;
     418 
    414419  // Check for Singular data types
    415420  // IntVec
    … …  
    420425    return GetIntMatLeftv(link, node, mlv);
    421426  // Ring
    422   else if (IsRingNode(node, mlv->r))
     427  else if (IsRingNode(node, mlv->r, IsUnOrdered))
    423428    return GetRingLeftv(link, node, mlv);
    424429  // Poly
    425   else if (IsPolyNode(node, mlv->r))
    426     return GetPolyLeftv(link, node, mlv);
     430  else if (IsPolyNode(node, mlv->r, IsUnOrdered))
     431    return GetPolyLeftv(link, node, mlv, IsUnOrdered);
    427432  // PolyVector
    428   else if (IsPolyVectorNode(node, mlv->r))
    429     return GetPolyVectorLeftv(link, node, mlv);
     433  else if (IsPolyVectorNode(node, mlv->r, IsUnOrdered))
     434    return GetPolyVectorLeftv(link, node, mlv, IsUnOrdered);
    430435  // Ideal
    431   else if (IsIdealNode(node, mlv->r))
    432     return GetIdealLeftv(link, node, mlv);
     436  else if (IsIdealNode(node, mlv->r, IsUnOrdered))
     437    return GetIdealLeftv(link, node, mlv, IsUnOrdered);
    433438  // Module
    434   else if (IsModuleNode(node, mlv->r))
    435     return GetModuleLeftv(link, node, mlv);
     439  else if (IsModuleNode(node, mlv->r, IsUnOrdered))
     440    return GetModuleLeftv(link, node, mlv, IsUnOrdered);
    436441  // Matrix
    437   else if (IsMatrixNode(node, mlv->r))
    438     return GetMatrixLeftv(link, node, mlv);
     442  else if (IsMatrixNode(node, mlv->r, IsUnOrdered))
     443    return GetMatrixLeftv(link, node, mlv, IsUnOrdered);
    439444  else if (IsQuitNode(node))
    440445    return GetQuitLeftv(mlv);
    … …  
    549554
    550555static mpsr_Status_t GetPolyLeftv(MP_Link_pt link, MPT_Node_pt node,
    551                                 mpsr_leftv mlv)
     556                                  mpsr_leftv mlv, BOOLEAN IsUnOrdered)
    552557{
    553558  poly p;
    … …  
    556561 
    557562  failr(mpsr_GetPoly(link, p, node->numchild, mlv->r));
     563  if (IsUnOrdered) p = pOrdPolyMerge(p);
     564  pTest(p);
    558565  mlv->lv = mpsr_InitLeftv(POLY_CMD, (void *) p);
    559566  return mpsr_Success;
    … …  
    561568
    562569static mpsr_Status_t GetPolyVectorLeftv(MP_Link_pt link, MPT_Node_pt node,
    563                                       mpsr_leftv mlv)
     570                                      mpsr_leftv mlv, BOOLEAN IsUnOrdered)
    564571{
    565572  poly p;
    … …  
    568575 
    569576  failr(mpsr_GetPolyVector(link, p, node->numchild, mlv->r));
     577  if (IsUnOrdered) p = pOrdPolyMerge(p);
     578  pTest(p);
    570579  mlv->lv = mpsr_InitLeftv(VECTOR_CMD, (void *) p);
    571580  return mpsr_Success;
    … …  
    573582
    574583static mpsr_Status_t GetIdealLeftv(MP_Link_pt link, MPT_Node_pt node,
    575                                  mpsr_leftv mlv)
     584                                 mpsr_leftv mlv, BOOLEAN IsUnOrdered)
    576585{
    577586  MP_NumChild_t nc = node->numchild, i;
    … …  
    585594    mp_failr(IMP_GetUint32(link, &nmon));
    586595    failr(mpsr_GetPoly(link, id->m[i], nmon, r));
    587   }
    588  
     596    if (IsUnOrdered) id->m[i] = pOrdPolyMerge(id->m[i]);
     597  }
     598  idTest(id);
    589599  mlv->lv = mpsr_InitLeftv(IDEAL_CMD, (void *) id);
    590600  return mpsr_Success;
    … …  
    592602
    593603static mpsr_Status_t GetModuleLeftv(MP_Link_pt link, MPT_Node_pt node,
    594                                   mpsr_leftv mlv)
     604                                  mpsr_leftv mlv, BOOLEAN IsUnOrdered)
    595605{
    596606  MP_NumChild_t nc = node->numchild, i;
    … …  
    611621    mp_failr(IMP_GetUint32(link, &nmon));
    612622    failr(mpsr_GetPolyVector(link, id->m[i], nmon, r));
     623    if (IsUnOrdered) id->m[i] = pOrdPolyMerge(id->m[i]);
    613624  }
    614625  if (rank == 1)
    615626    id->rank = idRankFreeModule(id);
    616 
     627  idTest(id);
    617628  mlv->lv = mpsr_InitLeftv(MODUL_CMD, (void *) id);
    618629  return mpsr_Success;
    … …  
    620631
    621632static mpsr_Status_t GetMatrixLeftv(MP_Link_pt link, MPT_Node_pt node,
    622                                   mpsr_leftv mlv)
     633                                  mpsr_leftv mlv, BOOLEAN IsUnOrdered)
    623634{
    624635  MP_NumChild_t nc = node->numchild, row = nc, col = 1, i;
    … …  
    648659    mp_failr(IMP_GetUint32(link, &nmon));
    649660    failr(mpsr_GetPoly(link, mp->m[i], nmon, mlv->r));
     661    if (IsUnOrdered) mp->m[i] = pOrdPolyMerge(mp->m[i]);
    650662  }
    651663
    … …  
    821833    mpsr_sleftv mlv;
    822834    mpsr_Status_t status;
     835    BOOLEAN IsUnOrdered;
    823836
    824837    // we would like to get polys and ideals directly
    825     if (IsPolyNode(node, mlv.r))
    826       status = GetPolyLeftv(link, node, &mlv);
     838    if (IsPolyNode(node, mlv.r, IsUnOrdered))
     839      status = GetPolyLeftv(link, node, &mlv, IsUnOrdered);
    827840    // Ideal
    828     else if (IsIdealNode(node, mlv.r))
    829       status = GetIdealLeftv(link, node, &mlv);
     841    else if (IsIdealNode(node, mlv.r, IsUnOrdered))
     842      status = GetIdealLeftv(link, node, &mlv, IsUnOrdered);
    830843    else
    831844      return MPT_NotExternalData;

  • Singular/mpsr_Get.h

    r17802f r12310e  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mpsr_Get.h,v 1.3 1998-06-02 15:29:59 Singular Exp $ */
     4/* $Id: mpsr_Get.h,v 1.4 1998-10-15 11:46:03 obachman Exp $ */
    55/***************************************************************
    66 *
    … …  
    5858
    5959// from mpsr_GetPoly.cc
    60 extern mpsr_Status_t mpsr_GetRingAnnots(MPT_Node_pt node, ring &r, BOOLEAN &mv);
     60extern mpsr_Status_t mpsr_GetRingAnnots(MPT_Node_pt node, ring &r,
     61                                        BOOLEAN &mv, BOOLEAN &IsUnOrdered);
    6162extern mpsr_Status_t mpsr_GetPoly(MP_Link_pt link, poly &p, MP_Uint32_t nmon,
    6263                                ring cring);

  • Singular/mpsr_GetPoly.cc

    r17802f r12310e  
    33****************************************/
    44
    5 /* $Id: mpsr_GetPoly.cc,v 1.17 1998-05-25 21:17:16 obachman Exp $ */
     5/* $Id: mpsr_GetPoly.cc,v 1.18 1998-10-15 11:46:04 obachman Exp $ */
    66
    77/***************************************************************
    … …  
    8181static mpsr_Status_t GetProtoTypeAnnot(MPT_Node_pt node, ring r, BOOLEAN mv,
    8282                                     ring &subring);
    83 static mpsr_Status_t GetOrderingAnnot(MPT_Node_pt node, ring r, BOOLEAN mv);
     83static mpsr_Status_t GetOrderingAnnot(MPT_Node_pt node, ring r, BOOLEAN mv,
     84                                      BOOLEAN &IsUnOrdered);
    8485static mpsr_Status_t GetSimpleOrdering(MPT_Node_pt node, ring r, short i);
    8586static mpsr_Status_t GetVarNamesAnnot(MPT_Node_pt node, ring r);
    … …  
    437438  pp->next = NULL;
    438439
    439   pTest(p);
    440440  return mpsr_Success;
    441441}
    … …  
    503503  pp->next = NULL;
    504504
    505   pTest(p);
    506505  return mpsr_Success;
    507506}
    … …  
    523522// Singular ring (in which case r is the respective ring) or,
    524523// MP_Failure, if not
    525 mpsr_Status_t mpsr_GetRingAnnots(MPT_Node_pt node, ring &r, BOOLEAN &mv)
     524mpsr_Status_t mpsr_GetRingAnnots(MPT_Node_pt node, ring &r,
     525                                 BOOLEAN &mv, BOOLEAN &IsUnOrdered)
    526526{
    527527  sip_sring r1, *subring;
    … …  
    550550    Warn("GetVarNamesAnnot: using default variable names");
    551551
    552   if (GetOrderingAnnot(node,r, mv) != mpsr_Success)
     552  if (GetOrderingAnnot(node,r, mv, IsUnOrdered) != mpsr_Success)
    553553    Warn("GetOrderingAnnot: using unspec ordering");
    554554
    … …  
    595595         
    596596static mpsr_Status_t GetProtoTypeAnnot(MPT_Node_pt node, ring r, BOOLEAN mv,
    597                                      ring &subring)
     597                                       ring &subring)
    598598{
    599599  MPT_Annot_pt annot = NULL;
    … …  
    694694  {
    695695    // alg numbers
    696     BOOLEAN mv2;
     696    BOOLEAN mv2, IsUnOrdered;
    697697    int i;
    698698
    … …  
    708708           node->numchild == 0);
    709709    // GetRingAnnots
    710     failr(mpsr_GetRingAnnots(node, subring, mv2));
     710    failr(mpsr_GetRingAnnots(node, subring, mv2, IsUnOrdered));
    711711    // Check whether the ring can be "coerced" to an algebraic number
    712712    falser(subring->ch >= 0 &&
    713713           subring->order[0] == ringorder_lp &&
    714714           subring->order[2] == 0 &&
    715            mv2 == FALSE);
     715           mv2 == FALSE &&
     716           IsUnOrdered == FALSE);
    716717
    717718    // Now do the coercion
    … …  
    780781}
    781782
    782 static mpsr_Status_t GetOrderingAnnot(MPT_Node_pt node, ring r, BOOLEAN mv)
    783 {
    784   MPT_Annot_pt annot = MPT_FindAnnot(node, MP_PolyDict, MP_AnnotPolyOrdering);
     783static mpsr_Status_t GetOrderingAnnot(MPT_Node_pt node, ring r,
     784                                      BOOLEAN mv, BOOLEAN &IsUnOrdered)
     785{
     786  MPT_Annot_pt annot = MPT_FindAnnot(node, MP_PolyDict,MP_AnnotPolyOrdering);
    785787  mpsr_Status_t status = mpsr_Success;
    786788
    787   if (annot == NULL || annot->value == NULL) status = mpsr_Failure;
     789  IsUnOrdered = FALSE;
     790  if (annot == NULL || annot->value == NULL)
     791  {
     792    annot = MPT_FindAnnot(node, MP_PolyDict, MP_AnnotShouldHavePolyOrdering);
     793    if (annot == NULL || annot->value == NULL)
     794      status = mpsr_Failure;
     795    else
     796      IsUnOrdered = TRUE;
     797  }
    788798
    789799  if (status == mpsr_Success) node =  annot->value->node;
    … …  
    869879  }
    870880  else
     881  {
     882    IsUnOrdered = FALSE;
    871883    r->order[0] = ringorder_unspec;
     884  }
    872885 
    873886  return mpsr_rSetOrdSgn(r);

  • Singular/mpsr_Tok.cc

    r17802f r12310e  
    33****************************************/
    44
    5 /* $Id: mpsr_Tok.cc,v 1.17 1998-09-08 07:46:34 Singular Exp $ */
     5/* $Id: mpsr_Tok.cc,v 1.18 1998-10-15 11:46:05 obachman Exp $ */
    66
    77/***************************************************************
    … …  
    252252  DUMP_CMD,
    253253  GETDUMP_CMD,
    254   STATUS_CMD
     254  STATUS_CMD,
     255  LIB_CMD
    255256};
    256257

  • Singular/polys-impl.h

    r17802f r12310e  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: polys-impl.h,v 1.23 1998-08-05 14:09:45 obachman Exp $ */
     6/* $Id: polys-impl.h,v 1.24 1998-10-15 11:46:06 obachman Exp $ */
    77
    88/***************************************************************
    … …  
    121121
    122122#define _pExpIndex(i)                                   \
    123   (pVarOffset > (SIZEOF_LONG / SIZEOF_EXPONENT) - 1 ?   \
     123  (pVarOffset > (SIZEOF_LONG / SIZEOF_EXPONENT) - 1?   \
    124124   pVarOffset - (i) : pVarOffset + (i))
    125125#define _pRingExpIndex(r, i)                                \
    126   ((r)->VarOffset > (SIZEOF_LONG / SIZEOF_EXPONENT) - 1 ?   \
     126  ((r)->VarOffset > (SIZEOF_LONG / SIZEOF_EXPONENT) - 1?   \
    127127   (r)->VarOffset - (i) : (r)->VarOffset + (i))
    128128

  • Singular/sing_mp.cc

    r17802f r12310e  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: sing_mp.cc,v 1.20 1998-10-14 10:18:56 obachman Exp $ */
     4/* $Id: sing_mp.cc,v 1.21 1998-10-15 11:46:06 obachman Exp $ */
    55
    66/*
    … …  
    2929#endif
    3030
    31 #define MPSR_DEBUG
    32 
    3331#ifdef MPSR_DEBUG
    3432#define MP_SET_LINK_OPTIONS(link) \
    … …  
    470468  while(1)
    471469  {
     470    errorreported = FALSE;
    472471    v = slRead(silink, v);
    473     if (feErrors != NULL)
     472    if (feErrors != NULL && *feErrors != '\0')
    474473    {
    475474      if (v != NULL) v->CleanUp();
    476475      v = mpsr_InitLeftv(STRING_CMD, (void *) mstrdup(feErrors));
    477       Free(feErrors, feErrorsLen);
    478       feErrors = NULL;
     476      *feErrors = '\0';
    479477    }
    480478

  • Singular/spolys.cc

    r17802f r12310e  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: spolys.cc,v 1.15 1998-09-07 15:25:56 Singular Exp $ */
     4/* $Id: spolys.cc,v 1.16 1998-10-15 11:46:07 obachman Exp $ */
    55
    66/*
    … …  
    710710}
    711711
    712 poly spDSpolyCreate(poly p1,poly p2,poly spNoether)
     712poly spDSpolyCreate(poly p1,poly p2,poly spNoether, spSpolyLoopProc dummy)
    713713{
    714714  poly m1=pOne();

  • Singular/tesths.cc

    r17802f r12310e  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: tesths.cc,v 1.52 1998-09-22 14:09:05 Singular Exp $ */
     4/* $Id: tesths.cc,v 1.53 1998-10-15 11:46:08 obachman Exp $ */
    55
    66/*
    … …  
    5353#define LON_MP_PORT         "MPport"
    5454#define LON_MP_HOST         "MPhost"
     55#define LON_NO_WARN         "no-warn"
     56#define LON_NO_OUT          "no-out"
    5557// undocumented options
    5658#ifdef HAVE_MPSR
    … …  
    7880  {LON_NO_STDLIB,         0,  0,  LONG_OPTION_RETURN},
    7981  {LON_NO_RC,             0,  0,  LONG_OPTION_RETURN},
     82  {LON_NO_WARN,           0,  0,  LONG_OPTION_RETURN},
     83  {LON_NO_OUT,           0,  0,  LONG_OPTION_RETURN},
    8084  {LON_MIN_TIME,          1,  0,  LONG_OPTION_RETURN},
    8185#ifdef HAVE_MPSR
    … …  
    111115#endif
    112116  {LON_HELP,        0,          "Print help message and exit",                          0},
    113   {LON_QUIET,       0,          "Do not print start-up banner and warnings",            0},
     117  {LON_QUIET,       0,          "Do not print start-up banner and library load messages",            0},
    114118  {LON_NO_TTY,      0,          "Do not redefine the terminal characteristics",         0},
    115119  {LON_VERSION,     0,          "Print extended version and configuration info",        0},
    … …  
    123127  {LON_NO_STDLIB,   0,          "Do not load `standard.lib' on start-up",               0},
    124128  {LON_NO_RC,       0,          "Do not execute `.singularrc' file on start-up",        0},
     129  {LON_NO_WARN,     0,          "Do not display warning messages",        0},
     130  {LON_NO_OUT,      0,          "Suppress all output",        0},
    125131  {LON_MIN_TIME,    "SECS",     "Do not display times smaller than SECS (in seconds)",  "0.5"},
    126132#ifdef HAVE_MPSR
    … …  
    412418            load_rc = FALSE;
    413419            mainSetSingOptionValue(LON_NO_RC, (char*) 1);
     420          }
     421          else if (strcmp(longopts[option_index].name, LON_NO_WARN) == 0)
     422          {
     423            feWarn = FALSE;
     424            mainSetSingOptionValue(LON_NO_WARN, (char*) 1);
     425          }
     426          else if (strcmp(longopts[option_index].name, LON_NO_OUT) == 0)
     427          {
     428            feOut = FALSE;
     429            mainSetSingOptionValue(LON_NO_OUT, (char*) 1);
    414430          }
    415431          else if (strcmp(longopts[option_index].name, LON_MIN_TIME) == 0)

  • Singular/utils.cc

    r17802f r12310e  
    55#include "getopt.h"
    66#include "utils.h"
     7#ifdef __MWERKS__
    78#define __GNU_LIBRARY__
    89#include "getopt.h"
     10#endif
    911
    1012extern FILE *yylpin;
Note: See TracChangeset for help on using the changeset viewer.