[BACK]Return to poly4.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / kan96xx / Kan

Diff for /OpenXM/src/kan96xx/Kan/poly4.c between version 1.1.1.1 and 1.7

version 1.1.1.1, 1999/10/08 02:12:02 version 1.7, 2003/07/19 06:03:57
Line 1 
Line 1 
   /* $OpenXM: OpenXM/src/kan96xx/Kan/poly4.c,v 1.6 2003/07/17 07:33:03 takayama Exp $ */
 #include <stdio.h>  #include <stdio.h>
 #include "datatype.h"  #include "datatype.h"
 #include "stackm.h"  #include "stackm.h"
Line 10  static int degreeOfInitW(POLY f,int w[]);
Line 11  static int degreeOfInitW(POLY f,int w[]);
   
   
 static void shell(v,n)  static void shell(v,n)
 int v[];       int v[];
 int n;       int n;
 {  {
   int gap,i,j,temp;    int gap,i,j,temp;
   
   for (gap = n/2; gap > 0; gap /= 2) {    for (gap = n/2; gap > 0; gap /= 2) {
     for (i = gap; i<n; i++) {      for (i = gap; i<n; i++) {
       for (j=i-gap ; j>=0 && v[j]<v[j+gap]; j -= gap) {        for (j=i-gap ; j>=0 && v[j]<v[j+gap]; j -= gap) {
         temp = v[j];          temp = v[j];
         v[j] = v[j+gap];          v[j] = v[j+gap];
         v[j+gap] = temp;          v[j+gap] = temp;
       }        }
     }      }
   }    }
Line 28  int n;
Line 29  int n;
   
   
 struct matrixOfPOLY *parts(f,v)  struct matrixOfPOLY *parts(f,v)
 POLY f;       POLY f;
 POLY v;  /* v must be a single variable, e.g. x */       POLY v;  /* v must be a single variable, e.g. x */
 {  {
   struct matrixOfPOLY *evPoly;    struct matrixOfPOLY *evPoly;
   int vi = 0;  /* index of v */    int vi = 0;  /* index of v */
Line 95  POLY v;  /* v must be a single variable, e.g. x */
Line 96  POLY v;  /* v must be a single variable, e.g. x */
     ft = f;      ft = f;
     while (ft != POLYNULL) {      while (ft != POLYNULL) {
       if (vx) {        if (vx) {
         if (ft->m->e[vi].x == ev[i]) {          if (ft->m->e[vi].x == ev[i]) {
           h = newCell(ft->coeffp,monomialCopy(ft->m));            h = newCell(ft->coeffp,monomialCopy(ft->m));
           xset0(h,vi); /* touch monomial part, so you need to copy it above. */            xset0(h,vi); /* touch monomial part, so you need to copy it above. */
           ans = ppAdd(ans,h);            ans = ppAdd(ans,h);
         }          }
       }else{        }else{
         if (ft->m->e[vi].D == ev[i]) {          if (ft->m->e[vi].D == ev[i]) {
           h = newCell(ft->coeffp,monomialCopy(ft->m));            h = newCell(ft->coeffp,monomialCopy(ft->m));
           dset0(h,vi);            dset0(h,vi);
           ans = ppAdd(ans,h);            ans = ppAdd(ans,h);
         }          }
       }        }
       ft = ft->next;        ft = ft->next;
     }      }
Line 113  POLY v;  /* v must be a single variable, e.g. x */
Line 114  POLY v;  /* v must be a single variable, e.g. x */
   }    }
   return(evPoly);    return(evPoly);
 }  }
   
 struct object parts2(f,v)  struct object parts2(f,v)
 POLY f;       POLY f;
 POLY v;  /* v must be a single variable, e.g. x */       POLY v;  /* v must be a single variable, e.g. x */
 {  {
   struct matrixOfPOLY *evPoly;    struct matrixOfPOLY *evPoly;
   int vi = 0;  /* index of v */    int vi = 0;  /* index of v */
Line 189  POLY v;  /* v must be a single variable, e.g. x */
Line 190  POLY v;  /* v must be a single variable, e.g. x */
     ft = f;      ft = f;
     while (ft != POLYNULL) {      while (ft != POLYNULL) {
       if (vx) {        if (vx) {
         if (ft->m->e[vi].x == ev[i]) {          if (ft->m->e[vi].x == ev[i]) {
           h = newCell(ft->coeffp,monomialCopy(ft->m));            h = newCell(ft->coeffp,monomialCopy(ft->m));
           xset0(h,vi); /* touch monomial part, so you need to copy it above. */            xset0(h,vi); /* touch monomial part, so you need to copy it above. */
           ans = ppAdd(ans,h);            ans = ppAdd(ans,h);
         }          }
       }else{        }else{
         if (ft->m->e[vi].D == ev[i]) {          if (ft->m->e[vi].D == ev[i]) {
           h = newCell(ft->coeffp,monomialCopy(ft->m));            h = newCell(ft->coeffp,monomialCopy(ft->m));
           dset0(h,vi);            dset0(h,vi);
           ans = ppAdd(ans,h);            ans = ppAdd(ans,h);
         }          }
       }        }
       ft = ft->next;        ft = ft->next;
     }      }
Line 215  POLY v;  /* v must be a single variable, e.g. x */
Line 216  POLY v;  /* v must be a single variable, e.g. x */
   putoa(rob,0,ob1); putoa(rob,1,ob2);    putoa(rob,0,ob1); putoa(rob,1,ob2);
   return(rob);    return(rob);
 }  }
   
 int pDegreeWrtV(f,v)  int pDegreeWrtV(f,v)
 POLY f;       POLY f;
 POLY v;       POLY v;
 {  {
   int vx = 1;    int vx = 1;
   int vi = 0;    int vi = 0;
Line 298  int containVectorVariable(POLY f)
Line 299  int containVectorVariable(POLY f)
 }  }
   
 POLY homogenize(f)  POLY homogenize(f)
 POLY f;       POLY f;
 /* homogenize by using (*grade)(f) */       /* homogenize by using (*grade)(f) */
 {  {
   POLY t;    POLY t;
   int maxg;    int maxg;
Line 330  POLY f;
Line 331  POLY f;
 }  }
   
 int isHomogenized(f)  int isHomogenized(f)
 POLY f;       POLY f;
 {  {
   POLY t;    POLY t;
   extern int Homogenize_vec;    extern int Homogenize_vec;
   int maxg;    int maxg;
   if (!Homogenize_vec) return(isHomogenized_vec(f));    if (!Homogenize_vec) return(isHomogenized_vec(f));
   if (f == ZERO) return(1);    if (f == ZERO) return(1);
     if (f->m->ringp->weightedHomogenization) {
           return 1; /* BUG: do not chech in case of one-zero homogenization */
     }
   maxg = (*grade)(f);    maxg = (*grade)(f);
   t = f;    t = f;
   while (t != POLYNULL) {    while (t != POLYNULL) {
Line 347  POLY f;
Line 351  POLY f;
 }  }
   
 int isHomogenized_vec(f)  int isHomogenized_vec(f)
 POLY f;       POLY f;
 {  {
 /* This is not efficient version. *grade should be grade_module1v(). */    /* This is not efficient version. *grade should be grade_module1v(). */
   POLY t;    POLY t;
   int ggg;    int ggg;
   if (f == ZERO) return(1);    if (f == ZERO) return(1);
     if (f->m->ringp->weightedHomogenization) {
           return 1; /* BUG: do not chech in case of one-zero homogenization */
     }
   while (f != POLYNULL) {    while (f != POLYNULL) {
     t = f;      t = f;
     ggg = (*grade)(f);      ggg = (*grade)(f);
     while (t != POLYNULL) {      while (t != POLYNULL) {
       if ((*isSameComponent)(f,t)) {        if ((*isSameComponent)(f,t)) {
         if (ggg != (*grade)(t)) return(0);          if (ggg != (*grade)(t)) return(0);
       }        }
       t = t->next;        t = t->next;
     }      }
Line 369  POLY f;
Line 376  POLY f;
   
   
 static int degreeOfPrincipalPart(f)  static int degreeOfPrincipalPart(f)
 POLY f;       POLY f;
 {  {
   int n,i,dd;    int n,i,dd;
   if (f ISZERO) return(0);    if (f ISZERO) return(0);
Line 382  POLY f;
Line 389  POLY f;
 }  }
   
 POLY POLYToPrincipalPart(f)  POLY POLYToPrincipalPart(f)
 POLY f;       POLY f;
 {  {
   POLY node;    POLY node;
   struct listPoly nod;    struct listPoly nod;
Line 411  POLY f;
Line 418  POLY f;
 }  }
   
 static int degreeOfInitW(f,w)  static int degreeOfInitW(f,w)
 POLY f;       POLY f;
 int w[];       int w[];
 {  {
   int n,i,dd;    int n,i,dd;
   if (f ISZERO) {    if (f ISZERO) {
Line 427  int w[];
Line 434  int w[];
 }  }
   
 POLY POLYToInitW(f,w)  POLY POLYToInitW(f,w)
 POLY f;       POLY f;
 int w[]; /* weight vector */       int w[]; /* weight vector */
 {  {
   POLY node;    POLY node;
   struct listPoly nod;    struct listPoly nod;
Line 492  int isTheSameRing(struct ring *rstack[],int rp, struct
Line 499  int isTheSameRing(struct ring *rstack[],int rp, struct
     if (rrr->orderMatrixSize != newRingp->orderMatrixSize) { a=12; goto bbb ; }      if (rrr->orderMatrixSize != newRingp->orderMatrixSize) { a=12; goto bbb ; }
     for (i=0; i<rrr->orderMatrixSize; i++) {      for (i=0; i<rrr->orderMatrixSize; i++) {
       for (j=0; j<2*(rrr->n); j++) {        for (j=0; j<2*(rrr->n); j++) {
         if (rrr->order[i*2*(rrr->n)+j] != newRingp->order[i*2*(rrr->n)+j])          if (rrr->order[i*2*(rrr->n)+j] != newRingp->order[i*2*(rrr->n)+j])
           { a=13; goto bbb ; }            { a=13; goto bbb ; }
       }        }
     }      }
     if (rrr->next != newRingp->next) { a=14; goto bbb ; }      if (rrr->next != newRingp->next) { a=14; goto bbb ; }
     if (rrr->multiplication != newRingp->multiplication) { a=15; goto bbb ; }      if (rrr->multiplication != newRingp->multiplication) { a=15; goto bbb ; }
     /* if (rrr->schreyer != newRingp->schreyer) { a=16; goto bbb ; }*/      /* if (rrr->schreyer != newRingp->schreyer) { a=16; goto bbb ; }*/
     if (newRingp->schreyer == 1) { a=16; goto bbb; }      if (newRingp->schreyer == 1) { a=16; goto bbb; }
       if (rrr->weightedHomogenization != newRingp->weightedHomogenization) { a=16; goto bbb; }
       if (rrr->degreeShiftSize != newRingp->degreeShiftSize) {
         a = 17; goto bbb;
       }
       if (rrr->degreeShiftN != newRingp->degreeShiftN) {
         a = 17; goto bbb;
       }
       for (i=0; i < rrr->degreeShiftSize; i++) {
         for (j=0; j< rrr->degreeShiftN; j++) {
           if (rrr->degreeShift[i*(rrr->degreeShiftN)+j] !=
               newRingp->degreeShift[i*(rrr->degreeShiftN)+j]) {
             a = 17; goto bbb;
           }
         }
       }
   
     /* The following fields are ignored.      /* The following fields are ignored.
        void *gbListTower;         void *gbListTower;
        int *outputOrder;         int *outputOrder;
Line 513  int isTheSameRing(struct ring *rstack[],int rp, struct
Line 536  int isTheSameRing(struct ring *rstack[],int rp, struct
   }    }
   return(-1);    return(-1);
 }  }
   
   /* s->1 */
   POLY goDeHomogenizeS(POLY f) {
     POLY node;
     POLY lastf;
     struct listPoly nod;
     POLY h;
     POLY tf;
     int gt,first;
   
     if (f == POLYNULL) return(POLYNULL);
     node = &nod;
     node->next = POLYNULL;
     lastf = POLYNULL;
     first = 1;
     while (f != POLYNULL) {
       tf = newCell(f->coeffp,monomialCopy(f->m));
       tf->m->e[0].x = 0;  /* H, s variable in the G-O paper. */
       if (first) {
         node->next = tf;
         lastf = tf;
         first = 0;
       }else{
         gt = (*mmLarger)(lastf,tf);
         if (gt == 1) {
           lastf->next = tf;
           lastf = tf;
         }else{
           h = node->next;
           h = ppAddv(h,tf);
           node->next = h;
           lastf = h;
           while (lastf->next != POLYNULL) {
             lastf = lastf->next;
           }
         }
       }
       f = f->next;
     }
     return (node->next);
   }
   
   /* Granger-Oaku's homogenization for the ecart tangent cone.
      Note: 2003.07.10.
      ds[] is the degree shift.
      ei ( element index ). If it is < 0, then e[n-1]->x will be used,
                            else ei is used.
      if onlyS is set to 1, then input is assumed to be (u,v)-h-homogeneous.
   */
   POLY goHomogenize(POLY f,int u[],int v[],int ds[],int dssize,int ei,int onlyS)
   {
     POLY node;
     POLY lastf;
     struct listPoly nod;
     POLY h;
     POLY tf;
     int gt,first,m,mp,t,tp,dsIdx,message;
     struct ring *rp;
   
     message = 1;
     if (f == POLYNULL) return(POLYNULL);
     rp = f->m->ringp;
     if ((rp->degreeShiftSize == 0) && (dssize > 0)) {
           warningPoly("You are trying to homogenize a polynomial with degree shift. However, the polynomial belongs to the ring without degreeShift option. It may cause a trouble in comparison in free module.\n");
     }
     node = &nod;
     node->next = POLYNULL;
     lastf = POLYNULL;
     first = 1;
     while (f != POLYNULL) {
       if (first) {
         t = m = dGrade1(f);
         tp = mp = uvGrade1(f,u,v,ds,dssize,ei);
       }else{
         t =  dGrade1(f);
         tp = uvGrade1(f,u,v,ds,dssize,ei);
         if (t > m) m = t;
         if (tp < mp) mp = tp;
       }
   
       tf = newCell(f->coeffp,monomialCopy(f->m));
           /* Automatic dehomogenize. Not +=  */
           if (message && ((tf->m->e[0].D != 0) || (tf->m->e[0].x != 0))) {
         /*go-debug fprintf(stderr,"Automatic dehomogenize and homogenize.\n"); */
             message = 0;
           }
           if (!onlyS) {
             tf->m->e[0].D = -t;  /* h */
           }
       tf->m->e[0].x = tp;  /* H, s variable in the G-O paper. */
           /*go-debug printf("t(h)=%d, tp(uv+ds)=%d\n",t,tp); */
       if (first) {
         node->next = tf;
         lastf = tf;
         first = 0;
       }else{
         gt = (*mmLarger)(lastf,tf);
         if (gt == 1) {
           lastf->next = tf;
           lastf = tf;
         }else{
           /*go-debug printf("?\n"); */
           h = node->next;
           h = ppAddv(h,tf);
           node->next = h;
           lastf = h;
           while (lastf->next != POLYNULL) {
             lastf = lastf->next;
           }
         }
           }
           f = f->next;
     }
     h = node->next;
     /*go-debug printf("m=%d, mp=%d\n",m,mp); */
     while (h != POLYNULL) {
       /*go-debug printf("Old: h=%d, s=%d\n",h->m->e[0].D,h->m->e[0].x); */
       if (!onlyS) h->m->e[0].D += m;   /* h */
       h->m->e[0].x += -mp; /* H, s*/
       /*go-debug printf("New: h=%d, s=%d\n",h->m->e[0].D,h->m->e[0].x); */
       h = h->next;
     }
     return (node->next);
   }
   
   /* u[] = -1, v[] = 1 */
   POLY goHomogenize11(POLY f,int ds[],int dssize,int ei,int onlyS)
   {
     int r;
     int i,t,n,m,nn;
     MONOMIAL tf;
     static int *u;
     static int *v;
     static struct ring *cr = (struct ring *)NULL;
   
     if (f == POLYNULL) return POLYNULL;
   
     tf = f->m;
     if (tf->ringp != cr) {
       n = tf->ringp->n;
       m = tf->ringp->m;
       nn = tf->ringp->nn;
       cr = tf->ringp;
           u = (int *)sGC_malloc(sizeof(int)*n);
           v = (int *)sGC_malloc(sizeof(int)*n);
           for (i=0; i<n; i++) u[i]=v[i]=0;
           for (i=m; i<nn; i++) {
             u[i] = -1; v[i] = 1;
           }
     }
     return(goHomogenize(f,u,v,ds,dssize,ei,onlyS));
   }
   
   POLY goHomogenize_dsIdx(POLY f,int u[],int v[],int dsIdx,int ei,int onlyS)
   {
     if (f == POLYNULL) return POLYNULL;
   }
   POLY goHomogenize11_dsIdx(POLY f,int ds[],int dsIdx,int ei,int onlyS)
   {
     if (f == POLYNULL) return POLYNULL;
   }
Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.7
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>