Changeset b39bc1f in git

Timestamp:

Oct 18, 2004, 8:57:07 PM (20 years ago)

Author:

Viktor Levandovskyy <levandov@…>

Branches:

(u'spielwiese', '17f1d200f27c5bd38f5dfc6e8a0879242279d1d8')

Children:

bc36a0348925ea3732666805bd1ad0d87c9223e3

Parents:

a63c242b49717f7a64c2432c5f75c71fc335ebdf

Message:

*levandov: new commands oppose, opposite and envelope are available


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

Location:

kernel

Files:

• gring.cc (modified) (2 diffs)
• gring.h (modified) (3 diffs)
• ring.cc (modified) (4 diffs)

kernel/gring.cc

@@ -7 +7 @@
  *  Author:  levandov (Viktor Levandovsky)
  *  Created: 8/00 - 11/00
- *  Version: $Id: gring.cc,v 1.15 2004-10-13 10:50:37 levandov Exp $
+ *  Version: $Id: gring.cc,v 1.16 2004-10-18 18:57:06 levandov Exp $
  *******************************************************************/
 #include "mod2.h"
@@ -2305 +2305 @@
 }
 
-poly p_Oppose(ring Rop, poly p)
-{
-  /* TODO check Rop == rOpposite(currRing) */
-  /* the same basefield, same number of variables */
-
+poly pOppose(ring Rop, poly p)
+  /* opposes a vector p from Rop to currRing */
+{
   /* the simplest case:*/
-  if (Rop==currRing) return pCopy(p); // ok
-  nMapFunc nMap=nSetMap(Rop);
+  if (  Rop == currRing )  return(pCopy(p));
+  /* check Rop == rOpposite(currRing) */
+  if ( !rIsLikeOpposite(currRing, Rop) )
+  {
+    WarnS("an opposite ring should be used");
+    return NULL;
+  }
+  /* nMapFunc nMap = nSetMap(Rop);*/
+  /* since we know that basefields coinside! */
   int *perm=(int *)omAlloc0((Rop->N+1)*sizeof(int));
-  /* we know perm exactly */
+  if (!p_IsConstantPoly(p, Rop))
+  {
+    /* we know perm exactly */
+    int i;
+    for(i=1; i<=Rop->N; i++)
+    {
+      perm[i] = Rop->N+1-i;
+    }
+  }
+  poly res = pPermPoly(p, perm, Rop, nCopy);
+  omFreeSize((ADDRESS)perm,(Rop->N+1)*sizeof(int));
+  return res;
+}
+
+ideal idOppose(ring Rop, ideal I)
+  /* opposes a module I from Rop to currRing */
+{
+  /* the simplest case:*/
+  if ( Rop == currRing ) return idCopy(I);
+  /* check Rop == rOpposite(currRing) */
+  if (!rIsLikeOpposite(currRing, Rop))
+  {
+    WarnS("an opposite ring should be used");
+    return NULL;
+  }
   int i;
-  for(i=1; i<=Rop->N; i++)
-  {
-    perm[i] = Rop->N+1-i;
-  }
-  /*  int *par_perm=NULL; */
-  poly res = pPermPoly(p, perm, Rop, nMap);
-  omFreeSize((ADDRESS)perm,(Rop->N+1)*sizeof(int));
-  //omFreeSize((ADDRESS)par_perm,rPar(r)*sizeof(int));
-  return res;
-}
-
-
-#endif
+  ideal idOp = idInit(I->ncols, I->rank);
+  for (i=0; i< (I->ncols)*(I->nrows); i++)
+  { 
+    idOp->m[i] = pOppose(Rop,I->m[i]); 
+  }
+  idTest(idOp);
+  return idOp;
+}
+
+BOOLEAN rIsLikeOpposite(ring rBase, ring rCandidate)
+  /* checks whether rings rBase and rCandidate */
+  /* could be opposite to each other */
+  /* returns TRUE if it is so */
+{
+  /* the same basefield */
+  int diagnose = TRUE;
+  ring save = currRing;
+  rChangeCurrRing(rBase);
+  nMapFunc nMap = nSetMap(rCandidate);
+  if (nMap != nCopy) diagnose = FALSE;
+  rChangeCurrRing(save);
+  /* same number of variables */
+  if (rBase->N != rCandidate->N) diagnose = FALSE;
+  /* nc and comm ring */
+  if ( rIsPluralRing(rBase) != rIsPluralRing(rCandidate) ) diagnose = FALSE;
+  /* TODO: varnames are e->E etc */
+  return diagnose;
+}
+
+#endif

kernel/gring.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: gring.h,v 1.8 2004-08-27 12:20:02 Singular Exp $ */
+/* $Id: gring.h,v 1.9 2004-10-18 18:57:06 levandov Exp $ */
 /*
 * ABSTRACT additional defines etc for --with-plural
@@ -19 +19 @@
 BOOLEAN nc_CallPlural(matrix CC, matrix DD, poly CN, poly DN, ring r);
 BOOLEAN nc_InitMultiplication(ring r);
+BOOLEAN rIsLikeOpposite(ring rBase, ring rCandidate);
 
 ring nc_rCreateNCcomm(ring r);
@@ -84 +85 @@
 
 poly p_CopyEmbed(poly p, ring srcRing, int shift, int par_shift);
-poly p_Oppose(ring Rop, poly p);
+poly pOppose(ring Rop, poly p);
+ideal idOppose(ring Rop, ideal I);
 
 #else

kernel/ring.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ring.cc,v 1.24 2004-10-15 17:40:30 Singular Exp $ */
+/* $Id: ring.cc,v 1.25 2004-10-18 18:57:07 levandov Exp $ */
 
 /*
@@ -3544 +3544 @@
   /* creates an opposite algebra of R */
   /* that is R^opp, where f (*^opp) g = g*f  */
+  /* ignores the case of qring -> done in iparith.cc */
 {
   ring save = currRing;  
-  ring    r = rCopy0(src);
+  ring    r = rCopy0(src,TRUE); /* TRUE for copy the qideal */
   // change vars v1..vN -> vN..v1
   int i;
@@ -3799 +3800 @@
   r->nc->IsSkewConstant =   src->nc->IsSkewConstant;
   omFreeSize((ADDRESS)perm,(rVar(r)+1)*sizeof(int));
+  /* now oppose the qideal for qrings */
+//   if (r->qideal != NULL)
+//   {
+//     idDelete(&(r->qideal));
+//     r->qideal = idOppose(src, qideal);
+//   }
+//   rTest(r);
   rChangeCurrRing(save);
   }
@@ -3811 +3819 @@
   ring Ropp = rOpposite(R);
   ring Renv = NULL;
-  int stat = rSum(R, Ropp, Renv);
+  int stat = rSum(R, Ropp, Renv); /* should ignore qideals */
   if ( stat <=0 )
     WarnS("Error in rEnvelope at rSum");
+  /* now create the qideal for qrings */
+//   if (R->qideal != NULL)
+//   {
+//     ring save = currRing;
+//     rChangeCurrRing(Ropp);
+//     ideal Q = idCopy(R->qideal);
+//     ideal Qop = idOppose(R,Q);
+//     rChangeCurrRing(Renv);
+//     ideal Qenv = idInit(Q->ncols+Qop->ncols,1);
+//     int i;
+//     for (i=0; i<= Q->ncols; i++)
+//     {
+//       Qenv->m[i] = maIMap(R,Q->m[i]);
+//     }
+//     for (i=0; i<= Qop->ncols; i++)
+//     {
+//       Qenv->m[Q->ncols+i] = maIMap(Ropp,Qop->m[i]);
+//     }
+//     /* should we run twostd on the result? */
+//     Renv->qideal = Qenv;
+//     rChangeCurrRing(save);
+//   }
+  rTest(Renv);
   return Renv;
 }