Changeset 861529 in git


Ignore:
Timestamp:
Jul 26, 2011, 1:21:51 PM (12 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'f875bbaccd0831e36aaed09ff6adeb3eb45aeb94')
Children:
92058150caf53dc60a028c63bafb64f39bfa73a8
Parents:
b7cfaff1d9a4ec8364a64a54d2b7e009f91418e2
git-author:
Hans Schoenemann <hannes@mathematik.uni-kl.de>2011-07-26 13:21:51+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 12:53:34+01:00
Message:
fix pShift -> p_Shift
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • Singular/iparith.cc

    rb7cfaf r861529  
    64076407  {
    64086408    if(v1->Typ()==POLY_CMD)
    6409       pShift(&R->m[0],-1);
     6409      p_Shift(&R->m[0],-1,currRing);
    64106410    L->m[1].data=(void *)R->m[0];
    64116411    R->m[0]=NULL;

  • kernel/ideals.cc

    rb7cfaf r861529  
    274274  rChangeCurrRing(r);
    275275  // create 1-t, t
    276   poly omt=pOne();
    277   pSetExp(omt,r->N,1);
    278   poly t=pCopy(omt);
    279   pSetm(omt);
    280   omt=pNeg(omt);
    281   omt=pAdd(omt,pOne());
     276  poly omt=p_One(currRing);
     277  p_SetExp(omt,r->N,1,currRing);
     278  poly t=p_Copy(omt,currRing);
     279  p_Setm(omt,currRing);
     280  omt=p_Neg(omt,currRing);
     281  omt=p_Add_q(omt,pOne(),currRing);
    282282  // compute (1-t)*h1
    283   h1=(ideal)mpMultP((matrix)h1,omt);
     283  h1=(ideal)mp_MultP((matrix)h1,omt,currRing);
    284284  // compute t*h2
    285   h2=(ideal)mpMultP((matrix)h2,pCopy(t));
     285  h2=(ideal)mp_MultP((matrix)h2,pCopy(t),currRing);
    286286  // (1-t)h1 + t*h2
    287287  h=idInit(IDELEMS(h1)+IDELEMS(h2),1);
    … …  
    347347
    348348  ring orig_ring=currRing;
    349   ring syz_ring=rCurrRingAssure_SyzComp();
     349  ring syz_ring=rAssure_SyzComp(orig_ring,TRUE);
     350  rChangeCurrRing(syz_ring);
    350351  rSetSyzComp(length, syz_ring);
    351352
    … …  
    360361        temp->m[k] = pCopy(first->m[i]);
    361362      else
    362         temp->m[k] = prCopyR(first->m[i], orig_ring);
     363        temp->m[k] = prCopyR(first->m[i], orig_ring, syz_ring);
    363364      q = pOne();
    364365      pSetComp(q,i+1+length);
    365366      pSetmComp(q);
    366       if (flength==0) pShift(&(temp->m[k]),1);
     367      if (flength==0) p_Shift(&(temp->m[k]),1,currRing);
    367368      p = temp->m[k];
    368369      while (pNext(p)!=NULL) pIter(p);
    … …  
    378379        temp->m[k] = pCopy(second->m[i]);
    379380      else
    380         temp->m[k] = prCopyR(second->m[i], orig_ring);
    381       if (slength==0) pShift(&(temp->m[k]),1);
     381        temp->m[k] = prCopyR(second->m[i], orig_ring,currRing);
     382      if (slength==0) p_Shift(&(temp->m[k]),1,currRing);
    382383      k++;
    383384    }
    … …  
    486487
    487488  ring orig_ring=currRing;
    488   ring syz_ring=rCurrRingAssure_SyzComp();
     489  ring syz_ring=rAssure_SyzComp(orig_ring,TRUE);
     490  rChangeCurrRing(syz_ring);
    489491  rSetSyzComp(syzComp, syz_ring);
    490492
    … …  
    515517            bigmat->m[i] = pCopy(arg[j]->m[l]);
    516518          else
    517             bigmat->m[i] = prCopyR(arg[j]->m[l], orig_ring);
    518           pShift(&(bigmat->m[i]),k*maxrk+isIdeal);
     519            bigmat->m[i] = prCopyR(arg[j]->m[l], orig_ring,currRing);
     520          p_Shift(&(bigmat->m[i]),k*maxrk+isIdeal,currRing);
    519521          i++;
    520522        }
    … …  
    542544      else
    543545        p = prCopyR(tempstd->m[j], syz_ring);
    544       pShift(&p,-syzComp-isIdeal);
     546      p_Shift(&p,-syzComp-isIdeal,currRing);
    545547      result->m[k] = p;
    546548      k++;
    … …  
    578580  if (k == 0)
    579581  {
    580     for (j=0; j<=i; j++) pShift(&(h2->m[j]),1);
     582    for (j=0; j<=i; j++) p_Shift(&(h2->m[j]),1,currRing);
    581583    k = 1;
    582584  }
    … …  
    678680  {
    679681    ideal result=idFreeModule(idElemens_h1/*IDELEMS(h1)*/);
    680     int curr_syz_limit=rGetCurrSyzLimit();
     682    int curr_syz_limit=rGetCurrSyzLimit(currRing);
    681683    if (curr_syz_limit>0)
    682684    for (ii=0;ii<idElemens_h1/*IDELEMS(h1)*/;ii++)
    683685    {
    684686      if (h1->m[ii]!=NULL)
    685         pShift(&h1->m[ii],curr_syz_limit);
     687        p_Shift(&h1->m[ii],curr_syz_limit,currRing);
    686688    }
    687689    return result;
    … …  
    692694  assume(currRing != NULL);
    693695  ring orig_ring=currRing;
    694   ring syz_ring=rCurrRingAssure_SyzComp();
     696  ring syz_ring=rAssure_SyzComp(orig_ring.TRUE);
     697  rChangeCurrRing(syz_ring);
    695698
    696699  if (setSyzComp)
    … …  
    723726      {
    724727        if (p_MinComp(s_h3->m[j],syz_ring) > k)
    725           pShift(&s_h3->m[j], -k);
     728          p_Shift(&s_h3->m[j], -k,currRing);
    726729        else
    727730          pDelete(&s_h3->m[j]);
    … …  
    814817  assume(currRing != NULL);
    815818  ring orig_ring=currRing;
    816   ring syz_ring=rCurrRingAssure_SyzComp();
     819  ring syz_ring=rAssure_SyzComp(orig_ring,TRUE);
     820  rChangeCurrRing(syz_ring);
    817821
    818822  rSetSyzComp(k,syz_ring);
    … …  
    869873    {
    870874      *syz=idFreeModule(IDELEMS(h1));
    871       int curr_syz_limit=rGetCurrSyzLimit();
     875      int curr_syz_limit=rGetCurrSyzLimit(currRing);
    872876      if (curr_syz_limit>0)
    873877      for (int ii=0;ii<IDELEMS(h1);ii++)
    874878      {
    875879        if (h1->m[ii]!=NULL)
    876           pShift(&h1->m[ii],curr_syz_limit);
     880          p_Shift(&h1->m[ii],curr_syz_limit,currRing);
    877881      }
    878882    }
    … …  
    887891
    888892  ring orig_ring = currRing;
    889   ring syz_ring = rCurrRingAssure_SyzComp();
     893  ring syz_ring = rAssure_SyzComp(orig_ring,TRUE);
     894  rChangeCurrRing(syz_ring);
    890895  rSetSyzComp(k,syz_ring);
    891896
    … …  
    930935          }
    931936        }
    932         if (!inputIsIdeal) pShift(&(s_h3->m[j]), -1);
     937        if (!inputIsIdeal) p_Shift(&(s_h3->m[j]), -1,currRing);
    933938      }
    934939      else
    … …  
    937942        if (lift3)
    938943        {
    939           pShift(&s_h3->m[j], -k);
     944          p_Shift(&s_h3->m[j], -k,currRing);
    940945          (*syz)->m[j]=s_h3->m[j];
    941946          s_h3->m[j]=NULL;
    … …  
    10941099
    10951100  ring orig_ring=currRing;
    1096   ring syz_ring=rCurrRingAssure_SyzComp();
     1101  ring syz_ring=rAssure_SyzComp(orig_ring,TRUE);
     1102  rChangeCurrRing(syz_ring);
    10971103  rSetSyzComp(k,syz_ring);
    10981104
    … …  
    11321138    {
    11331139      if (s_temp->m[j-1]!=NULL)
    1134         pShift(&(s_temp->m[j-1]),1);
     1140        p_Shift(&(s_temp->m[j-1]),1,currRing);
    11351141    }
    11361142  }
    … …  
    11851191        }
    11861192      }
    1187       pShift(&(s_result->m[j]),-k);
     1193      p_Shift(&(s_result->m[j]),-k,currRing);
    11881194      pNeg(s_result->m[j]);
    11891195    }
    … …  
    11951201      if (s_rest->m[j-1]!=NULL)
    11961202      {
    1197         pShift(&(s_rest->m[j-1]),-1);
     1203        p_Shift(&(s_rest->m[j-1]),-1,currRing);
    11981204        s_rest->m[j-1] = s_rest->m[j-1];
    11991205      }
    … …  
    12451251        }
    12461252      }
    1247       pShift(&s_result->m[i],-comps_to_add);
     1253      p_Shift(&s_result->m[i],-comps_to_add,currRing);
    12481254    }
    12491255  }
    … …  
    13511357      p = pCopy(h2->m[i]);
    13521358      if (k2 == 0)
    1353         pShift(&p,j*k+1);
     1359        p_Shift(&p,j*k+1,currRing);
    13541360      else
    1355         pShift(&p,j*k);
     1361        p_Shift(&p,j*k,currRing);
    13561362      q = pAdd(q,p);
    13571363      j++;
    … …  
    13811387      {
    13821388        p = pCopy_noCheck(h4->m[i-1]);
    1383         pShift(&p,1);
     1389        p_Shift(&p,1,currRing);
    13841390        h4->m[i] = p;
    13851391      }
    … …  
    13971403        p = pCopy(temph1->m[l]);
    13981404        if (k1 == 0)
    1399           pShift(&p,ll*k+1);
     1405          p_Shift(&p,ll*k+1,currRing);
    14001406        else
    1401           pShift(&p,ll*k);
     1407          p_Shift(&p,ll*k,currRing);
    14021408        if (kkk >= IDELEMS(h4))
    14031409        {
    … …  
    14541460
    14551461  ring orig_ring=currRing;
    1456   ring syz_ring=rCurrRingAssure_SyzComp();
     1462  ring syz_ring=rAssure_SyzComp(orig_ring.TRUE);
     1463  rChangeCurrRing(syz_ring);
    14571464  rSetSyzComp(kmax-1,syz_ring);
    14581465  if (orig_ring!=syz_ring)
    … …  
    14951502    {
    14961503      if (resultIsIdeal)
    1497         pShift(&s_h3->m[i],-kmax);
     1504        p_Shift(&s_h3->m[i],-kmax,currRing);
    14981505      else
    1499         pShift(&s_h3->m[i],-kmax+1);
     1506        p_Shift(&s_h3->m[i],-kmax+1,currRing);
    15001507    }
    15011508    else
    … …  
    21382145    else
    21392146    {
    2140       pShift(&(temp1->m[i]),-length);
     2147      p_Shift(&(temp1->m[i]),-length,currRing);
    21412148    }
    21422149  }
    … …  
    21992206    if(temp->m[i]!=NULL)
    22002207    {
    2201       if (slength==0) pShift(&(temp->m[i]),1);
     2208      if (slength==0) p_Shift(&(temp->m[i]),1,currRing);
    22022209      p = temp->m[i];
    22032210      while (pNext(p)!=NULL) pIter(p);
    … …  
    22172224      {
    22182225        temp->m[k] = pCopy(h1->m[i]);
    2219         if (flength==0) pShift(&(temp->m[k]),1);
     2226        if (flength==0) p_Shift(&(temp->m[k]),1,currRing);
    22202227        k++;
    22212228      }
    … …  
    22242231
    22252232  ring orig_ring=currRing;
    2226   ring syz_ring=rCurrRingAssure_SyzComp();
     2233  ring syz_ring=rAssure_SyzComp(orig_ring.TRUE);
     2234  rChangeCurrRing(syz_ring);
    22272235  rSetSyzComp(length, syz_ring);
    22282236  ideal s_temp;
    … …  
    22592267    else
    22602268    {
    2261       pShift(&(s_temp1->m[i]),-length);
     2269      p_Shift(&(s_temp1->m[i]),-length,currRing);
    22622270    }
    22632271  }

  • kernel/ideals.h

    rb7cfaf r861529  
    116116int pLowVar (poly p);
    117117  /*-the minimal index of used variables - 1-*/
    118 void pShift (poly * p,int i);
    119   /*- verschiebt die Indizes der Modulerzeugenden um i -*/
    120118void    idInitChoise (int r,int beg,int end,BOOLEAN *endch,int * choise);
    121119void    idGetNextChoise (int r,int end,BOOLEAN *endch,int * choise);

  • kernel/syz.cc

    rb7cfaf r861529  
    598598      for (j=0; j<IDELEMS(res[i]); j++)
    599599      {
    600         pShift(&res[i]->m[j], -rGetMaxSyzComp(i));
     600        p_Shift(&res[i]->m[j], -rGetMaxSyzComp(i),currRing);
    601601      }
    602602    }

  • kernel/syz0.cc

    rb7cfaf r861529  
    423423            IDELEMS(result) += 16;
    424424          }
    425           //pShift(&toRed,-rkF);
     425          //p_Shift(&toRed,-rkF,currRing);
    426426          pNorm(toRed);
    427427          (*Shdl)[Sl] = toRed;
    … …  
    839839  {
    840840    if (arg->m[i]!=NULL)
    841       pShift(&arg->m[i],-j);
     841      p_Shift(&arg->m[i],-j,currRing);
    842842  }
    843843}

  • kernel/syz3.cc

    rb7cfaf r861529  
    123123  if (pGetComp(gen)>0)
    124124  {
    125     pShift(&gen,-1);
    126     pShift(&neg_gen,-1);
     125    p_Shift(&gen,-1,currRing);
     126    p_Shift(&neg_gen,-1,currRing);
    127127  }
    128128  while (index>0)
    … …  
    194194          syzstr->res[index]->m[i+start] = pCopy(current_ideal->m[i]);
    195195          syzstr->res[index]->m[i+start] = pMult_mm(syzstr->res[index]->m[i+start],w_gen);
    196           pShift(&syzstr->res[index]->m[i+start],current_tl);
     196          p_Shift(&syzstr->res[index]->m[i+start],current_tl,currRing);
    197197          syzstr->res[index]->m[i+start] = pAdd(syzstr->res[index]->m[i+start],
    198198            ppMult_qq(current_repr->m[i],p));
    … …  
    201201            pMult_mm(syzstr->orderedRes[index]->m[i+start],w_gen);
    202202          if ((*syzstr->Tl)[index]!=0)
    203             pShift(&syzstr->orderedRes[index]->m[i+start],(*syzstr->Tl)[index]);
     203            p_Shift(&syzstr->orderedRes[index]->m[i+start],(*syzstr->Tl)[index],currRing);
    204204        }
    205205      }
    … …  
    212212          totake[index]->m[i+start_ttk] =
    213213            pMult_mm(pCopy(totake[index-1]->m[i]),w_gen);
    214           pShift(&totake[index]->m[i+start_ttk],current_tl);
     214          p_Shift(&totake[index]->m[i+start_ttk],current_tl,currRing);
    215215#ifdef FULL_TOTAKE
    216216          poly pp=pCopy(p);
    217           pShift(&pp,i+1);
     217          p_Shift(&pp,i+1,currRing);
    218218          totake[index]->m[i+start_ttk] = pAdd(totake[index]->m[i+start_ttk],pp);
    219219#endif
    … …  
    690690      tso.p = NULL;
    691691      p = pCopy(tso.p1);
    692       pShift(&p,-1);
     692      p_Shift(&p,-1,currRing);
    693693#ifdef WITH_BUCKET
    694694      poly pp;
    … …  
    706706      pDelete(&pp);
    707707      p = pCopy(tso.p2);
    708       pShift(&p,-1);
     708      p_Shift(&p,-1,currRing);
    709709      pp = pCopy(old_repr->m[tso.ind1]);
    710710      il=-1;
    … …  
    719719      tso.syz = pMult(p,pCopy(old_repr->m[tso.ind2]));
    720720      p = pCopy(tso.p2);
    721       pShift(&p,-1);
     721      p_Shift(&p,-1,currRing);
    722722      tso.syz = pSub(tso.syz,pMult(p,pCopy(old_repr->m[tso.ind1])));
    723723#endif
    … …  
    12321232      pNext(pp1) = NULL;
    12331233      pNext(pp2) = NULL;
    1234       //pShift(&p1,-ac);
    1235       //pShift(&p2,-ac);
     1234      //p_Shift(&p1,-ac,currRing);
     1235      //p_Shift(&p2,-ac,currRing);
    12361236      tp1 = pMult(tp1,pCopy(p2));
    12371237      tp2 = pMult(tp2,pCopy(p1));
    … …  
    17791779    {
    17801780      if (temp->m[j]!=NULL)
    1781         pShift(&temp->m[j],1);
     1781        p_Shift(&temp->m[j],1,currRing);
    17821782    }
    17831783  }
Note: See TracChangeset for help on using the changeset viewer.