Changeset e10683 in git

Timestamp:

Nov 30, 2000, 5:46:09 PM (23 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', 'd1ec153efbb92b07a03c829a7f893fe854f169d2')

Children:

379305282702a4d34d62437d3dfe5bf09925c710

Parents:

50268a871f223956bed4c2b84352e38f543a574b

Message:

*hannes: pmInit stuff


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

Location:

Singular

Files:

• polys.cc (modified) (6 diffs)
• polys.h (modified) (10 diffs)

Singular/polys.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: polys.cc,v 1.68 2000-11-09 16:32:53 obachman Exp $ */
+/* $Id: polys.cc,v 1.69 2000-11-30 16:46:09 Singular Exp $ */
 
 /*
@@ -55 +55 @@
   pLDeg=r->pLDeg;
   pLexOrder=r->LexOrder;
-  
+
   if (complete)
   {
@@ -140 +140 @@
 * convert monomial given as string to poly, e.g. 1x3y5z
 */
-poly pmInit(char *st, BOOLEAN &ok)
+char * p_Read(char *st, poly &rc, ring r)
 {
   int i,j;
-  ok=FALSE;
-  BOOLEAN b=FALSE;
-  poly rc = pInit();
-  char *s = nRead(st,&(rc->coef));
+  rc = p_Init(r);
+  char *s = r->cf->nRead(st,&(rc->coef));
   if (s==st)
   /* i.e. it does not start with a coeff: test if it is a ringvar*/
@@ -154 +152 @@
     {
       pIncrExp(rc,1+j);
+      while (*s!='\0') s++;
       goto done;
     }
   }
-  else
-    b=TRUE;
   while (*s!='\0')
   {
@@ -164 +161 @@
     ss[0] = *s++;
     ss[1] = '\0';
-    j = rIsRingVar(ss);
+    j = r_IsRingVar(ss,r);
     if (j >= 0)
     {
       s = eati(s,&i);
-      pAddExp(rc,1+j, (Exponent_t)i);
+      p_AddExp(rc,1+j, (Exponent_t)i, r);
     }
     else
     {
-      if ((s!=st)&&isdigit(st[0]))
-      {
-        errorreported=TRUE;
-      }
-      pDelete(&rc);
-      return NULL;
+      s--;
+      return s;
     }
   }
 done:
+  if (r->cf->nIsZero(pGetCoeff(rc))) p_DeleteLm(&rc,r);
+  else
+  {
+    p_Setm(rc,r);
+  }
+  return s;
+}
+
+poly pmInit(char *st, BOOLEAN &ok)
+{
+  poly p;
+  char *s=p_Read(st,p,currRing);
+  if (*s!='\0')
+  {
+    if ((s!=st)&&isdigit(st[0]))
+    {
+      errorreported=TRUE;
+    }
+    ok=FALSE;
+    pDelete(&p);
+    return NULL;
+  }
   ok=!errorreported;
-  if (nIsZero(pGetCoeff(rc))) pDeleteLm(&rc);
-  else
-  {
-    pSetm(rc);
-  }
-  return rc;
+  return p;
 }
 
@@ -229 +239 @@
   return q;
 }
-
 
 /*2

Singular/polys.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: polys.h,v 1.47 2000-11-23 17:40:02 Singular Exp $ */
+/* $Id: polys.h,v 1.48 2000-11-30 16:46:08 Singular Exp $ */
 /*
 * ABSTRACT - all basic methods to manipulate polynomials of the
@@ -20 +20 @@
           - debugging only if PDEBUG >= 2
           - normally inlined, unless PDEBUG >= 2 || NO_INLINE2
- Level 1: operations on monomials with time proportional to length 
+ Level 1: operations on monomials with time proportional to length
           - implemented in: pInline1.h
           - debugging only if PDEBUG >= 1
-          - normally inlined, unless PDEBUG >= 1 || NO_INLINE1 
+          - normally inlined, unless PDEBUG >= 1 || NO_INLINE1
  Level 0: short operations on polynomials with time proportional to
           length of poly
@@ -31 +31 @@
             #define DO_PINLINE0
             #include "pInline0.h"
- Misc   : operations on polynomials which do not fit in any of the 
+ Misc   : operations on polynomials which do not fit in any of the
           above categories
           - implemented in: polys*.cc
@@ -42 +42 @@
  However, PDEBUG will only be in effect, if !NDEBUG.
 
- All p_* operations take as last argument a ring 
- and are ring independent. Their corresponding p* operations are usually 
+ All p_* operations take as last argument a ring
+ and are ring independent. Their corresponding p* operations are usually
  just macros to the respective p_*(..,currRing).
 
@@ -62 +62 @@
 #define pSetOrder(p, o)     p_SetOrder(p, o, currRing)
 
-// Component 
+// Component
 #define pGetComp(p)         _p_GetComp(p, currRing)
 #define pSetComp(p,v)       p_SetComp(p,v, currRing)
@@ -83 +83 @@
 /***************************************************************
  *
- * Allocation/Initalization/Deletion 
+ * Allocation/Initalization/Deletion
  * except for pDeleteLm and pHead, all polys must be != NULL
  *
@@ -91 +91 @@
 // allocates a new monomial and initializes everything to 0
 #define pInit()         p_Init(currRing)
-// like pInit, except that expvector is initialized to that of p, 
+// like pInit, except that expvector is initialized to that of p,
 // p must be != NULL
 #define pLmInit(p)  p_LmInit(p, currRing)
-// returns newly allocated copy of Lm(p), coef is copied, next=NULL, 
+// returns newly allocated copy of Lm(p), coef is copied, next=NULL,
 // p might be NULL
 #define pHead(p)        p_Head(p, currRing)
-// if *p_ptr != NULL, delete p_ptr->coef, *p_ptr, and set *p_ptr to 
+// if *p_ptr != NULL, delete p_ptr->coef, *p_ptr, and set *p_ptr to
 // pNext(*p_ptr)
 static inline void pDeleteLm(poly *p) {p_DeleteLm(p, currRing);}
@@ -155 +155 @@
 #define pCmp(p1, p2)    p_Cmp(p1, p2, currRing)
 
-  
-/***************************************************************
- *
- * Divisiblity tests, args must be != NULL, except for 
+
+/***************************************************************
+ *
+ * Divisiblity tests, args must be != NULL, except for
  * pDivisbleBy
  *
  ***************************************************************/
 // returns TRUE, if leading monom of a divides leading monom of b
-// i.e., if there exists a expvector c > 0, s.t. b = a + c; 
+// i.e., if there exists a expvector c > 0, s.t. b = a + c;
 #define pDivisibleBy(a, b)  p_DivisibleBy(a,b,currRing)
 // like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
@@ -282 +282 @@
 
 
-poly      pmInit(char *s, BOOLEAN &ok);   /* monom -> poly */
+poly      pmInit(char *s, BOOLEAN &ok);     /* monom -> poly, interpreter */
+char *    p_Read(char *s, poly &p, ring r); /* monom -> poly */
 void      ppDelete(poly * a, ring r);
 
@@ -301 +302 @@
 int pMaxCompProc(poly p);
 
-#define   pOneComp(p)       p_OneComp(p, currRing) 
+#define   pOneComp(p)       p_OneComp(p, currRing)
 #define   pSetCompP(a,i)    p_SetCompP(a, i, currRing)