Changeset e94918 in git


Ignore:
Timestamp:
Aug 3, 2011, 5:40:29 PM (12 years ago)
Author:
Martin Lee <martinlee84@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')
Children:
3bef0a1d1e460c3e6aea207800d6677a02625ba9
Parents:
8fa9eac11b7255f081ef96ac76bf845c0fc38c59
git-author:
Martin Lee <martinlee84@web.de>2011-08-03 17:40:29+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 13:14:17+01:00
Message:
fixed walk.cc but still currRingHdl needs to be fixed
File:
1 edited

Legend:

Unmodified
Added
Removed

  • Singular/walk.cc

    r8fa9ea re94918  
    5757#include <polys/ext_fields/longalg.h>
    5858#include <coeffs/ffields.h>
     59#include <coeffs/coeffs.h>
    5960#include <Singular/subexpr.h>
    6061#include <polys/templates/p_Procs.h>
    … …  
    290291  strat->kHEdgeFound = ppNoether != NULL;
    291292  strat->kNoether=pCopy(ppNoether);
    292   strat->ak = idRankFreeModule(F);
     293  strat->ak = id_RankFreeModule(F, currRing);
    293294  initBuchMoraCrit(strat);
    294   strat->NotUsedAxis = (BOOLEAN *)omAlloc((pVariables+1)*sizeof(BOOLEAN));
    295   for (j=pVariables; j>0; j--) strat->NotUsedAxis[j] = TRUE;
     295  strat->NotUsedAxis = (BOOLEAN *)omAlloc((currRing->N+1)*sizeof(BOOLEAN));
     296  for (j=currRing->N; j>0; j--) strat->NotUsedAxis[j] = TRUE;
    296297  strat->enterS      = enterSBba;
    297298  strat->posInT      = posInT0;
    … …  
    325326  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
    326327  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
    327   omFreeSize((ADDRESS)strat->NotUsedAxis,(pVariables+1)*sizeof(BOOLEAN));
     328  omFreeSize((ADDRESS)strat->NotUsedAxis,(currRing->N+1)*sizeof(BOOLEAN));
    328329  omfree(strat->sevT);
    329330  omfree(strat->S_2_R);
    … …  
    564565  mpz_init(zsum);
    565566
    566   for (i=pVariables; i>0; i--)
     567  for (i=currRing->N; i>0; i--)
    567568  {
    568569    mpz_set_si(zvec, (*weight)[i-1]);
    … …  
    625626  mpz_init(ztmp);
    626627
    627   for (i=pVariables; i>0; i--)
     628  for (i=currRing->N; i>0; i--)
    628629  {
    629630    mpz_set_si(zvec, (*weight)[i-1]);
    … …  
    895896  intvec* ivUnit = Mivdp(nV);//19.02
    896897  int i,j, tmpdeg, maxdeg=0;
    897   number tmpcoeff , maxcoeff=nNULL;
     898  number tmpcoeff , maxcoeff=currRing->cf->nNULL;
    898899  poly p;
    899900  for(i=nG-1; i>=0; i--)
    … …  
    18171818  int i, nv = currRing->N;
    18181819
    1819   r->ch  = currRing->ch;
     1820  r->cf->ch  = rChar (currRing);
    18201821  r->N   = currRing->N;
    18211822  int nb = rBlocks(currRing) + 1;//31.10.01 (+1)
    … …  
    18911892  int i, nv = currRing->N;
    18921893
    1893   r->ch  = currRing->ch;
     1894  r->cf->ch  = rChar (currRing);
    18941895  r->N   = currRing->N;
    18951896  int nb = rBlocks(currRing) + 1;//31.10.01 (+1)
    … …  
    19501951  res->VarOffset = NULL;
    19511952  res->ref=0;
    1952   if (currRing->extRing!=NULL)
    1953     currRing->extRing->ref++;
    1954 
    1955   if (currRing->parameter!=NULL)
    1956   {
    1957     res->minpoly=nCopy(currRing->minpoly);
     1953  if (currRing->cf->extRing!=NULL)
     1954    currRing->cf->extRing->ref++;
     1955
     1956  if (rParameter (currRing)!=NULL)
     1957  {
     1958    res->cf->extRing->minideal->m[0]=p_Copy(currRing->cf->extRing->minideal->m[0],currRing->cf->extRing);
    19581959    int l=rPar(currRing);
    1959     res->parameter=(char **)omAlloc(l*sizeof(char_ptr));
     1960    res->cf->extRing->names=(char **)omAlloc(l*sizeof(char_ptr));
    19601961
    19611962    for(i=l-1;i>=0;i--)
    1962       res->parameter[i]=omStrDup(currRing->parameter[i]);
     1963      rParameter (res)[i]=omStrDup(rParameter (currRing)[i]);
    19631964  }
    19641965
    … …  
    20292030  r->VarOffset = NULL;
    20302031  r->ref=0;
    2031   if (currRing->extRing!=NULL)
    2032     currRing->extRing->ref++;
    2033 
    2034   if (currRing->parameter!=NULL)
    2035   {
    2036     r->minpoly=nCopy(currRing->minpoly);
     2032  if (currRing->cf->extRing!=NULL)
     2033    currRing->cf->extRing->ref++;
     2034
     2035  if (rParameter (currRing)!=NULL)
     2036  {
     2037    r->cf->extRing->minideal->m[0]=p_Copy(currRing->cf->extRing->minideal->m[0], currRing->cf->extRing);
    20372038    int l=rPar(currRing);
    2038     r->parameter=(char **)omAlloc(l*sizeof(char_ptr));
     2039    r->cf->extRing->names=(char **)omAlloc(l*sizeof(char_ptr));
    20392040
    20402041    for(i=l-1;i>=0;i--)
    2041       r->parameter[i]=omStrDup(currRing->parameter[i]);
    2042   }
    2043 
    2044 
    2045   r->ch  = currRing->ch;
     2042      rParameter(r)[i]=omStrDup(rParameter (currRing)[i]);
     2043  }
     2044
     2045
     2046  r->cf->ch  = rChar (currRing);
    20462047  r->N   = currRing->N;
    20472048  int nb = rBlocks(currRing) + 1;//31.10.01 (+1)
    … …  
    20802081
    20812082
    2082   if (currRing->parameter!=NULL)
    2083   {
    2084     r->minpoly=nCopy(currRing->minpoly);
     2083  if (rParameter(currRing)!=NULL)
     2084  {
     2085    r->cf->extRing->minideal->m[0]=p_Copy(currRing->cf->extRing->minideal->m[0], currRing->cf->extRing);
    20852086    int l=rPar(currRing);
    2086     r->parameter=(char **)omAlloc(l*sizeof(char_ptr));
     2087    r->cf->extRing->names=(char **)omAlloc(l*sizeof(char_ptr));
    20872088
    20882089    for(i=l-1;i>=0;i--)
    2089       r->parameter[i]=omStrDup(currRing->parameter[i]);
     2090      rParameter(r)[i]=omStrDup(rParameter(currRing)[i]);
    20902091  }
    20912092
    … …  
    21562157  {
    21572158    //..25.03.03 VMrDefaultlp();//    VMrDefault(target_weight);
    2158     if (currRing->parameter != NULL)
     2159    if (rParameter (currRing) != NULL)
    21592160      DefRingParlp();
    21602161    else
    … …  
    21622163
    21632164    TargetRing = currRing;
    2164     ssG = idrMoveR(G,EXXRing);
     2165    ssG = idrMoveR(G,EXXRing,currRing);
    21652166    iv_M_lp = MivMatrixOrderlp(nV);
    21662167    //target_weight = MPertVectorslp(ssG, iv_M_lp, tp_deg);
    … …  
    21702171
    21712172    rChangeCurrRing(EXXRing);
    2172     G = idrMoveR(ssG, TargetRing);
     2173    G = idrMoveR(ssG, TargetRing,currRing);
    21732174  }
    21742175  else
    … …  
    22422243    /* define a new ring that its ordering is "(a(curr_weight),lp) */
    22432244    //..25.03.03 VMrDefault(curr_weight);
    2244     if (currRing->parameter != NULL)
     2245    if (rParameter (currRing) != NULL)
    22452246      DefRingPar(curr_weight);
    22462247    else
    … …  
    22482249
    22492250    newRing = currRing;
    2250     Gomega1 = idrMoveR(Gomega, oldRing);
     2251    Gomega1 = idrMoveR(Gomega, oldRing,currRing);
    22512252
    22522253    to=clock();
    … …  
    22612262    /* change the ring to oldRing */
    22622263    rChangeCurrRing(oldRing);
    2263     M1 =  idrMoveR(M, newRing);
    2264     Gomega2 =  idrMoveR(Gomega1, newRing);
     2264    M1 =  idrMoveR(M, newRing,currRing);
     2265    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
    22652266
    22662267    to=clock();
    … …  
    22742275    /* change the ring to newRing */
    22752276    rChangeCurrRing(newRing);
    2276     F1 = idrMoveR(F, oldRing);
     2277    F1 = idrMoveR(F, oldRing,currRing);
    22772278
    22782279    to=clock();
    … …  
    22952296  {
    22962297    //..25.03.03 VMrDefaultlp();//define and execute the ring "lp"
    2297     if (currRing->parameter != NULL)
     2298    if (rParameter (currRing) != NULL)
    22982299      DefRingParlp();
    22992300    else
    23002301      VMrDefaultlp();
    23012302
    2302     F1 = idrMoveR(G, newRing);
     2303    F1 = idrMoveR(G, newRing,currRing);
    23032304
    23042305    if(nnwinC == 0 || test_w_in_ConeCC(F1, pert_target_vector) != 1)
    … …  
    23062307      oldRing = currRing;
    23072308      rChangeCurrRing(newRing);
    2308       G = idrMoveR(F1, oldRing);
     2309      G = idrMoveR(F1, oldRing,currRing);
    23092310      Print("\n// takes %d steps and calls the recursion of level %d:",
    23102311             nwalk, tp_deg-1);
    … …  
    23152316    TargetRing = currRing;
    23162317    rChangeCurrRing(EXXRing);
    2317     result = idrMoveR(F1, TargetRing);
     2318    result = idrMoveR(F1, TargetRing,currRing);
    23182319  }
    23192320  else
    … …  
    23242325      /*
    23252326      if(MivSame(curr_weight, iv_lp) == 1)
    2326         if (currRing->parameter != NULL)
     2327        if (rParameter(currRing) != NULL)
    23272328          DefRingParlp();
    23282329        else
    23292330          VMrDefaultlp();
    23302331      else
    2331         if (currRing->parameter != NULL)
     2332        if (rParameter(currRing) != NULL)
    23322333          DefRingPar(curr_weight);
    23332334        else
    … …  
    23362337
    23372338        //..25.03.03 VMrDefaultlp();//define and execute the ring "lp"
    2338         if (currRing->parameter != NULL)
     2339        if (rParameter (currRing) != NULL)
    23392340          DefRingParlp();
    23402341        else
    … …  
    23422343
    23432344
    2344       F1 = idrMoveR(G, newRing);
     2345      F1 = idrMoveR(G, newRing,currRing);
    23452346      //Print("\n// Apply \"std\" in ring r%d_%d = %s;\n", tp_deg, nwalk, rString(currRing));
    23462347
    … …  
    23512352
    23522353    rChangeCurrRing(EXXRing);
    2353     result = idrMoveR(G, newRing);
     2354    result = idrMoveR(G, newRing,currRing);
    23542355  }
    23552356  delete target_weight;
    … …  
    28542855    ideal H0 = idHeadCC(G);
    28552856
    2856     if (currRing->parameter != NULL)
     2857    if (rParameter (currRing) != NULL)
    28572858      DefRingParlp();
    28582859    else
    … …  
    28602861
    28612862    TargetRing = currRing;
    2862     ssG = idrMoveR(G,EXXRing);
    2863 
    2864     ideal H0_tmp = idrMoveR(H0,EXXRing);
     2863    ssG = idrMoveR(G,EXXRing,currRing);
     2864
     2865    ideal H0_tmp = idrMoveR(H0,EXXRing,currRing);
    28652866    ideal H1 = idHeadCC(ssG);
    28662867
    … …  
    28902891    //PrintS("\n// Input is not GB!!");
    28912892    rChangeCurrRing(EXXRing);
    2892     G = idrMoveR(ssG, TargetRing);
     2893    G = idrMoveR(ssG, TargetRing,currRing);
    28932894
    28942895    if(Overflow_Error == TRUE)  {
    … …  
    29232924
    29242925    /* defiNe a new ring that its ordering is "(a(curr_weight),lp) */
    2925     if (currRing->parameter != NULL)
     2926    if (rParameter(currRing) != NULL)
    29262927      DefRingPar(curr_weight);
    29272928    else
    … …  
    29292930
    29302931    newRing = currRing;
    2931     Gomega1 = idrMoveR(Gomega, oldRing);
     2932    Gomega1 = idrMoveR(Gomega, oldRing,currRing);
    29322933    to=clock();
    29332934    /* compute a reduced Groebner basis of <Gomega> w.r.t. "newRing" */
    … …  
    29412942    /* change the ring to oldRing */
    29422943    rChangeCurrRing(oldRing);
    2943     M1 =  idrMoveR(M, newRing);
    2944     Gomega2 =  idrMoveR(Gomega1, newRing);
     2944    M1 =  idrMoveR(M, newRing,currRing);
     2945    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
    29452946
    29462947     to=clock();
    … …  
    29552956    /* change the ring to newRing */
    29562957    rChangeCurrRing(newRing);
    2957     F1 = idrMoveR(F, oldRing);
     2958    F1 = idrMoveR(F, oldRing,currRing);
    29582959
    29592960    to=clock();
    … …  
    30263027    newRing = currRing;
    30273028
    3028     if (currRing->parameter != NULL)
     3029    if (rParameter(currRing) != NULL)
    30293030      DefRingParlp();
    30303031    else
    30313032      VMrDefaultlp();
    30323033
    3033     F1 = idrMoveR(G, newRing);
     3034    F1 = idrMoveR(G, newRing,currRing);
    30343035
    30353036    if(nnwinC == 0 || test_w_in_ConeCC(F1, target_weight) != 1 ) {
    … …  
    30433044    TargetRing = currRing;
    30443045    rChangeCurrRing(EXXRing);
    3045     result = idrMoveR(F1, TargetRing);
     3046    result = idrMoveR(F1, TargetRing,currRing);
    30463047  }
    30473048  else  {
    … …  
    30503051
    30513052      newRing = currRing;
    3052       if (currRing->parameter != NULL)
     3053      if (rParameter(currRing) != NULL)
    30533054        DefRingParlp();
    30543055      else
    … …  
    30573058      KSTD_Finish:
    30583059      if(isGB == FALSE)
    3059         F1 = idrMoveR(G, newRing);
     3060        F1 = idrMoveR(G, newRing,currRing);
    30603061      else
    30613062        F1 = G;
    … …  
    30733074    LastGB_Finish:
    30743075    rChangeCurrRing(EXXRing);
    3075     result = idrMoveR(G, newRing);
     3076    result = idrMoveR(G, newRing,currRing);
    30763077  }
    30773078
    … …  
    31533154
    31543155    /* define a new ring that its ordering is "(a(curr_weight),lp) */
    3155     if (currRing->parameter != NULL)
     3156    if (rParameter(currRing) != NULL)
    31563157      DefRingPar(curr_weight);
    31573158    else
    … …  
    31593160
    31603161    newRing = currRing;
    3161     Gomega1 = idrMoveR(Gomega, oldRing);
     3162    Gomega1 = idrMoveR(Gomega, oldRing,currRing);
    31623163    to = clock();
    31633164    /* compute a reduced Groebner basis of <Gomega> w.r.t. "newRing" */
    … …  
    31663167    /* change the ring to oldRing */
    31673168    rChangeCurrRing(oldRing);
    3168     M1 =  idrMoveR(M, newRing);
    3169     Gomega2 =  idrMoveR(Gomega1, newRing);
     3169    M1 =  idrMoveR(M, newRing,currRing);
     3170    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
    31703171
    31713172    to = clock();
    … …  
    31803181    /* change the ring to newRing */
    31813182    rChangeCurrRing(newRing);
    3182     F1 = idrMoveR(F, oldRing);
     3183    F1 = idrMoveR(F, oldRing,currRing);
    31833184
    31843185    to = clock();
    … …  
    32123213
    32133214      newRing = currRing;
    3214       if (currRing->parameter != NULL)
     3215      if (rParameter(currRing) != NULL)
    32153216        DefRingPar(target_weight);
    32163217      else
    32173218        VMrDefault(target_weight);
    32183219
    3219       F1 = idrMoveR(G, newRing);
     3220      F1 = idrMoveR(G, newRing,currRing);
    32203221      G = MstdCC(F1);
    32213222      idDelete(&F1);
    … …  
    32573258 TEST_OVERFLOW_OI:
    32583259  rChangeCurrRing(XXRing);
    3259   G = idrMoveR(G, newRing);
     3260  G = idrMoveR(G, newRing,currRing);
    32603261  delete ivNull;
    32613262  delete exivlp;
    … …  
    33413342  {
    33423343    ideal H0 = idHeadCC(G);
    3343     if (currRing->parameter != NULL)
     3344    if (rParameter(currRing) != NULL)
    33443345      DefRingPar(orig_target_weight);
    33453346    else
    … …  
    33473348
    33483349    TargetRing = currRing;
    3349     ssG = idrMoveR(G,EXXRing);
    3350 
    3351     ideal H0_tmp = idrMoveR(H0,EXXRing);
     3350    ssG = idrMoveR(G,EXXRing,currRing);
     3351
     3352    ideal H0_tmp = idrMoveR(H0,EXXRing,currRing);
    33523353    ideal H1 = idHeadCC(ssG);
    33533354    id_Delete(&H0,EXXRing);
    … …  
    33843385
    33853386    rChangeCurrRing(EXXRing);
    3386     G = idrMoveR(ssG, TargetRing);
     3387    G = idrMoveR(ssG, TargetRing,currRing);
    33873388  }
    33883389
    … …  
    34103411
    34113412    /* define a new ring that its ordering is "(a(curr_weight),lp) */
    3412     if (currRing->parameter != NULL)
     3413    if (rParameter(currRing) != NULL)
    34133414      DefRingPar(curr_weight);
    34143415    else
    … …  
    34163417
    34173418    newRing = currRing;
    3418     Gomega1 = idrMoveR(Gomega, oldRing);
     3419    Gomega1 = idrMoveR(Gomega, oldRing,currRing);
    34193420
    34203421    to = clock();
    … …  
    34313432    rChangeCurrRing(oldRing);
    34323433
    3433     M1 =  idrMoveR(M, newRing);
    3434     Gomega2 =  idrMoveR(Gomega1, newRing);
     3434    M1 =  idrMoveR(M, newRing,currRing);
     3435    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
    34353436
    34363437    to = clock();
    … …  
    34453446    /* change the ring to newRing */
    34463447    rChangeCurrRing(newRing);
    3447     F1 = idrMoveR(F, oldRing);
     3448    F1 = idrMoveR(F, oldRing,currRing);
    34483449
    34493450    to = clock();
    … …  
    35123513    newRing = currRing;
    35133514
    3514     if (currRing->parameter != NULL)
     3515    if (rParameter(currRing) != NULL)
    35153516      //  DefRingParlp(); //
    35163517      DefRingPar(orig_target_weight);
    … …  
    35193520
    35203521
    3521     F1 = idrMoveR(G, newRing);
     3522    F1 = idrMoveR(G, newRing,currRing);
    35223523
    35233524    if(nnwinC == 0)
    … …  
    35313532    TargetRing = currRing;
    35323533    rChangeCurrRing(EXXRing);
    3533     result = idrMoveR(F1, TargetRing);
     3534    result = idrMoveR(F1, TargetRing,currRing);
    35343535  }
    35353536  else
    … …  
    35373538    if(nlast == 1)
    35383539    {
    3539       if (currRing->parameter != NULL)
     3540      if (rParameter(currRing) != NULL)
    35403541        DefRingPar(orig_target_weight);
    35413542      else
    … …  
    35453546    KSTD_Finish:
    35463547      if(isGB == FALSE)
    3547         F1 = idrMoveR(G, newRing);
     3548        F1 = idrMoveR(G, newRing,currRing);
    35483549      else
    35493550        F1 = G;
    … …  
    35583559  LastGB_Finish:
    35593560    rChangeCurrRing(EXXRing);
    3560     result = idrMoveR(G, newRing);
     3561    result = idrMoveR(G, newRing,currRing);
    35613562  }
    35623563
    … …  
    36593660
    36603661      /* create a new ring newRing */
    3661        if (currRing->parameter != NULL)
     3662       if (rParameter(currRing) != NULL)
    36623663         DefRingPar(curr_weight);
    36633664       else
    … …  
    36653666
    36663667      newRing = currRing;
    3667       F1 = idrMoveR(F, oldRing);
     3668      F1 = idrMoveR(F, oldRing,currRing);
    36683669    }
    36693670    else
    … …  
    36783679
    36793680      /* define a new ring that its ordering is "(a(curr_weight),lp) */
    3680       if (currRing->parameter != NULL)
     3681      if (rParameter(currRing) != NULL)
    36813682        DefRingPar(curr_weight);
    36823683      else
    … …  
    36843685
    36853686      newRing = currRing;
    3686       Gomega1 = idrMoveR(Gomega, oldRing);
     3687      Gomega1 = idrMoveR(Gomega, oldRing,currRing);
    36873688
    36883689      to = clock();
    … …  
    36983699      /* change the ring to oldRing */
    36993700      rChangeCurrRing(oldRing);
    3700       M1 =  idrMoveR(M, newRing);
    3701       Gomega2 =  idrMoveR(Gomega1, newRing);
     3701      M1 =  idrMoveR(M, newRing,currRing);
     3702      Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
    37023703
    37033704      to = clock();
    … …  
    37143715      /* change the ring to newRing */
    37153716      rChangeCurrRing(newRing);
    3716       F1 = idrMoveR(F, oldRing);
     3717      F1 = idrMoveR(F, oldRing,currRing);
    37173718    }
    37183719
    … …  
    37443745      PrintS("\n// ** The computed vector does NOT stay in Cone!!\n");
    37453746
    3746       if (currRing->parameter != NULL)
     3747      if (rParameter(currRing) != NULL)
    37473748        DefRingPar(target_weight);
    37483749      else
    37493750        VMrDefault(target_weight);
    37503751
    3751       F1 = idrMoveR(G, newRing);
     3752      F1 = idrMoveR(G, newRing,currRing);
    37523753      G = MstdCC(F1);
    37533754      idDelete(&F1);
    … …  
    37733774  }
    37743775  rChangeCurrRing(XXRing);
    3775   G = idrMoveR(G, newRing);
     3776  G = idrMoveR(G, newRing,currRing);
    37763777
    37773778  delete tmp_weight;
    … …  
    38413842    newRing = currRing;
    38423843
    3843     Gomega1 = idrMoveR(Gomega, oldRing);
     3844    Gomega1 = idrMoveR(Gomega, oldRing,currRing);
    38443845
    38453846    /* compute a reduced Groebner basis of <Gomega> w.r.t. "newRing" */
    … …  
    38553856      /* change the ring to oldRing */
    38563857    rChangeCurrRing(oldRing);
    3857     M1 =  idrMoveR(M, newRing);
    3858     Gomega2 =  idrMoveR(Gomega1, newRing);
     3858    M1 =  idrMoveR(M, newRing,currRing);
     3859    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
    38593860
    38603861      /* compute a representation of the generators of submod (M)
    … …  
    38693870    /* change the ring to newRing */
    38703871    rChangeCurrRing(newRing);
    3871     F1 = idrMoveR(F, oldRing);
     3872    F1 = idrMoveR(F, oldRing,currRing);
    38723873
    38733874    /* reduce the Groebner basis <G> w.r.t. new ring */
    … …  
    39023903  }
    39033904  rChangeCurrRing(XXRing);
    3904   G = idrMoveR(G, newRing);
     3905  G = idrMoveR(G, newRing,currRing);
    39053906
    39063907  delete tmp_weight;
    … …  
    39813982  {
    39823983    //ring order := (a(curr_weight),lp);
    3983     if (currRing->parameter != NULL)
     3984    if (rParameter(currRing) != NULL)
    39843985      DefRingPar(curr_weight);
    39853986    else
    39863987      VMrDefault(curr_weight);
    39873988
    3988     G = idrMoveR(Go, XXRing);
     3989    G = idrMoveR(Go, XXRing,currRing);
    39893990    G = MstdCC(G);
    39903991    tostd = clock()-to;
    … …  
    40024003  if(tp_deg > 1 && tp_deg <= nV)
    40034004  {
    4004     if (currRing->parameter != NULL)
     4005    if (rParameter(currRing) != NULL)
    40054006      DefRingPar(target_weight);
    40064007    else
    … …  
    40084009
    40094010    TargetRing = currRing;
    4010     ssG = idrMoveR(G,HelpRing);
     4011    ssG = idrMoveR(G,HelpRing,currRing);
    40114012    if(MivSame(target_weight, exivlp) == 1)
    40124013    {
    … …  
    40254026    pert_target_vector = target_weight; //vor 19. mai 2003//test 19 Junu 03
    40264027    rChangeCurrRing(HelpRing);
    4027     G = idrMoveR(ssG, TargetRing);
     4028    G = idrMoveR(ssG, TargetRing,currRing);
    40284029  }
    40294030  /*
    … …  
    40634064
    40644065    /* define a new ring that its ordering is "(a(curr_weight),lp) */
    4065     if (currRing->parameter != NULL)
     4066    if (rParameter(currRing) != NULL)
    40664067      DefRingPar(curr_weight);
    40674068    else
    … …  
    40694070
    40704071    newRing = currRing;
    4071     Gomega1 = idrMoveR(Gomega, oldRing);
     4072    Gomega1 = idrMoveR(Gomega, oldRing,currRing);
    40724073
    40734074#ifdef ENDWALKS
    … …  
    41074108    /* change the ring to oldRing */
    41084109    rChangeCurrRing(oldRing);
    4109     M1 =  idrMoveR(M, newRing);
    4110     Gomega2 =  idrMoveR(Gomega1, newRing);
     4110    M1 =  idrMoveR(M, newRing,currRing);
     4111    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
    41114112
    41124113    //if(endwalks==1)  PrintS("\n// Lifting is working:..");
    … …  
    41284129    /* change the ring to newRing */
    41294130    rChangeCurrRing(newRing);
    4130     F1 = idrMoveR(F, oldRing);
     4131    F1 = idrMoveR(F, oldRing,currRing);
    41314132
    41324133    //if(endwalks==1)PrintS("\n// InterRed is working now:");
    … …  
    41814182  FINISH_160302://16.03.02
    41824183    if(MivSame(orig_target, exivlp) == 1)
    4183       if (currRing->parameter != NULL)
     4184      if (rParameter(currRing) != NULL)
    41844185        DefRingParlp();
    41854186      else
    41864187        VMrDefaultlp();
    41874188    else
    4188       if (currRing->parameter != NULL)
     4189      if (rParameter(currRing) != NULL)
    41894190        DefRingPar(orig_target);
    41904191      else
    … …  
    41924193
    41934194    TargetRing=currRing;
    4194     F1 = idrMoveR(G, newRing);
     4195    F1 = idrMoveR(G, newRing,currRing);
    41954196#ifdef CHECK_IDEAL
    41964197      headidString(G, "G");
    … …  
    42244225        // PrintS("\n// ** calls \"LastGB\" to compute a GB");
    42254226        rChangeCurrRing(newRing);
    4226         ideal F2 = idrMoveR(F1, TargetRing);
     4227        ideal F2 = idrMoveR(F1, TargetRing,currRing);
    42274228        eF1 = LastGB(F2, curr_weight, tp_deg-1);
    42284229        F2=NULL;
    … …  
    42324233
    42334234      rChangeCurrRing(XXRing);
    4234       Eresult = idrMoveR(eF1, exTargetRing);
     4235      Eresult = idrMoveR(eF1, exTargetRing,currRing);
    42354236    }
    42364237    else{
    42374238      rChangeCurrRing(XXRing);
    4238       Eresult = idrMoveR(F1, TargetRing);
     4239      Eresult = idrMoveR(F1, TargetRing,currRing);
    42394240    }
    42404241  }
    42414242  else {
    42424243    rChangeCurrRing(XXRing);
    4243     Eresult = idrMoveR(G, newRing);
     4244    Eresult = idrMoveR(G, newRing,currRing);
    42444245  }
    42454246  delete ivNull;
    … …  
    43604361        nlev +=1;
    43614362
    4362         if (currRing->parameter != NULL)
     4363        if (rParameter(currRing) != NULL)
    43634364          DefRingPar(omtmp);
    43644365        else
    … …  
    43664367
    43674368        testring = currRing;
    4368         Gt = idrMoveR(G, oRing);
     4369        Gt = idrMoveR(G, oRing,currRing);
    43694370
    43704371        /* perturb the original target vector w.r.t. the current GB */
    … …  
    43734374
    43744375        rChangeCurrRing(oRing);
    4375         G = idrMoveR(Gt, testring);
     4376        G = idrMoveR(Gt, testring,currRing);
    43764377
    43774378        /* perturb the current vector w.r.t. the current GB */
    … …  
    44094410
    44104411    OVERFLOW_IN_NEXT_VECTOR:
    4411       if (currRing->parameter != NULL)
     4412      if (rParameter(currRing) != NULL)
    44124413        DefRingPar(omtmp);
    44134414      else
    … …  
    44154416
    44164417#ifdef TEST_OVERFLOW
    4417       Gt = idrMoveR(G, oRing);
     4418      Gt = idrMoveR(G, oRing,currRing);
    44184419      Gt = NULL; return(Gt);
    44194420#endif
    … …  
    44214422      //Print("\n\n// apply BB's alg. in ring r = %s;", rString(currRing));
    44224423      to=clock();
    4423       Gt = idrMoveR(G, oRing);
     4424      Gt = idrMoveR(G, oRing,currRing);
    44244425      G1 = MstdCC(Gt);
    44254426      xtextra=xtextra+clock()-to;
    … …  
    44474448    if (MivComp(next_vect, XivNull) == 1)
    44484449    {
    4449       if (currRing->parameter != NULL)
     4450      if (rParameter(currRing) != NULL)
    44504451        DefRingPar(omtmp);
    44514452      else
    … …  
    44534454
    44544455      testring = currRing;
    4455       Gt = idrMoveR(G, oRing);
     4456      Gt = idrMoveR(G, oRing,currRing);
    44564457
    44574458      if(test_w_in_ConeCC(Gt, omega2) == 1) {
    … …  
    44944495        //Print("\n//  ring tau = %s;", rString(currRing));
    44954496        rChangeCurrRing(oRing);
    4496         G = idrMoveR(Gt, testring);
     4497        G = idrMoveR(Gt, testring,currRing);
    44974498
    44984499        goto NEXT_VECTOR_FRACTAL;
    … …  
    45094510        // update the original target vector w.r.t. the current GB
    45104511        if(MivSame(Xivinput, Xivlp) == 1)
    4511           if (currRing->parameter != NULL)
     4512          if (rParameter(currRing) != NULL)
    45124513            DefRingParlp();
    45134514          else
    45144515            VMrDefaultlp();
    45154516        else
    4516           if (currRing->parameter != NULL)
     4517          if (rParameter(currRing) != NULL)
    45174518            DefRingPar(Xivinput);
    45184519          else
    … …  
    45204521
    45214522        testring = currRing;
    4522         Gt = idrMoveR(G, oRing);
     4523        Gt = idrMoveR(G, oRing,currRing);
    45234524
    45244525        delete Xtau;
    … …  
    45264527
    45274528        rChangeCurrRing(oRing);
    4528         G = idrMoveR(Gt, testring);
     4529        G = idrMoveR(Gt, testring,currRing);
    45294530
    45304531        delete omega2;
    … …  
    45614562#endif // BUCHBERGER_ALG
    45624563
    4563     if (currRing->parameter != NULL)
     4564    if (rParameter(currRing) != NULL)
    45644565      DefRingPar(omega);
    45654566    else
    45664567      VMrDefault(omega);
    45674568
    4568     Gomega1 = idrMoveR(Gomega, oRing);
     4569    Gomega1 = idrMoveR(Gomega, oRing,currRing);
    45694570
    45704571    /* Maximal recursion depth, to compute a red. GB */
    … …  
    45934594    else {
    45944595      rChangeCurrRing(oRing);
    4595       Gomega1 = idrMoveR(Gomega1, oRing);
     4596      Gomega1 = idrMoveR(Gomega1, oRing,currRing);
    45964597      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega);
    45974598    }
    … …  
    46014602
    46024603    rChangeCurrRing(oRing);
    4603     Gresult1 = idrMoveR(Gresult, new_ring);
    4604     Gomega2 = idrMoveR(Gomega1, new_ring);
     4604    Gresult1 = idrMoveR(Gresult, new_ring,currRing);
     4605    Gomega2 = idrMoveR(Gomega1, new_ring,currRing);
    46054606
    46064607    to=clock();
    … …  
    46134614
    46144615    rChangeCurrRing(new_ring);
    4615     F1 = idrMoveR(F, oRing);
     4616    F1 = idrMoveR(F, oRing,currRing);
    46164617
    46174618    to=clock();
    … …  
    46824683  if(MivComp(ivtarget, Xivlp)  != 1)
    46834684  {
    4684     if (currRing->parameter != NULL)
     4685    if (rParameter(currRing) != NULL)
    46854686      DefRingPar(ivtarget);
    46864687    else
    46874688      VMrDefault(ivtarget);
    46884689
    4689     I1 = idrMoveR(I, oldRing);
     4690    I1 = idrMoveR(I, oldRing,currRing);
    46904691    Mlp = MivWeightOrderlp(ivtarget);
    46914692    Xtau = Mfpertvector(I1, Mlp);
    … …  
    46934694  else
    46944695  {
    4695     if (currRing->parameter != NULL)
     4696    if (rParameter(currRing) != NULL)
    46964697      DefRingParlp();
    46974698    else
    46984699      VMrDefaultlp();
    46994700
    4700     I1 = idrMoveR(I, oldRing);
     4701    I1 = idrMoveR(I, oldRing,currRing);
    47014702    Mlp =  MivMatrixOrderlp(nV);
    47024703    Xtau = Mfpertvector(I1, Mlp);
    … …  
    47114712  ring tRing = currRing;
    47124713
    4713   if (currRing->parameter != NULL)
     4714  if (rParameter(currRing) != NULL)
    47144715    DefRingPar(ivstart);
    47154716  else
    47164717    VMrDefault(ivstart);
    47174718
    4718   I = idrMoveR(I1,tRing);
     4719  I = idrMoveR(I1,tRing,currRing);
    47194720  to=clock();
    47204721  ideal J = MstdCC(I);
    … …  
    47284729
    47294730  rChangeCurrRing(oldRing);
    4730   resF = idrMoveR(J, helpRing);
     4731  resF = idrMoveR(J, helpRing,currRing);
    47314732  idSkipZeroes(resF);
    47324733
    … …  
    47974798  {
    47984799    //rOrdStr(currRing) = (a(.c_w..),lp,C)
    4799     if (currRing->parameter != NULL)
     4800    if (rParameter(currRing) != NULL)
    48004801      DefRingPar(curr_weight);
    48014802    else
    48024803      VMrDefault(curr_weight);
    4803     G = idrMoveR(G, XXRing);
     4804    G = idrMoveR(G, XXRing,currRing);
    48044805    G = MstdCC(G);
    48054806  }
    … …  
    48234824    ring exring = currRing;
    48244825
    4825     if (currRing->parameter != NULL)
     4826    if (rParameter(currRing) != NULL)
    48264827      DefRingPar(curr_weight);
    48274828    else
    48284829      VMrDefault(curr_weight);
    48294830    to=clock();
    4830     Gw = idrMoveR(G, exring);
     4831    Gw = idrMoveR(G, exring,currRing);
    48314832    G = MstdCC(Gw);
    48324833    Gw = NULL;
    … …  
    48584859
    48594860    /* define a new ring that its ordering is "(a(curr_weight),lp) */
    4860     if (currRing->parameter != NULL)
     4861    if (rParameter(currRing) != NULL)
    48614862      DefRingPar(curr_weight);
    48624863    else
    … …  
    48644865
    48654866    newRing = currRing;
    4866     Gomega1 = idrMoveR(Gomega, oldRing);
     4867    Gomega1 = idrMoveR(Gomega, oldRing,currRing);
    48674868
    48684869    to=clock();
    … …  
    48784879    /* change the ring to oldRing */
    48794880    rChangeCurrRing(oldRing);
    4880     M1 =  idrMoveR(M, newRing);
    4881     Gomega2 =  idrMoveR(Gomega1, newRing);
     4881    M1 =  idrMoveR(M, newRing,currRing);
     4882    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
    48824883
    48834884    to=clock();
    … …  
    48944895    /* change the ring to newRing */
    48954896    rChangeCurrRing(newRing);
    4896     F1 = idrMoveR(F, oldRing);
     4897    F1 = idrMoveR(F, oldRing,currRing);
    48974898
    48984899    to=clock();
    … …  
    49384939
    49394940      if(MivSame(target_tmp, iv_lp) == 1)
    4940         if (currRing->parameter != NULL)
     4941        if (rParameter(currRing) != NULL)
    49414942          DefRingParlp();
    49424943        else
    49434944          VMrDefaultlp();
    49444945      else
    4945         if (currRing->parameter != NULL)
     4946        if (rParameter(currRing) != NULL)
    49464947          DefRingPar(target_tmp);
    49474948        else
    … …  
    49494950
    49504951      lpRing = currRing;
    4951       G1 = idrMoveR(G, newRing);
     4952      G1 = idrMoveR(G, newRing,currRing);
    49524953
    49534954      to=clock();
    … …  
    49594960      else {
    49604961        rChangeCurrRing(newRing);
    4961         G1 = idrMoveR(G1, lpRing);
     4962        G1 = idrMoveR(G1, lpRing,currRing);
    49624963
    49634964        //Print("\n\n// calls \"LastGB\" (%d) to compute a GB", nV-1);
    … …  
    49654966
    49664967        rChangeCurrRing(lpRing);
    4967         G = idrMoveR(G, newRing);
     4968        G = idrMoveR(G, newRing,currRing);
    49684969      }
    49694970      textra=clock()-to;
    … …  
    49924993      if(endwalks == 1 && MivComp(next_weight, curr_weight) == 1){
    49934994        rChangeCurrRing(XXRing);
    4994         G = idrMoveR(G, newRing);
     4995        G = idrMoveR(G, newRing,currRing);
    49954996        goto FINISH;
    49964997      }
    … …  
    49984999
    49995000      if(MivSame(target_tmp, iv_lp) == 1)
    5000         if (currRing->parameter != NULL)
     5001        if (rParameter(currRing) != NULL)
    50015002          DefRingParlp();
    50025003        else
    50035004          VMrDefaultlp();
    50045005      else
    5005         if (currRing->parameter != NULL)
     5006        if (rParameter(currRing) != NULL)
    50065007          DefRingPar(target_tmp);
    50075008        else
    … …  
    50095010
    50105011      lpRing = currRing;
    5011       Glp = idrMoveR(G, newRing);
    5012       H2 = idrMoveR(H0, newRing);
     5012      Glp = idrMoveR(G, newRing,currRing);
     5013      H2 = idrMoveR(H0, newRing,currRing);
    50135014
    50145015      /* Apply Lemma 2.2 in Collart et. al (1997) to check whether
    … …  
    50675068          {
    50685069            rChangeCurrRing(newRing);
    5069             G = idrMoveR(Glp, lpRing);
     5070            G = idrMoveR(Glp, lpRing,currRing);
    50705071            goto OMEGA_OVERFLOW_TRAN_NEW;
    50715072          }
    … …  
    50815082      {
    50825083        rChangeCurrRing(newRing);
    5083         G = idrMoveR(Glp, lpRing);
     5084        G = idrMoveR(Glp, lpRing,currRing);
    50845085        goto TRAN_LIFTING;
    50855086      }
    … …  
    50995100      */
    51005101      rChangeCurrRing(newRing);
    5101       G = idrMoveR(Glp, lpRing);
     5102      G = idrMoveR(Glp, lpRing,currRing);
    51025103
    51035104      delete next_weight;
    … …  
    51165117 BE_FINISH:
    51175118  rChangeCurrRing(XXRing);
    5118   G = idrMoveR(G, lpRing);
     5119  G = idrMoveR(G, lpRing,currRing);
    51195120
    51205121 FINISH:
    … …  
    51655166    if(Overflow_Error == FALSE)
    51665167    {
    5167       if (currRing->parameter != NULL)
     5168      if (rParameter(currRing) != NULL)
    51685169        DefRingParlp();
    51695170      else
    … …  
    51715172
    51725173      TargetRing = currRing;
    5173       ssG = idrMoveR(Go,YXXRing);
     5174      ssG = idrMoveR(Go,YXXRing,currRing);
    51745175    }
    51755176    Overflow_Error = FALSE;
    … …  
    52065207
    52075208  rChangeCurrRing(YXXRing);
    5208   G = idrMoveR(ssG, TargetRing);
     5209  G = idrMoveR(ssG, TargetRing,currRing);
    52095210
    52105211  while(1)
    … …  
    52395240
    52405241    /* define a new ring that its ordering is "(a(curr_weight),lp) */
    5241     if (currRing->parameter != NULL)
     5242    if (rParameter(currRing) != NULL)
    52425243      DefRingPar(curr_weight);
    52435244    else
    … …  
    52455246
    52465247    newRing = currRing;
    5247     Gomega1 = idrMoveR(Gomega, oldRing);
     5248    Gomega1 = idrMoveR(Gomega, oldRing,currRing);
    52485249
    52495250#ifdef ENDWALKS
    … …  
    52685269    /* change the ring to oldRing */
    52695270    rChangeCurrRing(oldRing);
    5270     M1 =  idrMoveR(M, newRing);
    5271     Gomega2 =  idrMoveR(Gomega1, newRing);
     5271    M1 =  idrMoveR(M, newRing,currRing);
     5272    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
    52725273    to=clock();
    52735274
    … …  
    52855286    /* change the ring to newRing */
    52865287    rChangeCurrRing(newRing);
    5287     F1 = idrMoveR(F, oldRing);
     5288    F1 = idrMoveR(F, oldRing,currRing);
    52885289    to=clock();
    52895290    //if(endwalks == 1) PrintS("\n//  InterRed is still working:");
    … …  
    53485349
    53495350  //define and execute ring with lex. order
    5350   if (currRing->parameter != NULL)
     5351  if (rParameter(currRing) != NULL)
    53515352    DefRingParlp();
    53525353  else
    53535354    VMrDefaultlp();
    53545355
    5355   G1 = idrMoveR(G, newRing);
     5356  G1 = idrMoveR(G, newRing,currRing);
    53565357
    53575358  if( test_w_in_ConeCC(G1, target_weight) != 1 || ntestwinC == 0)
    … …  
    53815382  newRing = currRing;
    53825383  rChangeCurrRing(YXXRing);
    5383   ideal result = idrMoveR(G1, newRing);
     5384  ideal result = idrMoveR(G1, newRing,currRing);
    53845385
    53855386  delete ivNull;
    … …  
    54505451      if(op_tmp == op_deg) {
    54515452        //rOrdStr(currRing) = (a(...),lp,C)
    5452         if (currRing->parameter != NULL)
     5453        if (rParameter(currRing) != NULL)
    54535454          DefRingPar(cw_tmp);
    54545455        else
    54555456          VMrDefault(cw_tmp);
    54565457
    5457         G = idrMoveR(Go, XXRing);
     5458        G = idrMoveR(Go, XXRing,currRing);
    54585459        G = MstdCC(G);
    54595460        if(op_deg != 1)
    … …  
    55135514
    55145515    /* define a new ring which ordering is "(a(curr_weight),lp) */
    5515     if (currRing->parameter != NULL)
     5516    if (rParameter(currRing) != NULL)
    55165517      DefRingPar(curr_weight);
    55175518    else
    … …  
    55195520
    55205521    newRing = currRing;
    5521     Gomega1 = idrMoveR(Gomega, oldRing);
     5522    Gomega1 = idrMoveR(Gomega, oldRing,currRing);
    55225523
    55235524    to=clock();
    … …  
    55335534    /* change the ring to oldRing */
    55345535    rChangeCurrRing(oldRing);
    5535     M1 =  idrMoveR(M, newRing);
    5536     Gomega2 =  idrMoveR(Gomega1, newRing);
     5536    M1 =  idrMoveR(M, newRing,currRing);
     5537    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
    55375538
    55385539    to=clock();
    … …  
    55485549   /* change the ring to newRing */
    55495550    rChangeCurrRing(newRing);
    5550     F1 = idrMoveR(F, oldRing);
     5551    F1 = idrMoveR(F, oldRing,currRing);
    55515552
    55525553    to=clock();
    … …  
    55725573      newRing = currRing;
    55735574
    5574       if (currRing->parameter != NULL)
     5575      if (rParameter(currRing) != NULL)
    55755576        DefRingPar(target_weight);
    55765577      else
    55775578        VMrDefault(target_weight);
    55785579
    5579       F1 = idrMoveR(G, newRing);
     5580      F1 = idrMoveR(G, newRing,currRing);
    55805581      G = MstdCC(F1);
    55815582      idDelete(&F1);
    … …  
    56245625
    56255626  rChangeCurrRing(XXRing);
    5626   ideal result = idrMoveR(G, newRing);
     5627  ideal result = idrMoveR(G, newRing,currRing);
    56275628  id_Delete(&G, newRing);
    56285629
Note: See TracChangeset for help on using the changeset viewer.