Changeset 4a822ba in git


Ignore:
Timestamp:
Sep 12, 2016, 3:10:43 PM (7 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
0816f71425281ce41a6a64263309ea59a13ade6e
Parents:
395731e22e1afda9d31e802ed31db98790d11c52
git-author:
Hans Schoenemann <hannes@mathematik.uni-kl.de>2016-09-12 15:10:43+02:00
git-committer:
Hans Schoenemann <hannes@mathematik.uni-kl.de>2016-09-12 15:11:11+02:00
Message:
adjust poly, matrix etc comparisons
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • Singular/iparith.cc

    r395731e r4a822ba  
    431431  return FALSE;
    432432}
     433static BOOLEAN jjCOMPARE_MA(leftv res, leftv u, leftv v)
     434{
     435  //Print("in: >>%s<<\n",my_yylinebuf);
     436  matrix a=(matrix)u->Data();
     437  matrix b=(matrix)v->Data();
     438  int r=mp_Compare(a,b,currRing);
     439  switch  (iiOp)
     440  {
     441    case '<':
     442      res->data  = (char *) (long)(r < 0);
     443      break;
     444    case '>':
     445      res->data  = (char *) (long)(r > 0);
     446      break;
     447    case LE:
     448      res->data  = (char *) (long)(r <= 0);
     449      break;
     450    case GE:
     451      res->data  = (char *) (long)(r >= 0);
     452      break;
     453    case EQUAL_EQUAL:
     454    case NOTEQUAL: /* negation handled by jjEQUAL_REST */
     455      res->data  = (char *)(long) (r == 0);
     456      break;
     457  }
     458  jjEQUAL_REST(res,u,v);
     459  return FALSE;
     460}
    433461static BOOLEAN jjCOMPARE_P(leftv res, leftv u, leftv v)
    434462{
    435463  poly p=(poly)u->Data();
    436464  poly q=(poly)v->Data();
    437   int r=pCmp(p,q);
    438   if (r==0)
    439   {
    440     number h=nSub(pGetCoeff(p),pGetCoeff(q));
    441     /* compare lead coeffs */
    442     r = -1+nIsZero(h)+2*nGreaterZero(h); /* -1: <, 0:==, 1: > */
    443     nDelete(&h);
    444   }
    445   else if (p==NULL)
    446   {
    447     if (q==NULL)
    448     {
    449       /* compare 0, 0 */
    450       r=0;
    451     }
    452     else if(pIsConstant(q))
    453     {
    454       /* compare 0, const */
    455       r = 1-2*nGreaterZero(pGetCoeff(q)); /* -1: <, 1: > */
    456     }
    457   }
    458   else if (q==NULL)
    459   {
    460     if (pIsConstant(p))
    461     {
    462       /* compare const, 0 */
    463       r = -1+2*nGreaterZero(pGetCoeff(p)); /* -1: <, 1: > */
    464     }
    465   }
     465  int r=p_Compare(p,q,currRing);
    466466  switch  (iiOp)
    467467  {

  • Singular/table.h

    r395731e r4a822ba  
    463463,{D(jjCOMPARE_P), '<',            INT_CMD,        POLY_CMD,   POLY_CMD, ALLOW_PLURAL | ALLOW_RING}
    464464,{D(jjCOMPARE_P), '<',            INT_CMD,        VECTOR_CMD, VECTOR_CMD, ALLOW_PLURAL | ALLOW_RING}
     465#if 0
     466,{D(jjCOMPARE_MA),'<',            INT_CMD,        MATRIX_CMD, MATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
     467,{D(jjWRONG2),    '<',            INT_CMD,        MATRIX_CMD, INTVEC_CMD, ALLOW_PLURAL | ALLOW_RING}
     468,{D(jjWRONG2),    '<',            INT_CMD,        INTVEC_CMD, MATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
     469,{D(jjWRONG2),    '<',            INT_CMD,        MATRIX_CMD, INTMAT_CMD, ALLOW_PLURAL | ALLOW_RING}
     470,{D(jjWRONG2),    '<',            INT_CMD,        INTMAT_CMD, MATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
     471,{D(jjWRONG2),    '<',            INT_CMD,        MATRIX_CMD, NUMBER_CMD, ALLOW_PLURAL | ALLOW_RING}
     472,{D(jjWRONG2),    '<',            INT_CMD,        NUMBER_CMD, MATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
     473,{D(jjWRONG2),    '<',            INT_CMD,        MATRIX_CMD, POLY_CMD,   ALLOW_PLURAL | ALLOW_RING}
     474,{D(jjWRONG2),    '<',            INT_CMD,        POLY_CMD,   MATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
     475,{D(jjWRONG2),    '<',            INT_CMD,        MATRIX_CMD, VECTOR_CMD, ALLOW_PLURAL | ALLOW_RING}
     476,{D(jjWRONG2),    '<',            INT_CMD,        VECTOR_CMD, MATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
     477,{D(jjWRONG2),    '<',            INT_CMD,        MATRIX_CMD, IDEAL_CMD,  ALLOW_PLURAL | ALLOW_RING}
     478,{D(jjWRONG2),    '<',            INT_CMD,        IDEAL_CMD,  MATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
     479,{D(jjWRONG2),    '<',            INT_CMD,        MATRIX_CMD, MODUL_CMD,  ALLOW_PLURAL | ALLOW_RING}
     480,{D(jjWRONG2),    '<',            INT_CMD,        MODUL_CMD,  MATRIX_CMD, ALLOW_PLURAL | ALLOW_RING}
     481#endif
    465482,{D(jjGE_I),      GE,             INT_CMD,        INT_CMD,    INT_CMD, ALLOW_PLURAL | ALLOW_RING}
    466483,{D(jjGE_BI),     GE,             INT_CMD,        BIGINT_CMD, BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}

  • kernel/ideals.cc

    r395731e r4a822ba  
    25492549int pCompare_qsort(const void *a, const void *b)
    25502550{
    2551   int res = p_Compare(((poly_sort *)a)->p, ((poly_sort *)b)->p,currRing);
    2552   return(res);
     2551  return (p_Compare(((poly_sort *)a)->p, ((poly_sort *)b)->p,currRing));
    25532552}
    25542553

  • libpolys/polys/matpol.cc

    r395731e r4a822ba  
    574574    v = v->next;
    575575  }
     576}
     577
     578int mp_Compare(matrix a, matrix b, const ring R)
     579{
     580  if (MATCOLS(a)<MATCOLS(b)) return -1;
     581  else if (MATCOLS(a)>MATCOLS(b)) return 1;
     582  if (MATROWS(a)<MATROWS(b)) return -1;
     583  else if (MATROWS(a)<MATROWS(b)) return 1;
     584
     585  unsigned ii=MATCOLS(a)*MATROWS(b)-1;
     586  unsigned j=0;
     587  int r=0;
     588  while (j<=ii)
     589  {
     590    r=p_Compare(a->m[j],b->m[j],R);
     591    if (r!=0) return r;
     592    j++;
     593  }
     594  return r;
     595}
     596
     597BOOLEAN mp_Equal(matrix a, matrix b, const ring R)
     598{
     599  if ((MATCOLS(a)!=MATCOLS(b)) || (MATROWS(a)!=MATROWS(b)))
     600    return FALSE;
     601  int i=MATCOLS(a)*MATROWS(a)-1;
     602  while (i>=0)
     603  {
     604    if (a->m[i]==NULL)
     605    {
     606      if (b->m[i]!=NULL) return FALSE;
     607    }
     608    else if (b->m[i]==NULL) return FALSE;
     609    else if (p_Cmp(a->m[i],b->m[i], R)!=0) return FALSE;
     610    i--;
     611  }
     612  i=MATCOLS(a)*MATROWS(a)-1;
     613  while (i>=0)
     614  {
     615    if(!p_EqualPolys(a->m[i],b->m[i], R)) return FALSE;
     616    i--;
     617  }
     618  return TRUE;
    576619}
    577620
    … …  
    16681711  return (result);
    16691712}
    1670 int mp_Compare(matrix a, matrix b, const ring R)
    1671 {
    1672   if (MATCOLS(a)<MATCOLS(b)) return -1;
    1673   else if (MATCOLS(a)>MATCOLS(b)) return 1;
    1674   if (MATROWS(a)<MATROWS(b)) return -1;
    1675   else if (MATROWS(a)<MATROWS(b)) return 1;
    1676 
    1677   int i=MATCOLS(a)*MATROWS(b)-1;
    1678   int c;
    1679   while (i>=0)
    1680   {
    1681     if (a->m[i]==NULL)
    1682     {
    1683       if (b->m[i]!=NULL) return -1;
    1684     }
    1685     else
    1686       if (b->m[i]==NULL) return 1;
    1687       else if ((c=p_Cmp(a->m[i],b->m[i], R))!=0) return c;
    1688     i--;
    1689   }
    1690   unsigned ii=MATCOLS(a)*MATROWS(b)-1;
    1691   unsigned j=0;
    1692   int r=0;
    1693   while (j<=ii)
    1694   {
    1695     r=p_Compare(a->m[j],b->m[j],R);
    1696     if (r!=0) return r;
    1697     j++;
    1698   }
    1699   return r;
    1700 }
    1701 
    1702 BOOLEAN mp_Equal(matrix a, matrix b, const ring R)
    1703 {
    1704   int r=mp_Compare(a,b,R);
    1705   return (r==0);
    1706 }
    1707 

  • libpolys/polys/monomials/p_polys.cc

    r395731e r4a822ba  
    47104710/***************************************************************/
    47114711/*
    4712 * compare the leading terms of a and b
    4713 */
    4714 static int tCompare(const poly a, const poly b, const ring R)
    4715 {
    4716   if (b == NULL) return(a != NULL);
    4717   if (a == NULL) return(-1);
    4718 
    4719   /* a != NULL && b != NULL */
    4720   int r = p_LmCmp(a, b,R);
    4721   if (r != 0) return(r);
    4722   number h = n_Sub(pGetCoeff(a), pGetCoeff(b),R->cf);
    4723   r = -1 + n_IsZero(h,R->cf) + 2*n_GreaterZero(h,R->cf);   /* -1: <, 0:==, 1: > */
    4724   n_Delete(&h,R->cf);
    4725   return(r);
    4726 }
    4727 
    4728 /*
    47294712* compare a and b
    47304713*/
    47314714int p_Compare(const poly a, const poly b, const ring R)
    47324715{
    4733   int r = tCompare(a, b,R);
    4734   if (r != 0) return(r);
    4735 
    4736   poly aa = a;
    4737   poly bb = b;
    4738   while (r == 0 && aa != NULL && bb != NULL)
    4739   {
    4740     pIter(aa);
    4741     pIter(bb);
    4742     r = tCompare(aa, bb,R);
     4716  int r=p_Cmp(a,b,R);
     4717  if ((r==0)&&(a!=NULL))
     4718  {
     4719    number h=n_Sub(pGetCoeff(a),pGetCoeff(b),R->cf);
     4720    /* compare lead coeffs */
     4721    r = -1+n_IsZero(h,R->cf)+2*n_GreaterZero(h,R->cf); /* -1: <, 0:==, 1: > */
     4722    n_Delete(&h,R->cf);
     4723  }
     4724  else if (a==NULL)
     4725  {
     4726    if (b==NULL)
     4727    {
     4728      /* compare 0, 0 */
     4729      r=0;
     4730    }
     4731    else if(p_IsConstant(b,R))
     4732    {
     4733      /* compare 0, const */
     4734      r = 1-2*n_GreaterZero(pGetCoeff(b),R->cf); /* -1: <, 1: > */
     4735    }
     4736  }
     4737  else if (b==NULL)
     4738  {
     4739    if (p_IsConstant(a,R))
     4740    {
     4741      /* compare const, 0 */
     4742      r = -1+2*n_GreaterZero(pGetCoeff(a),R->cf); /* -1: <, 1: > */
     4743    }
    47434744  }
    47444745  return(r);
Note: See TracChangeset for help on using the changeset viewer.