Changeset c6a3eb2 in git

Timestamp:

Feb 28, 2011, 2:20:22 PM (13 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '38077648e7239f98078663eb941c3c979511150a')

Children:

89abbe07ab1f0d917faf8b67ce6eb62994353b25

Parents:

8e45403dd5d584f695e8de3d811c76579d3a7a55

git-author:

Hans Schoenemann <hannes@mathematik.uni-kl.de>2011-02-28 14:20:22+01:00

git-committer:

Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 11:59:33+01:00

Message:

main part of maps.cc

Location:

libpolys/polys

Files:

• monomials/maps.cc (modified) (20 diffs)
• monomials/maps.h (modified) (1 diff)
• monomials/p_polys.cc (modified) (1 diff)
• monomials/p_polys.h (modified) (2 diffs)
• monomials/ring.cc (modified) (2 diffs)
• monomials/ring.h (modified) (1 diff)
• polys.h (modified) (1 diff)
• polys1.cc (modified) (1 diff)

libpolys/polys/monomials/maps.cc

@@ -7 +7 @@
 */
 
-#include <kernel/mod2.h>
-#include <kernel/options.h>
-#include <kernel/febase.h>
-#include <kernel/polys.h>
-#include <kernel/numbers.h>
-#include <kernel/ring.h>
-#include <kernel/ideals.h>
-#include <kernel/matpol.h>
+#include <misc/options.h>
+#include <monomials/p_polys.h>
+#include <coeffs/coeffs.h>
+#include <coeffs/numbers.h>
+#include <monomials/ring.h>
+#include <simpleideals.h>
 #include <omalloc/omalloc.h>
-#include <kernel/kstd1.h>
-#include <kernel/longtrans.h>
-#include <kernel/maps.h>
-#include <kernel/prCopy.h>
+#include <polys/prCopy.h>
+#include <polys/ext_fields/longtrans.h>
+#include <polys/monomials/maps.h>
 
 #ifdef HAVE_PLURAL
@@ -36 +33 @@
 * copy a map
 */
-map maCopy(map theMap)
+map maCopy(map theMap, const ring r)
 {
   int i;
   map m=(map)idInit(IDELEMS(theMap),0);
   for (i=IDELEMS(theMap)-1; i>=0; i--)
-      m->m[i] = pCopy(theMap->m[i]);
+      m->m[i] = p_Copy(theMap->m[i],r);
   m->preimage=omStrDup(theMap->preimage);
   return m;
@@ -50 +47 @@
 * return the image of var(v)^pExp, where var(v) maps to p
 */
-poly maEvalVariable(poly p, int v,int pExp,matrix s)
+poly maEvalVariable(poly p, int v,int pExp, ideal s, const ring dst_r)
 {
   if (pExp==1)
-    return pCopy(p);
+    return p_Copy(p,dst_r);
 
   poly res;
@@ -64 +61 @@
     if(MATELEM(s,v,1)==NULL)
     {
-      MATELEM(s,v,1)=pCopy(p/*theMap->m[v-1]*/);
+      MATELEM(s,v,1)=p_Copy(p/*theMap->m[v-1]*/,dst_r);
     }
     else
@@ -77 +74 @@
     for(;j<=pExp;j++)
     {
-      p0=MATELEM(s,v,j)=ppMult_qq(p0, p);
-      pNormalize(p0);
-    }
-    res=pCopy(p0/*MATELEM(s,v,pExp)*/);
+      p0=MATELEM(s,v,j)=pp_Mult_qq(p0, p,dst_r);
+      p_Normalize(p0, dst_r);
+    }
+    res=p_Copy(p0/*MATELEM(s,v,pExp)*/,dst_r);
   }
   else //if ((p->next!=NULL)&&(p->next->next==NULL))
   {
-    res=pPower(pCopy(p),pExp);
+    res=p_Power(p_Copy(p,dst_r),pExp,dst_r);
   }
   return res;
 }
 
-static poly maEvalMonom(map theMap, poly p,ring preimage_r,matrix s, nMapFunc nMap)
-{
-    poly q=pNSet(nMap(pGetCoeff(p)));
+static poly maEvalMonom(map theMap, poly p,ring preimage_r, ideal s, 
+           nMapFunc nMap, const ring dst_r)
+{
+    poly q=p_NSet(nMap(pGetCoeff(p),preimage_r->cf,dst_r->cf),dst_r);
 
     int i;
@@ -102 +100 @@
         {
           poly p1=theMap->m[i-1];
-          poly pp=maEvalVariable(p1,i,pExp,s);
-          q = pMult(q,pp);
+          poly pp=maEvalVariable(p1,i,pExp,s,dst_r);
+          q = p_Mult_q(q,pp,dst_r);
         }
         else
         {
-          pDelete(&q);
+          p_Delete(&q,dst_r);
           break;
         }
@@ -113 +111 @@
     }
     int modulComp = p_GetComp( p,preimage_r);
-    if (q!=NULL) pSetCompP(q,modulComp);
+    if (q!=NULL) p_SetCompP(q,modulComp,dst_r);
   return q;
 }
 
-poly maEval(map theMap, poly p,ring preimage_r,nMapFunc nMap,matrix s)
+poly maEval(map theMap, poly p,ring preimage_r,nMapFunc nMap, ideal s, const ring dst_r)
 {
   poly result = NULL;
@@ -142 +140 @@
       for (i=0; i<l; i++)
       {
-        monoms[i]=maEvalMonom(theMap,p,preimage_r,s, nMap);
+        monoms[i]=maEvalMonom(theMap,p,preimage_r,s, nMap, dst_r);
         pIter(p);
       }
     }
-    result=maEvalMonom(theMap,p,preimage_r,s, nMap);
+    result=maEvalMonom(theMap,p,preimage_r,s, nMap, dst_r);
     if (l>0)
     {
       for(i = l-1; i>=0; i--)
       {
-        result=pAdd(result, monoms[i]);
+        result=p_Add_q(result, monoms[i], dst_r);
       }
       omFreeSize((ADDRESS)monoms,l*sizeof(poly));
     }
-    if (currRing->minpoly!=NULL) result=pMinPolyNormalize(result);
-  }
-  pTest(result);
+    if (dst_r->minpoly!=NULL) result=pMinPolyNormalize(result);
+  }
   return result;
 }
@@ -166 +163 @@
 *be carefull: there is no range check for the variables of p
 */
-static poly pChangeSizeOfPoly(ring p_ring, poly p,int minvar,int maxvar)
+static poly pChangeSizeOfPoly(ring p_ring, poly p,int minvar,int maxvar, const ring dst_r)
 {
   int i;
@@ -173 +170 @@
 
   if (p==NULL) return result;
-  else result = pInit();
+  else result = p_Init(dst_r);
   resultWorkP = result;
   while (p!=NULL)
   {
     for (i=minvar;i<=maxvar;i++)
-      pSetExp(resultWorkP,i-minvar+1,p_GetExp(p,i,p_ring));
-    pSetComp(resultWorkP,p_GetComp(p,p_ring));
-    n=nCopy(pGetCoeff(p));
-    pSetCoeff(resultWorkP,n);
-    pSetm(resultWorkP);
+      p_SetExp(resultWorkP,i-minvar+1,p_GetExp(p,i,p_ring),dst_r);
+    p_SetComp(resultWorkP,p_GetComp(p,p_ring),dst_r);
+    n=n_Copy(pGetCoeff(p),dst_r->cf);
+    p_SetCoeff(resultWorkP,n,dst_r);
+    p_Setm(resultWorkP,dst_r);
     pIter(p);
     if (p!=NULL)
     {
-      pNext(resultWorkP) = pInit();
+      pNext(resultWorkP) = p_Init(dst_r);
       pIter(resultWorkP);
     }
@@ -199 +196 @@
 * (assumes) that both ring have the same coeff.field
 */
-ideal maGetPreimage(ring theImageRing, map theMap, ideal id)
-{
-  ring sourcering = currRing;
+ideal maGetPreimage(ring theImageRing, map theMap, ideal id, const ring dst_r)
+{
+  ring sourcering = dst_r;
 
 #ifdef HAVE_PLURAL
@@ -219 +216 @@
   ideal temp2;
 
-  int imagepvariables = theImageRing->N;
-  int N = pVariables+imagepvariables;
+  int imagepvariables = rVar(theImageRing);
+  int N = rVar(dst_r)+imagepvariables;
 
   ring tmpR;
@@ -229 +226 @@
   }
 
-  if (nSetMap(theImageRing) != nCopy)
+  if (n_SetMap(theImageRing->cf,dst_r->cf) != ndCopyMap)
   {
     Werror("Coefficient fields/rings must be equal");
@@ -235 +232 @@
   }
 
-  // change to new ring
-  rChangeCurrRing(tmpR);
   if (id==NULL)
     j = 0;
@@ -246 +241 @@
   for (i=0;i<sourcering->N;i++)
   {
-    q = pISet(-1);
-    pSetExp(q,i+1+imagepvariables,1);
-    pSetm(q);
+    q = p_ISet(-1,tmpR);
+    p_SetExp(q,i+1+imagepvariables,1,tmpR);
+    p_Setm(q,tmpR);
     if ((i<IDELEMS(theMap)) && (theMap->m[i]!=NULL))
     {
-      p = pSort(pChangeSizeOfPoly(theImageRing,theMap->m[i],1,imagepvariables));
-      p=pAdd(p,q);
+      p = p_SortMerge(
+        pChangeSizeOfPoly(theImageRing,theMap->m[i],1,imagepvariables,tmpR),
+        tmpR);
+      p=p_Add_q(p,q,tmpR);
     }
     else
@@ -263 +260 @@
   for (i=sourcering->N;i<sourcering->N+j0;i++)
   {
-    temp1->m[i] = pSort(pChangeSizeOfPoly(theImageRing,
-                                    id->m[i-sourcering->N],1,imagepvariables));
+    temp1->m[i] = p_SortMerge(pChangeSizeOfPoly(theImageRing,
+                         id->m[i-sourcering->N],1,imagepvariables,tmpR),tmpR);
   }
   for (i=sourcering->N+j0;i<sourcering->N+j;i++)
   {
-    temp1->m[i] = pSort(pChangeSizeOfPoly(theImageRing,
-                                    theImageRing->qideal->m[i-sourcering->N-j0],
-                                    1,imagepvariables));
+    temp1->m[i] = p_SortMerge(pChangeSizeOfPoly(theImageRing,
+                              theImageRing->qideal->m[i-sourcering->N-j0],
+                              1,imagepvariables,tmpR),tmpR);
   }
   // we ignore here homogenity - may be changed later:
   temp2 = kStd(temp1,NULL,isNotHomog,NULL);
-  idDelete(&temp1);
+  id_Delete(&temp1,tmpR);
   for (i=0;i<IDELEMS(temp2);i++)
   {
-    if (pLowVar(temp2->m[i])<imagepvariables) pDelete(&(temp2->m[i]));
+    if (pLowVar(temp2->m[i])<imagepvariables) p_Delete(&(temp2->m[i]),tmpR);
   }
 
   // let's get back to the original ring
-  rChangeCurrRing(sourcering);
+  //rChangeCurrRing(sourcering);
   temp1 = idInit(5,1);
   j = 0;
@@ -289 +286 @@
     if (p!=NULL)
     {
-      q = pSort(pChangeSizeOfPoly(tmpR, p,imagepvariables+1,N));
+      q = p_SortMerge(pChangeSizeOfPoly(tmpR, p,imagepvariables+1,N),sourcering);
       if (j>=IDELEMS(temp1))
       {
@@ -375 +372 @@
 * embeds poly p from the subring r into the current ring
 */
-poly maIMap(ring r, poly p)
+poly maIMap(ring r, poly p, const ring dst_r)
 {
   /* the simplest case:*/
-  if(r==currRing) return pCopy(p);
-  nMapFunc nMap=nSetMap(r);
+  if(r==dst_r) return p_Copy(p,dst_r);
+  nMapFunc nMap=n_SetMap(r->cf,dst_r->cf);
   int *perm=(int *)omAlloc0((r->N+1)*sizeof(int));
   //int *par_perm=(int *)omAlloc0(rPar(r)*sizeof(int));
   maFindPerm(r->names,r->N, r->parameter, r->P,
-             currRing->names,currRing->N,currRing->parameter, currRing->P,
-             perm,NULL, currRing->ch);
-  poly res=pPermPoly(p,perm,r, nMap /*,par_perm,rPar(r)*/);
+             dst_r->names,dst_r->N,dst_r->parameter, dst_r->P,
+             perm,NULL, dst_r->ch);
+  poly res=p_PermPoly(p,perm,r,dst_r, nMap /*,par_perm,rPar(r)*/);
   omFreeSize((ADDRESS)perm,(r->N+1)*sizeof(int));
   //omFreeSize((ADDRESS)par_perm,rPar(r)*sizeof(int));
@@ -464 +461 @@
 // This is a very dirty way to cancel monoms whose number equals the
 // MinPoly
-poly pMinPolyNormalize(poly p)
-{
-  number one = nInit(1);
+poly pMinPolyNormalize(poly p, const ring r)
+{
+  number one = n_Init(1,r->cf);
   spolyrec rp;
 
@@ -474 +471 @@
   {
     // this returns 0, if p == MinPoly
-    number product = nMult(pGetCoeff(p), one);
-    if ((product == NULL)||(nIsZero(product)))
-    {
-      pLmDelete(&p);
+    number product = n_Mult(pGetCoeff(p), one,r->cf);
+    if ((product == NULL)||(n_IsZero(product,r->cf)))
+    {
+      p_LmDelete(&p,r);
     }
     else
     {
-      pSetCoeff(p, product);
+      p_SetCoeff(p, product,r);
       pNext(q) = p;
       q = p;

libpolys/polys/monomials/maps.h

@@ -16 +16 @@
 typedef struct sip_smap *         map;
 
-poly maEval(map theMap, poly p, ring dst_ring, nMapFunc nMap); //,matrix s=NULL);
-map maCopy(map theMap, ring dst_ring);
+poly maEval(map theMap, poly p, ring dst_ring, nMapFunc nMap, ideal s=NULL);
+map maCopy(map theMap, const ring dst_ring);
 
 ideal maGetPreimage(ring theImageRing, map theMap,ideal id);

libpolys/polys/monomials/p_polys.cc

@@ -2885 +2885 @@
 
 /*2
+* handle memory request for sets of polynomials (ideals)
+* l is the length of *p, increment is the difference (may be negative)
+*/
+void pEnlargeSet(poly* *p, int l, int increment)
+{
+  poly* h;
+
+  h=(poly*)omReallocSize((poly*)*p,l*sizeof(poly),(l+increment)*sizeof(poly));
+  if (increment>0)
+  {
+    //for (i=l; i<l+increment; i++)
+    //  h[i]=NULL;
+    memset(&(h[l]),0,increment*sizeof(poly));
+  }
+  *p=h;
+}
+
+/*2
 *returns a re-ordered copy of a polynomial, with permutation of the variables
 */

libpolys/polys/monomials/p_polys.h

@@ -339 +339 @@
 inline   poly      pLast(poly a) { int l; return pLast(a, l);}
 static inline poly pReverse(poly p);
+void      pEnlargeSet(poly**p, int length, int increment);
 
 
@@ -381 +382 @@
 long pLDeg1c_WFirstTotalDegree(poly p,int *l, ring r);
 BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r);
+
+long p_Deg(poly a, const ring r);
 /***************************************************************
  *

libpolys/polys/monomials/ring.cc

@@ -3379 +3379 @@
 static void rOptimizeLDeg(ring r)
 {
-  if (r->pFDeg == pDeg)
+  if (r->pFDeg == p_Deg)
   {
     if (r->pLDeg == pLDeg1)
@@ -3520 +3520 @@
   
   if (rOrd_is_Totaldegree_Ordering(r) || rOrd_is_WeightedDegree_Ordering(r))
-    r->pFDeg = pDeg;
+    r->pFDeg = p_Deg;
 
   r->pFDegOrig = r->pFDeg;

libpolys/polys/monomials/ring.h

@@ -55 +55 @@
   int ncols;
   #define IDELEMS(i) ((i)->ncols)
+  #define MATCOLS(i) ((i)->ncols)
+  #define MATROWS(i) ((i)->nrows)
+  #define MATELEM(mat,i,j) ((mat)->m)[MATCOLS((mat)) * ((i)-1) + (j)-1]
 };
 typedef struct sip_sideal *       ideal;
+
+struct sip_smap
+{
+  poly *m;
+  char *preimage;
+  int nrows;
+  int ncols;
+};
+typedef struct sip_smap *         map;
+
 typedef enum
 {

libpolys/polys/polys.h

@@ -273 +273 @@
 inline void    wrp(poly p)        {p_wrp(p, currRing, currRing);}
 
-void      pEnlargeSet(polyset *p, int length, int increment);
 #define   pISet(i) p_ISet(i,currRing)
 #define   pNSet(n) p_NSet(n,currRing)

libpolys/polys/polys1.cc

@@ -33 +33 @@
 
 
-/*2
-* handle memory request for sets of polynomials (ideals)
-* l is the length of *p, increment is the difference (may be negative)
-*/
-void pEnlargeSet(polyset *p, int l, int increment)
-{
-  polyset h;
-
-  h=(polyset)omReallocSize((poly*)*p,l*sizeof(poly),(l+increment)*sizeof(poly));
-  if (increment>0)
-  {
-    //for (i=l; i<l+increment; i++)
-    //  h[i]=NULL;
-    memset(&(h[l]),0,increment*sizeof(poly));
-  }
-  *p=h;
-}
-
 poly ppJet(poly p, int m)
 {