Changeset 01c1d0 in git


Ignore:
Timestamp:
Apr 21, 2011, 1:34:10 PM (13 years ago)
Author:
Oleksandr Motsak <motsak@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b52fc4b2495505785981d640dcf7eb3e456778ef')
Children:
59a62bd935a023662ba918abaefcc861c4adbe81
Parents:
0b7bf7ebce7bb8127ebbb274e87efef8dce670c7
git-author:
Oleksandr Motsak <motsak@mathematik.uni-kl.de>2011-04-21 13:34:10+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 12:31:24+01:00
Message:
FIX: moved P/minpoly/parameters from ring to coeff
Location:
libpolys
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • libpolys/coeffs/coeffs.h

    r0b7bf7 r01c1d0  
    154154   int     ref;
    155155   n_coeffType type;
    156 ////-----------------------------------------
    157   char**     parameter; /* names of parameters, rInit */
    158   number     minpoly;  /* for Q_a/Zp_a, rInit */
     156//-------------------------------------------
     157  char**     parameter; //< names of parameters, rInit
     158  short      P;      //< number of pars, rInit
     159  number     minpoly;  //< for Q_a/Zp_a, rInit
    159160
    160161#ifdef HAVE_RINGS
  • libpolys/polys/OBSOLETE_pInitContent.cc

    r0b7bf7 r01c1d0  
    4343    }
    4444    else if ((rField_is_Extension(r))
    45     && ((rPar(r)>1)||(r->minpoly==NULL)))
     45    && ((rPar(r)>1)||(r->cf->minpoly==NULL)))
    4646    {
    4747      h=pInitContent_a(ph);
     
    751751      qq = pInit();
    752752      number n=nMap(pGetCoeff(p));
    753       if ((currRing->minpoly!=NULL)
     753      if ((currRing->cf->minpoly!=NULL)
    754754      && ((rField_is_Zp_a()) || (rField_is_Q_a())))
    755755      {
     
    763763      qq=pOne();
    764764      aq=napPermNumber(pGetCoeff(p),par_perm,OldPar, oldRing);
    765       if ((aq!=NULL) && (currRing->minpoly!=NULL)
     765      if ((aq!=NULL) && (currRing->cf->minpoly!=NULL)
    766766      && ((rField_is_Zp_a()) || (rField_is_Q_a())))
    767767      {
     
    829829      }
    830830      if (mapped_to_par
    831       && (currRing->minpoly!=NULL))
     831      && (currRing->cf->minpoly!=NULL))
    832832      {
    833833        number n=pGetCoeff(qq);
  • libpolys/polys/kbuckets.cc

    r0b7bf7 r01c1d0  
    11551155  if (rField_is_Zp(r))
    11561156    return TRUE;
    1157   if (r->parameter==NULL)
     1157  if (r->cf->parameter==NULL)
    11581158  {
    11591159    return (r->cf->cfSize(n,r->cf)==1);
  • libpolys/polys/monomials/maps.cc

    r0b7bf7 r01c1d0  
    155155      omFreeSize((ADDRESS)monoms,l*sizeof(poly));
    156156    }
    157     if (dst_r->minpoly!=NULL) result=p_MinPolyNormalize(result, dst_r);
     157    if (dst_r->cf->minpoly!=NULL) result=p_MinPolyNormalize(result, dst_r);
    158158  }
    159159  return result;
     
    270270  int *perm=(int *)omAlloc0((r->N+1)*sizeof(int));
    271271  //int *par_perm=(int *)omAlloc0(rPar(r)*sizeof(int));
    272   maFindPerm(r->names,r->N, r->parameter, r->P,
    273              dst_r->names,dst_r->N,dst_r->parameter, dst_r->P,
    274              perm,NULL, dst_r->ch);
     272  maFindPerm(r->names, rVar(r), r->cf->parameter, rPar(r),
     273             dst_r->names, rVar(dst_r),dst_r->cf->parameter, rPar(dst_r),
     274             perm,NULL, dst_r->cf->ch);
    275275  poly res=p_PermPoly(p,perm,r,dst_r, nMap /*,par_perm,rPar(r)*/);
    276276  omFreeSize((ADDRESS)perm,(r->N+1)*sizeof(int));
  • libpolys/polys/monomials/p_polys.cc

    r0b7bf7 r01c1d0  
    18571857    }
    18581858    else if ((rField_is_Extension(r))
    1859     && ((rPar(r)>1)||(r->minpoly==NULL)))
     1859    && ((rPar(r)>1)||(r->cf->minpoly==NULL)))
    18601860    {
    18611861      h=p_InitContent_a(ph,r);
     
    32403240      qq = p_Init(dst);
    32413241      number n=nMap(pGetCoeff(p),oldRing->cf,dst->cf);
    3242       if ((dst->minpoly!=NULL)
     3242      if ((dst->cf->minpoly!=NULL)
    32433243      && ((rField_is_Zp_a(dst)) || (rField_is_Q_a(dst))))
    32443244      {
     
    32543254      #if 0
    32553255      aq=naPermNumber(pGetCoeff(p),par_perm,OldPar, oldRing);
    3256       if ((dst->minpoly!=NULL)
     3256      if ((dst->cf->minpoly!=NULL)
    32573257      && ((rField_is_Zp_a(dst)) || (rField_is_Q_a(dst))))
    32583258      {
     
    33293329      }
    33303330      if (mapped_to_par
    3331       && (dst->minpoly!=NULL))
     3331      && (dst->cf->minpoly!=NULL))
    33323332      {
    33333333        number n=pGetCoeff(qq);
  • libpolys/polys/monomials/ring.cc

    r0b7bf7 r01c1d0  
    7474};
    7575
    76 #define  rInternalChar(r) ((r)->ch)
     76#define  rInternalChar(r) ((r)->cf->ch)
    7777
    7878const char * rSimpleOrdStr(int ord)
     
    9494//BOOLEAN rField_is_R(ring r)
    9595//{
    96 //  if (r->ch== -1)
     96//  if (r->cf->ch== -1)
    9797//  {
    9898//    if (r->float_len==(short)0) return TRUE;
     
    108108void rChangeCurrRing(ring r)
    109109{
    110  // if ((currRing!=NULL) && (currRing->minpoly!=NULL))
     110 // if ((currRing!=NULL) && (currRing->cf->minpoly!=NULL))
    111111 // {
    112  //   omCheckAddr(currRing->minpoly);
     112 //   omCheckAddr(currRing->cf->minpoly);
    113113 // }
    114114  //------------ set global ring vars --------------------------------
     
    140140  assume( cf != NULL);
    141141  ring r=(ring) omAlloc0Bin(sip_sring_bin);
    142   r->ch    = n_GetChar(cf);
     142  r->cf->ch    = n_GetChar(cf);
    143143  r->N     = N;
    144144  r->cf = cf;
    145   /*r->P     = 0; Alloc0 */
     145  /*rPar(r)  = 0; Alloc0 */
    146146  /*names*/
    147147  r->names = (char **) omAlloc0(N * sizeof(char *));
     
    279279  nblocks--;
    280280
    281 
     281  n_CoeffWrite(r->cf);
     282#if 0
    282283  if (rField_is_GF(r))
    283284  {
    284     Print("//   # ground field : %d\n",r->ch);
     285    Print("//   # ground field : %d\n",r->cf->ch);
    285286    Print("//   primitive element : %s\n", r->parameter[0]);
    286287    StringSetS("//   minpoly        : ");
     
    313314    else
    314315      Print ("%d\n",rChar(r)); /* Fp(a) */
    315     if (r->parameter!=NULL)
     316    if (r->cf->parameter!=NULL)
    316317    {
    317318      Print ("//   %d parameter    : ",rPar(r));
    318       char **sp=r->parameter;
     319      char **sp=r->cf->parameter;
    319320      int nop=0;
    320321      while (nop<rPar(r))
     
    328329      {
    329330        // i^2+1:
    330         Print("(%s^2+1)\n",r->parameter[0]);
    331       }
    332       else if (r->minpoly==NULL)
     331        Print("(%s^2+1)\n",r->cf->parameter[0]);
     332      }
     333      else if (r->cf->minpoly==NULL)
    333334      {
    334335        PrintS("0\n");
     
    336337      else
    337338      {
    338         StringSetS(""); n_Write(r->minpoly,r->cf); PrintS(StringAppendS("\n"));
     339        StringSetS(""); n_Write(r->cf->minpoly,r->cf); PrintS(StringAppendS("\n"));
    339340      }
    340341      //if (r->minideal!=NULL)
     
    345346    }
    346347  }
     348#endif 
    347349  Print("//   number of vars : %d",r->N);
    348350
     
    477479#endif
    478480
    479   nKillChar(r->cf);
     481  nKillChar(r->cf); r->cf = NULL;
    480482  rUnComplete(r);
    481483  // delete order stuff
     
    512514
    513515  // delete parameter
    514   if (r->parameter!=NULL)
    515   {
    516     char **s=r->parameter;
     516  if (r->cf->parameter!=NULL)
     517  {
     518    char **s=r->cf->parameter;
    517519    j = 0;
    518520    while (j < rPar(r))
     
    522524      j++;
    523525    }
    524     omFreeSize((ADDRESS)r->parameter,rPar(r)*sizeof(char *));
    525   }
    526 #ifdef HAVE_RINGS
    527   if (r->cf->modBase != NULL)
    528   {
    529     mpz_clear(r->cf->modBase);
    530     omFree((ADDRESS)r->cf->modBase);
    531   }
    532   if (r->cf->modNumber != NULL)
    533   {
    534     mpz_clear(r->cf->modNumber);
    535     omFree((ADDRESS)r->cf->modNumber);
    536   }
    537 #endif
     526    omFreeSize((ADDRESS)r->cf->parameter,rPar(r)*sizeof(char *));
     527  }
    538528  omFreeBin(r, sip_sring_bin);
    539529}
     
    679669  }
    680670#endif
    681   if (r->parameter==NULL)
    682   {
    683     i=r->ch;
     671  if (r->cf->parameter==NULL)
     672  {
     673    i=r->cf->ch;
    684674    if(i==-1)
    685675      s=omStrDup("real");                    /* R */
     
    693683  if (rField_is_long_C(r))
    694684  {
    695     s=(char *)omAlloc(21+strlen(r->parameter[0]));
    696     sprintf(s,"complex,%d,%s",r->float_len,r->parameter[0]);   /* C */
     685    s=(char *)omAlloc(21+strlen(r->cf->parameter[0]));
     686    sprintf(s,"complex,%d,%s",r->float_len,r->cf->parameter[0]);   /* C */
    697687    return s;
    698688  }
     
    700690  for(i=0; i<rPar(r);i++)
    701691  {
    702     l+=(strlen(r->parameter[i])+1);
     692    l+=(strlen(r->cf->parameter[i])+1);
    703693  }
    704694  s=(char *)omAlloc((long)(l+MAX_INT_LEN+1));
    705695  s[0]='\0';
    706   if (r->ch<0)       sprintf(s,"%d",-r->ch); /* Fp(a) */
    707   else if (r->ch==1) sprintf(s,"0");         /* Q(a)  */
     696  if (r->cf->ch<0)       sprintf(s,"%d",-r->cf->ch); /* Fp(a) */
     697  else if (r->cf->ch==1) sprintf(s,"0");         /* Q(a)  */
    708698  else
    709699  {
    710     sprintf(s,"%d,%s",r->ch,r->parameter[0]); /* GF(q)  */
     700    sprintf(s,"%d,%s",r->cf->ch,r->cf->parameter[0]); /* GF(q)  */
    711701    return s;
    712702  }
     
    717707  {
    718708    strcat(s,tt);
    719     strcat(s,r->parameter[i]);
     709    strcat(s,r->cf->parameter[i]);
    720710  }
    721711  return s;
     
    724714char * rParStr(ring r)
    725715{
    726   if ((r==NULL)||(r->parameter==NULL)) return omStrDup("");
     716  if ((r==NULL)||(r->cf->parameter==NULL)) return omStrDup("");
    727717
    728718  int i;
     
    731721  for (i=0; i<rPar(r); i++)
    732722  {
    733     l+=strlen(r->parameter[i])+1;
     723    l+=strlen(r->cf->parameter[i])+1;
    734724  }
    735725  char *s=(char *)omAlloc((long)l);
     
    737727  for (i=0; i<rPar(r)-1; i++)
    738728  {
    739     strcat(s,r->parameter[i]);
     729    strcat(s,r->cf->parameter[i]);
    740730    strcat(s,",");
    741731  }
    742   strcat(s,r->parameter[i]);
     732  strcat(s,r->cf->parameter[i]);
    743733  return s;
    744734}
     
    759749int  rIsExtension(const ring r)
    760750{
    761   return (r->parameter!=NULL); /* R, Q, Fp: FALSE */
     751  return (r->cf->parameter!=NULL); /* R, Q, Fp: FALSE */
    762752}
    763753
     
    793783    return 0;
    794784  if (!rIsExtension(r)) /* Q, Fp */
    795     return r->ch;
     785    return r->cf->ch;
    796786  if (rField_is_Zp_a(r))  /* Fp(a)  */
    797     return -r->ch;
     787    return -r->cf->ch;
    798788  if (rField_is_Q_a(r))   /* Q(a)  */
    799789    return 0;
    800790  /*else*/               /* GF(p,n) */
    801791  {
    802     if ((r->ch & 1)==0) return 2;
     792    if ((r->cf->ch & 1)==0) return 2;
    803793    int i=3;
    804     while ((r->ch % i)!=0) i+=2;
     794    while ((r->cf->ch % i)!=0) i+=2;
    805795    return i;
    806796  }
     
    843833int rSumInternal(ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp)
    844834{
     835
    845836  ip_sring tmpR;
    846837  memset(&tmpR,0,sizeof(tmpR));
    847838  /* check coeff. field =====================================================*/
     839
     840  TODO(Hans, switch to the use of ->cf);
     841  assume( tmpR.cf !=NULL ); // ???!
     842 
    848843  if ((rFieldType(r1)==rFieldType(r2))
    849844  && (rInternalChar(r1)==rInternalChar(r2)))
    850845  {
    851     tmpR.ch=r1->ch;
    852846    if (rField_is_Q(r1)||rField_is_Zp(r1)||rField_is_GF(r1)) /*Q, Z/p, GF(p,n)*/
    853847    {
    854       if (r1->parameter!=NULL)
    855       {
    856         if (!vartest || (strcmp(r1->parameter[0],r2->parameter[0])==0)) /* 1 par */
     848      if (r1->cf->parameter!=NULL)
     849      {
     850        if (!vartest || (strcmp(r1->cf->parameter[0],r2->cf->parameter[0])==0)) /* 1 par */
    857851        {
    858852          //tmpR.parameter=(char **)omAllocBin(char *);
    859           //tmpR.parameter[0]=omStrDup(r1->parameter[0]);
     853          //tmpR.parameter[0]=omStrDup(r1->cf->parameter[0]);
    860854          //tmpR.P=1;
    861855        }
     
    866860        }
    867861      }
     862      tmpR.cf->ch=r1->cf->ch;
    868863    }
    869864    else if (rField_is_Extension(r1)) /* Q(a),Z/p(a) */
    870865    {
    871       if (r1->minpoly!=NULL)
    872       {
    873         if (r2->minpoly!=NULL)
     866      if (r1->cf->minpoly!=NULL)
     867      {
     868        if (r2->cf->minpoly!=NULL)
    874869        {
    875870          // HANNES: TODO: delete nSetChar
     
    878873//        rChangeCurrRing(r1);
    879874           
    880           if ((!vartest || (strcmp(r1->parameter[0],r2->parameter[0])==0)) /* 1 par */
    881               && n_Equal(r1->minpoly,r2->minpoly, r1->cf))
     875          if ((!vartest || (strcmp(r1->cf->parameter[0],r2->cf->parameter[0])==0)) /* 1 par */
     876              && n_Equal(r1->cf->minpoly,r2->cf->minpoly, r1->cf))
    882877          {
    883878            //tmpR.parameter=(char **)omAllocBin(char *);
    884             //tmpR.parameter[0]=omStrDup(r1->parameter[0]);
    885             //tmpR.minpoly=n_Copy(r1->minpoly, r1->cf);
     879            //tmpR.parameter[0]=omStrDup(r1->cf->parameter[0]);
     880            //tmpR.minpoly=n_Copy(r1->cf->minpoly, r1->cf);
    886881            //tmpR.P=1;
    887882            // HANNES: TODO: delete nSetChar
     
    896891        else
    897892        {
    898           if ((!vartest || (strcmp(r1->parameter[0],r2->parameter[0])==0)) /* 1 par */
     893          if ((!vartest || (strcmp(r1->cf->parameter[0],r2->cf->parameter[0])==0)) /* 1 par */
    899894              && (rPar(r2)==1))
    900895          {
    901896            //tmpR.parameter=(char **)omAllocBin(char *);
    902             //tmpR.parameter[0]=omStrDup(r1->parameter[0]);
     897            //tmpR.parameter[0]=omStrDup(r1->cf->parameter[0]);
    903898            //tmpR.P=1;
    904             //tmpR.minpoly=n_Copy(r1->minpoly, r1->cf);
     899            //tmpR.minpoly=n_Copy(r1->cf->minpoly, r1->cf);
    905900          }
    906901          else
     
    911906        }
    912907      }
    913       else /* r1->minpoly==NULL */
    914       {
    915         if (r2->minpoly!=NULL)
    916         {
    917           if ((!vartest || (strcmp(r1->parameter[0],r2->parameter[0])==0)) /* 1 par */
     908      else /* r1->cf->minpoly==NULL */
     909      {
     910        if (r2->cf->minpoly!=NULL)
     911        {
     912          if ((!vartest || (strcmp(r1->cf->parameter[0],r2->cf->parameter[0])==0)) /* 1 par */
    918913              && (rPar(r1)==1))
    919914          {
    920915            //tmpR.parameter=(char **)omAllocBin(char *);
    921             //tmpR.parameter[0]=omStrDup(r1->parameter[0]);
     916            //tmpR.parameter[0]=omStrDup(r1->cf->parameter[0]);
    922917            //tmpR.P=1;
    923             //tmpR.minpoly=n_Copy(r2->minpoly, r2->cf);
     918            //tmpR.minpoly=n_Copy(r2->cf->minpoly, r2->cf);
    924919          }
    925920          else
     
    932927        {
    933928          int len=rPar(r1)+rPar(r2);
    934           tmpR.parameter=(char **)omAlloc0(len*sizeof(char *));
     929          tmpR.cf->parameter=(char **)omAlloc0(len*sizeof(char *));
    935930          int i;
    936931          for (i=0;i<rPar(r1);i++)
    937932          {
    938             tmpR.parameter[i]=omStrDup(r1->parameter[i]);
     933            tmpR.cf->parameter[i]=omStrDup(r1->cf->parameter[i]);
    939934          }
    940935          int j,l;
     
    945940              for(l=0;l<i;l++)
    946941              {
    947                 if(strcmp(tmpR.parameter[l],r2->parameter[j])==0)
     942                if(strcmp(tmpR.cf->parameter[l],r2->cf->parameter[j])==0)
    948943                  break;
    949944              }
     
    953948            if (l==i)
    954949            {
    955               tmpR.parameter[i]=omStrDup(r2->parameter[j]);
     950              tmpR.cf->parameter[i]=omStrDup(r2->cf->parameter[j]);
    956951              i++;
    957952            }
     
    959954          if (i!=len)
    960955          {
    961             tmpR.parameter=(char**)omReallocSize(tmpR.parameter,
     956            tmpR.cf->parameter=(char**)omReallocSize(tmpR.cf->parameter,
    962957                                                 len*sizeof(char *),
    963958                                                 i*sizeof(char *));
    964959          }
    965           tmpR.P=i;
     960          tmpR.cf->P=i;
    966961        }
    967962      }
     
    998993    #endif
    999994  }
    1000   else /* r1->ch!=r2->ch */
    1001   {
    1002     if (r1->ch<-1) /* Z/p(a) */
    1003     {
    1004       if ((r2->ch==0) /* Q */
    1005           || (r2->ch==-r1->ch)) /* Z/p */
    1006       {
    1007         tmpR.ch=r1->ch;
    1008         tmpR.P=rPar(r1);
    1009         tmpR.parameter=(char **)omAlloc(rPar(r1)*sizeof(char *));
     995  else /* r1->cf->ch!=r2->cf->ch */
     996  {
     997    if (r1->cf->ch<-1) /* Z/p(a) */
     998    {
     999      if ((r2->cf->ch==0) /* Q */
     1000          || (r2->cf->ch==-r1->cf->ch)) /* Z/p */
     1001      {
     1002        tmpR.cf->ch=r1->cf->ch;
     1003        tmpR.cf->P=rPar(r1);
     1004        tmpR.cf->parameter=(char **)omAlloc(rPar(r1)*sizeof(char *));
    10101005        int i;
    10111006        for (i=0;i<rPar(r1);i++)
    10121007        {
    1013           tmpR.parameter[i]=omStrDup(r1->parameter[i]);
    1014         }
    1015         if (r1->minpoly!=NULL)
    1016         {
    1017           tmpR.minpoly=n_Copy(r1->minpoly, r1->cf);
     1008          tmpR.cf->parameter[i]=omStrDup(r1->cf->parameter[i]);
     1009        }
     1010        if (r1->cf->minpoly!=NULL)
     1011        {
     1012          tmpR.cf->minpoly=n_Copy(r1->cf->minpoly, r1->cf);
    10181013        }
    10191014      }
     
    10241019      }
    10251020    }
    1026     else if (r1->ch==-1) /* R */
     1021    else if (r1->cf->ch==-1) /* R */
    10271022    {
    10281023      WerrorS("R+..");
    10291024      return -1;
    10301025    }
    1031     else if (r1->ch==0) /* Q */
    1032     {
    1033       if ((r2->ch<-1)||(r2->ch==1)) /* Z/p(a),Q(a) */
    1034       {
    1035         tmpR.ch=r2->ch;
    1036         tmpR.P=rPar(r2);
    1037         tmpR.parameter=(char **)omAlloc(rPar(r2)*sizeof(char *));
     1026    else if (r1->cf->ch==0) /* Q */
     1027    {
     1028      if ((r2->cf->ch<-1)||(r2->cf->ch==1)) /* Z/p(a),Q(a) */
     1029      {
     1030        tmpR.cf->ch=r2->cf->ch;
     1031        tmpR.cf->P=rPar(r2);
     1032        tmpR.cf->parameter=(char **)omAlloc(rPar(r2)*sizeof(char *));
    10381033        int i;
    10391034        for (i=0;i<rPar(r2);i++)
    10401035        {
    1041           tmpR.parameter[i]=omStrDup(r2->parameter[i]);
    1042         }
    1043         if (r2->minpoly!=NULL)
    1044         {
    1045           tmpR.minpoly=n_Copy(r2->minpoly, r2->cf);
    1046         }
    1047       }
    1048       else if (r2->ch>1) /* Z/p,GF(p,n) */
    1049       {
    1050         tmpR.ch=r2->ch;
    1051         if (r2->parameter!=NULL)
    1052         {
    1053           tmpR.parameter=(char_ptr *)omAllocBin(char_ptr_bin);
    1054           tmpR.P=1;
    1055           tmpR.parameter[0]=omStrDup(r2->parameter[0]);
     1036          tmpR.cf->parameter[i]=omStrDup(r2->cf->parameter[i]);
     1037        }
     1038        if (r2->cf->minpoly!=NULL)
     1039        {
     1040          tmpR.cf->minpoly=n_Copy(r2->cf->minpoly, r2->cf);
     1041        }
     1042      }
     1043      else if (r2->cf->ch>1) /* Z/p,GF(p,n) */
     1044      {
     1045        tmpR.cf->ch=r2->cf->ch;
     1046        if (r2->cf->parameter!=NULL)
     1047        {
     1048          tmpR.cf->parameter=(char_ptr *)omAllocBin(char_ptr_bin);
     1049          tmpR.cf->P=1;
     1050          tmpR.cf->parameter[0]=omStrDup(r2->cf->parameter[0]);
    10561051        }
    10571052      }
     
    10621057      }
    10631058    }
    1064     else if (r1->ch==1) /* Q(a) */
    1065     {
    1066       if (r2->ch==0) /* Q */
    1067       {
    1068         tmpR.ch=r1->ch;
    1069         tmpR.P=rPar(r1);
    1070         tmpR.parameter=(char **)omAlloc(rPar(r1)*sizeof(char *));
     1059    else if (r1->cf->ch==1) /* Q(a) */
     1060    {
     1061      if (r2->cf->ch==0) /* Q */
     1062      {
     1063        tmpR.cf->ch=r1->cf->ch;
     1064        tmpR.cf->P=rPar(r1);
     1065        tmpR.cf->parameter=(char **)omAlloc(rPar(r1)*sizeof(char *));
    10711066        int i;
    10721067        for(i=0;i<rPar(r1);i++)
    10731068        {
    1074           tmpR.parameter[i]=omStrDup(r1->parameter[i]);
    1075         }
    1076         if (r1->minpoly!=NULL)
    1077         {
    1078           tmpR.minpoly=n_Copy(r1->minpoly, r1->cf);
     1069          tmpR.cf->parameter[i]=omStrDup(r1->cf->parameter[i]);
     1070        }
     1071        if (r1->cf->minpoly!=NULL)
     1072        {
     1073          tmpR.cf->minpoly=n_Copy(r1->cf->minpoly, r1->cf);
    10791074        }
    10801075      }
     
    10851080      }
    10861081    }
    1087     else /* r1->ch >=2 , Z/p */
    1088     {
    1089       if (r2->ch==0) /* Q */
    1090       {
    1091         tmpR.ch=r1->ch;
    1092       }
    1093       else if (r2->ch==-r1->ch) /* Z/p(a) */
    1094       {
    1095         tmpR.ch=r2->ch;
    1096         tmpR.P=rPar(r2);
    1097         tmpR.parameter=(char **)omAlloc(rPar(r2)*sizeof(char *));
     1082    else /* r1->cf->ch >=2 , Z/p */
     1083    {
     1084      if (r2->cf->ch==0) /* Q */
     1085      {
     1086        tmpR.cf->ch=r1->cf->ch;
     1087      }
     1088      else if (r2->cf->ch==-r1->cf->ch) /* Z/p(a) */
     1089      {
     1090        tmpR.cf->ch=r2->cf->ch;
     1091        tmpR.cf->P=rPar(r2);
     1092        tmpR.cf->parameter=(char **)omAlloc(rPar(r2)*sizeof(char *));
    10981093        int i;
    10991094        for(i=0;i<rPar(r2);i++)
    11001095        {
    1101           tmpR.parameter[i]=omStrDup(r2->parameter[i]);
    1102         }
    1103         if (r2->minpoly!=NULL)
    1104         {
    1105           tmpR.minpoly=n_Copy(r2->minpoly, r2->cf);
     1096          tmpR.cf->parameter[i]=omStrDup(r2->cf->parameter[i]);
     1097        }
     1098        if (r2->cf->minpoly!=NULL)
     1099        {
     1100          tmpR.cf->minpoly=n_Copy(r2->cf->minpoly, r2->cf);
    11061101        }
    11071102      }
     
    11271122    if (*(r1->names[i]) == '\0')
    11281123      b = FALSE;
    1129     else if ((r2->parameter!=NULL) && (strlen(r1->names[i])==1))
     1124    else if ((r2->cf->parameter!=NULL) && (strlen(r1->names[i])==1))
    11301125    {
    11311126      if (vartest)
     
    11331128        for(j=0;j<rPar(r2);j++)
    11341129        {
    1135           if (strcmp(r1->names[i],r2->parameter[j])==0)
     1130          if (strcmp(r1->names[i],r2->cf->parameter[j])==0)
    11361131          {
    11371132            b=FALSE;
     
    11591154    if (*(r2->names[i]) == '\0')
    11601155      b = FALSE;
    1161     else if ((r1->parameter!=NULL) && (strlen(r2->names[i])==1))
     1156    else if ((r1->cf->parameter!=NULL) && (strlen(r2->names[i])==1))
    11621157    {
    11631158      if (vartest)
     
    11651160        for(j=0;j<rPar(r1);j++)
    11661161        {
    1167           if (strcmp(r2->names[i],r1->parameter[j])==0)
     1162          if (strcmp(r2->names[i],r1->cf->parameter[j])==0)
    11681163          {
    11691164            b=FALSE;
     
    14211416      if (rPar(R2)!=0) par_perm2=(int *)omAlloc0((rPar(R2)+1)*sizeof(int));
    14221417
    1423       maFindPerm(R1->names,  rVar(R1),  R1->parameter,  rPar(R1),
    1424                  sum->names, rVar(sum), sum->parameter, rPar(sum),
    1425                  perm1, par_perm1, sum->ch);
    1426 
    1427       maFindPerm(R2->names,  rVar(R2),  R2->parameter,  rPar(R2),
    1428                  sum->names, rVar(sum), sum->parameter, rPar(sum),
    1429                  perm2, par_perm2, sum->ch);
     1418      maFindPerm(R1->names,  rVar(R1),  R1->cf->parameter,  rPar(R1),
     1419                 sum->names, rVar(sum), sum->cf->parameter, rPar(sum),
     1420                 perm1, par_perm1, sum->cf->ch);
     1421
     1422      maFindPerm(R2->names,  rVar(R2),  R2->cf->parameter,  rPar(R2),
     1423                 sum->names, rVar(sum), sum->cf->parameter, rPar(sum),
     1424                 perm2, par_perm2, sum->cf->ch);
    14301425
    14311426
     
    15261521    int *par_perm1 = NULL;
    15271522    if (rPar(r1)!=0) par_perm1=(int *)omAlloc0((rPar(r1)+1)*sizeof(int));
    1528     maFindPerm(r1->names,  rVar(r1),  r1->parameter,  rPar(r1),
    1529                sum->names, rVar(sum), sum->parameter, rPar(sum),
    1530                perm1, par_perm1, sum->ch);
     1523    maFindPerm(r1->names,  rVar(r1),  r1->cf->parameter,  rPar(r1),
     1524               sum->names, rVar(sum), sum->cf->parameter, rPar(sum),
     1525               perm1, par_perm1, sum->cf->ch);
    15311526    nMapFunc nMap1 = n_SetMap(r1->cf,sum->cf);
    15321527    Q1 = idInit(IDELEMS(r1->qideal),1);
     
    15491544    int *par_perm2 = NULL;
    15501545    if (rPar(r2)!=0) par_perm2=(int *)omAlloc0((rPar(r2)+1)*sizeof(int));
    1551     maFindPerm(r2->names,  rVar(r2),  r2->parameter,  rPar(r2),
    1552                sum->names, rVar(sum), sum->parameter, rPar(sum),
    1553                perm2, par_perm2, sum->ch);
     1546    maFindPerm(r2->names,  rVar(r2),  r2->cf->parameter,  rPar(r2),
     1547               sum->names, rVar(sum), sum->cf->parameter, rPar(sum),
     1548               perm2, par_perm2, sum->cf->ch);
    15541549    nMapFunc nMap2 = n_SetMap(r2->cf,sum->cf);
    15551550    Q2 = idInit(IDELEMS(r2->qideal),1);
     
    16201615  //struct omBin   PolyBin; /* Bin from where monoms are allocated */
    16211616  //memset: res->PolyBin=NULL; // rComplete
    1622   res->ch=r->ch;     /* characteristic */
     1617  res->cf->ch=r->cf->ch;     /* characteristic */
    16231618#ifdef HAVE_RINGS
    16241619  res->cf->ringtype = r->cf->ringtype;  // cring = 0 => coefficient field, cring = 1 => coeffs from Z/2^m
     
    16401635  res->float_len2=r->float_len2; /* additional char-flags */
    16411636
    1642   res->N=r->N;      /* number of vars */
    1643   res->P=r->P;      /* number of pars */
     1637  res->N=rVar(r);      /* number of vars */
     1638  res->cf->P=rPar(r);      /* number of pars */
    16441639  res->OrdSgn=r->OrdSgn; /* 1 for polynomial rings, -1 otherwise */
    16451640
     
    16971692  res->algring=r->algring;
    16981693  //memset: res->minideal=NULL;
    1699   if (r->parameter!=NULL)
    1700   {
    1701     if (r->minpoly!=NULL) res->minpoly=n_Copy(r->minpoly,r->cf);
     1694  if (r->cf->parameter!=NULL)
     1695  {
     1696    if (r->cf->minpoly!=NULL) res->cf->minpoly=n_Copy(r->cf->minpoly,r->cf);
    17021697    int l=rPar(r);
    1703     res->parameter=(char **)omAlloc(l*sizeof(char *));
     1698    res->cf->parameter=(char **)omAlloc(l*sizeof(char *));
    17041699    int i;
    17051700    for(i=0;i<rPar(r);i++)
    17061701    {
    1707       res->parameter[i]=omStrDup(r->parameter[i]);
     1702      res->cf->parameter[i]=omStrDup(r->cf->parameter[i]);
    17081703    }
    17091704    if (r->minideal!=NULL)
     
    18451840  for (i=0; i<rPar(r1);i++)
    18461841  {
    1847       if (strcmp(r1->parameter[i], r2->parameter[i])!=0)
     1842      if (strcmp(r1->cf->parameter[i], r2->cf->parameter[i])!=0)
    18481843        return FALSE;
    18491844  }
    18501845
    1851   if (r1->minpoly != NULL)
    1852   {
    1853     if (r2->minpoly == NULL) return FALSE;
    1854     if (! n_Equal(r1->minpoly, r2->minpoly, r1->cf)) return FALSE;
    1855   }
    1856   else if (r2->minpoly != NULL) return FALSE;
     1846  if (r1->cf->minpoly != NULL)
     1847  {
     1848    if (r2->cf->minpoly == NULL) return FALSE;
     1849    if (! n_Equal(r1->cf->minpoly, r2->cf->minpoly, r1->cf)) return FALSE;
     1850  }
     1851  else if (r2->cf->minpoly != NULL) return FALSE;
    18571852
    18581853  if (qr)
     
    22762271    }
    22772272  }
    2278   if (r->minpoly!=NULL)
    2279   {
    2280     omCheckAddr(r->minpoly);
     2273  if (r->cf->minpoly!=NULL)
     2274  {
     2275    omCheckAddr(r->cf->minpoly);
    22812276  }
    22822277  //assume(r->cf!=NULL);
     
    31603155  {
    31613156    int i;
    3162     if (r->parameter!=NULL)
     3157    if (r->cf->parameter!=NULL)
    31633158    {
    31643159      for (i=0;i<rPar(r);i++)
    31653160      {
    3166         if(strlen(r->parameter[i])>1)
     3161        if(strlen(r->cf->parameter[i])>1)
    31673162        {
    31683163          r->ShortOut=FALSE;
     
    55055500
    55065501        assume(MATELEM(src->GetNC()->C,i,j) != NULL);
    5507         MATELEM(C,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->C,i,j),perm,src,r, nMap,par_perm,src->P);
     5502        MATELEM(C,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->C,i,j),perm,src,r, nMap,par_perm,rPar(src));
    55085503
    55095504        if(MATELEM(src->GetNC()->D,i,j) != NULL)
    5510           MATELEM(D,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->D,i,j),perm,src,r, nMap,par_perm,src->P);
     5505          MATELEM(D,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->D,i,j),perm,src,r, nMap,par_perm,rPar(src));
    55115506      }
    55125507    }
  • libpolys/polys/monomials/ring.h

    r0b7bf7 r01c1d0  
    196196  int*       block0; /* starting pos., rInit/rSleftvOrdering2Ordering*/
    197197  int*       block1; /* ending pos., rInit/rSleftvOrdering2Ordering*/
    198   char**     parameter; /* names of parameters, rInit */
    199   number     minpoly;  /* for Q_a/Zp_a, rInit */
     198//  char**     parameter; /* names of parameters, rInit */
     199//  number     minpoly;  /* for Q_a/Zp_a, rInit */
    200200  ideal      minideal;
    201201  int**      wvhdl;  /* array of weight vectors, rInit/rSleftvOrdering2Ordering */
     
    234234  unsigned long options; /* ring dependent options */
    235235
    236   int        ch;  /* characteristic, rInit */
     236//  int        ch;  /* characteristic, rInit */
    237237  int        ref; /* reference counter to the ring, interpreter */
    238238
     
    242242  short      N;      /* number of vars, rInit */
    243243
    244   short      P;      /* number of pars, rInit */
    245244  short      OrdSgn; /* 1 for polynomial rings, -1 otherwise, rInit */
    246245
     
    259258  BOOLEAN   LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
    260259  BOOLEAN   MixedOrder; // TRUE for global/local mixed orderings, FALSE otherwise
    261   BOOLEAN pLexOrder; /* TRUE if the monomial ordering is not compatible with pFDeg */
     260  BOOLEAN   pLexOrder; /* TRUE if the monomial ordering is not compatible with pFDeg */
    262261
    263262  BOOLEAN   ComponentOrder; // ???
     
    402401char * rString(ring r);
    403402int    rChar(ring r);
    404 #define rPar(r) (r->P)
     403#define rPar(r) (r->cf->P)
    405404#define rVar(r) (r->N)
    406405char * rParStr(ring r);
     
    451450
    452451static inline BOOLEAN rField_is_Zp(const ring r, int p)
    453 { assume(r != NULL); return (getCoeffType(r->cf) == n_Zp) && (r->ch == p); }
     452{ assume(r != NULL); return (getCoeffType(r->cf) == n_Zp) && (r->cf->ch == p); }
    454453
    455454static inline BOOLEAN rField_is_Q(const ring r)
  • libpolys/polys/nc/gring.cc

    r0b7bf7 r01c1d0  
    37713771  //  else
    37723772  {
    3773     int *perm = (int *)omAlloc0((srcRing->N+1)*sizeof(int));
    3774     int *par_perm = (int *)omAlloc0((srcRing->P+1)*sizeof(int));
    3775     //    int *par_perm = (int *)omAlloc0((srcRing->P+1)*sizeof(int));
     3773    int *perm = (int *)omAlloc0((rVar(srcRing)+1)*sizeof(int));
     3774    int *par_perm = (int *)omAlloc0((rPar(srcRing)+1)*sizeof(int));
     3775    //    int *par_perm = (int *)omAlloc0((rPar(srcRing)+1)*sizeof(int));
    37763776    int i;
    37773777    //    if (srcRing->P > 0)
     
    37803780    //  par_perm[i]=-i;
    37813781    //    }
    3782     if ((shift<0) || (shift > srcRing->N)) // ???
     3782    if ((shift<0) || (shift > rVar(srcRing))) // ???
    37833783    {
    37843784      Werror("bad shifts in p_CopyEmbed");
     
    37893789      perm[i] = shift+i;
    37903790    }
    3791     q = p_PermPoly(p,perm,srcRing, dstRing, nMap,par_perm,srcRing->P);
     3791    q = p_PermPoly(p,perm,srcRing, dstRing, nMap,par_perm, rPar(srcRing));
    37923792  }
    37933793  return(q);
  • libpolys/polys/polys0.cc

    r0b7bf7 r01c1d0  
    3636    n_Write(p->coef,r->cf);
    3737    wroteCoef=(rShortOut(r) == FALSE)
    38     || (r->parameter!=NULL)
     38    || (r->cf->parameter!=NULL)
    3939    || rField_is_R(r) || (rField_is_long_R(r)) || (rField_is_long_C(r));
    4040    writeGen=TRUE;
     
    4646      n_Write(p->coef,r->cf);
    4747      wroteCoef=(rShortOut(r) == FALSE)
    48       || (r->parameter!=NULL)
     48      || (r->cf->parameter!=NULL)
    4949      || rField_is_R(r) || (rField_is_long_R(r)) || (rField_is_long_C(r));
    5050      writeGen=TRUE;
  • libpolys/polys/templates/p_Procs_Set.h

    r0b7bf7 r01c1d0  
    155155  extern poly p_Mult_nn_pthread(poly p, const number n, const ring r);
    156156  #ifdef NV_OPS
    157   if ((field==FieldZp) && (r->ch>NV_MAX_PRIME))
     157  if ((field==FieldZp) && (r->cf->ch>NV_MAX_PRIME))
    158158  {
    159159    // set all (mult/div.) routines to FieldGeneral-variants
Note: See TracChangeset for help on using the changeset viewer.