Changeset 984ff3 in git


Ignore:
Timestamp:
May 20, 2014, 10:00:18 AM (9 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')
Children:
7063d23887fa8ed57cbcc380059730b2c9c57a3592550d1a103eaa2a9516fa2d6b6217676a4d17e2
Parents:
868d77da262fc3cd0ba86c003e62b39cafb75dbe46c7c3543716f62ef5bb7e5989d0c0876634829a
Message:
Merge pull request #586 from surface-smoothers/patch-AnnExt_R_Bug

Patch ann ext r bug
Files:
11 added
55 deleted
121 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/modstd.lib

    r46c7c3 r984ff3  
    3434{
    3535   newstruct("idealPrimeTest", "ideal Ideal");
    36 }
    37 
    38 ////////////////////////////////////////////////////////////////////////////////
    39 
    40 proc mixedTest()
    41 "USAGE:  mixedTest();
    42 RETURN:  1 if ordering of basering is mixed, 0 else
    43 EXAMPLE: example mixedTest(); shows an example
    44 "
    45 {
    46    int i,p,m;
    47    for(i = 1; i <= nvars(basering); i++)
    48    {
    49       if(var(i) > 1)
    50       {
    51          p++;
    52       }
    53       else
    54       {
    55          m++;
    56       }
    57    }
    58    if((p > 0) && (m > 0)) { return(1); }
    59    return(0);
    60 }
    61 example
    62 { "EXAMPLE:"; echo = 2;
    63    ring R1 = 0,(x,y,z),dp;
    64    mixedTest();
    65    ring R2 = 31,(x(1..4),y(1..3)),(ds(4),lp(3));
    66    mixedTest();
    67    ring R3 = 181,x(1..9),(dp(5),lp(4));
    68    mixedTest();
    6936}
    7037
    … …  
    920887   rt = rtimer;
    921888
    922    if(!mixedTest())
     889   if(!hasMixedOrdering())
    923890   {
    924891      if(h)

  • Singular/LIB/modwalk.lib

    r46c7c3 r984ff3  
    8383//-------------------------  make i homogeneous  -----------------------------
    8484
    85   if(!mixedTest() && !h)
     85  if(!hasMixedOrdering() && !h)
    8686  {
    8787    if(!((find(ordstr_R0, "M") > 0) || (find(ordstr_R0, "a") > 0) || neg))
    … …  
    154154    }
    155155  }
    156   if(!mixedTest() && !h)
     156  if(!hasMixedOrdering() && !h)
    157157  {
    158158    if(!((find(ordstr_R0, "M") > 0) || (find(ordstr_R0, "a") > 0) || neg))

  • Singular/LIB/primdec.lib

    r868d77d r984ff3  
    39953995  if(n<nvars(basering))
    39963996  {
    3997      matrix f=transpose(re[n+1]);      //Hom(_,R)
    3998      module k=nres(f,2)[2];            //the kernel
    3999      matrix g=transpose(re[n]);        //the image of Hom(_,R)
    4000 
    4001      ideal ann=quotient1(g,k);           //the anihilator
    4002   }
    4003   else
    4004   {
    4005      ideal ann=Ann(transpose(re[n]));
    4006   }
     3997    if(size(re[n+1])>0)
     3998    {
     3999        matrix f=transpose(re[n+1]);      //Hom(_,R)
     4000        module k=nres(f,2)[2];            //the kernel
     4001        matrix g=transpose(re[n]);        //the image of Hom(_,R)
     4002
     4003        ideal ann=quotient1(g,k);         //the anihilator
     4004        return(ann);
     4005    }
     4006  }
     4007  // remaining case: re[n+1] is trivial
     4008  // either n is at least number of variables or
     4009  // resolution happens to be shorter
     4010  ideal ann=Ann(transpose(re[n]));
    40074011  return(ann);
    40084012}

  • Singular/LIB/ring.lib

    r46c7c3 r984ff3  
    2727 hasCommutativeVars(rng)  non-commutive or commnuative polynomial ring
    2828 hasGlobalOrdering(rng)   global versus mixed/local monomial ordering
     29 hasMixedOrdering()       mixed versus global/local ordering
    2930 isSubModule(I,J)         check if I is in J as submodule
    3031";
    … …  
    10101011}
    10111012
    1012 
     1013proc hasMixedOrdering()
     1014"USAGE:  hasMixedOrdering();
     1015RETURN:  1 if ordering of basering is mixed, 0 else
     1016EXAMPLE: example hasMixedOrdering(); shows an example
     1017"
     1018{
     1019   int i,p,m;
     1020   for(i = 1; i <= nvars(basering); i++)
     1021   {
     1022      if(var(i) > 1)
     1023      {
     1024         p++;
     1025      }
     1026      else
     1027      {
     1028         m++;
     1029      }
     1030   }
     1031   if((p > 0) && (m > 0)) { return(1); }
     1032   return(0);
     1033}
     1034example
     1035{ "EXAMPLE:"; echo = 2;
     1036   ring R1 = 0,(x,y,z),dp;
     1037   hasMixedOrdering();
     1038   ring R2 = 31,(x(1..4),y(1..3)),(ds(4),lp(3));
     1039   hasMixedOrdering();
     1040   ring R3 = 181,x(1..9),(dp(5),lp(4));
     1041   hasMixedOrdering();
     1042}
     1043

  • Singular/LIB/symodstd.lib

    r46c7c3 r984ff3  
    3535LIB "modstd.lib";
    3636LIB "parallel.lib";
     37LIB "ring.lib";
    3738
    3839////////////////////////////////////////////////////////////////////////////////
    … …  
    11171118   rt = rtimer;
    11181119
    1119    if(!mixedTest())
     1120   if(!hasMixedOrdering())
    11201121   {
    11211122      if(h)

  • Singular/dyn_modules/callgfanlib/gfan.cc

    r46c7c3 r984ff3  
    40844084                                                case TRUE:
    40854085                                                        if(hasNegCoeff)
    4086                                                                 nCoeffNom=nNeg(nCoeffNom);
     4086                                                                nCoeffNom=nInpNeg(nCoeffNom);
    40874087                                                        pSetCoeff(strPoly, nDiv(nCoeffNom, nCoeffDenom));
    40884088                                                        break;
    40894089                                                case FALSE:
    40904090                                                        if(hasNegCoeff)
    4091                                                                 nCoeff=nNeg(nCoeff);
     4091                                                                nCoeff=nInpNeg(nCoeff);
    40924092                                                        if(!nIsOne(nCoeff))
    40934093                                                        {

  • Singular/dyn_modules/syzextra/mod_main.cc

    r46c7c3 r984ff3  
    3030#include <Singular/attrib.h>
    3131
    32 #include <Singular/ipid.h> 
     32#include <Singular/ipid.h>
    3333#include <Singular/ipshell.h> // For iiAddCproc
    3434
    … …  
    4545
    4646
    47 #if GOOGLE_PROFILE_ENABLED 
     47#if GOOGLE_PROFILE_ENABLED
    4848#include <google/profiler.h>
    49 #endif // #if GOOGLE_PROFILE_ENABLED 
     49#endif // #if GOOGLE_PROFILE_ENABLED
    5050
    5151
    … …  
    8484
    8585  const char *usage = "'ClearContent' needs a (non-zero!) poly or vector argument...";
    86  
     86
    8787  if( h == NULL )
    8888  {
    … …  
    100100
    101101  assume (h->Next() == NULL);
    102  
     102
    103103  poly ph = reinterpret_cast<poly>(h->Data());
    104  
     104
    105105  if( ph == NULL )
    106106  {
    … …  
    108108    return TRUE;
    109109  }
    110  
     110
    111111  const ring r =  currRing;
    112112  assume( r != NULL ); assume( r->cf != NULL ); const coeffs C = r->cf;
    … …  
    185185  }
    186186
    187   return (_n); 
     187  return (_n);
    188188}
    189189
    … …  
    201201  {
    202202    const char* name = (char*)(h->Data());
    203     assume( name != NULL );   
     203    assume( name != NULL );
    204204    ProfilerStart(name);
    205205  } else
    206     WerrorS("ProfilerStart requires a string [name] argument"); 
     206    WerrorS("ProfilerStart requires a string [name] argument");
    207207#else
    208208  WarnS("Sorry no google profiler support (GOOGLE_PROFILE_ENABLE!=1)...");
    … …  
    249249}
    250250
    251                    
     251
    252252
    253253static BOOLEAN DetailedPrint(leftv __res, leftv h)
    … …  
    263263  if( h->Typ() == NUMBER_CMD)
    264264  {
    265     number n = (number)h->Data(); 
     265    number n = (number)h->Data();
    266266
    267267    const ring r = currRing;
    … …  
    278278    return FALSE;
    279279  }
    280  
     280
    281281  if( h->Typ() == RING_CMD)
    282282  {
    … …  
    301301  if( h->Typ() == IDEAL_CMD || h->Typ() == MODUL_CMD)
    302302  {
    303     const ideal id = (const ideal)h->Data(); h = h->Next(); 
     303    const ideal id = (const ideal)h->Data(); h = h->Next();
    304304
    305305    dPrint(id, currRing, currRing, getOptionalInteger(h, 3));
    306    
    307     return FALSE;           
     306
     307    return FALSE;
    308308  }
    309309
    … …  
    344344    if (r == NULL)
    345345      Print("ring '%10s': NULL", "syRing");
    346     else 
     346    else
    347347      if (r == currRing)
    348348        Print("ring '%10s': currRing", "syRing");
    … …  
    356356#endif
    357357          // rChangeCurrRing(r);
    358         }           
     358        }
    359359    PrintLn();
    360360
    … …  
    489489
    490490    h = h->Next(); assume (h == NULL);
    491    
     491
    492492    return FALSE;
    493493  }
    … …  
    495495  if( h->Typ() == IDEAL_CMD || h->Typ() == MODUL_CMD)
    496496  {
    497     res->data = id_Tail( (const ideal)h->Data(), r );     
     497    res->data = id_Tail( (const ideal)h->Data(), r );
    498498    res->rtyp = h->Typ();
    499    
     499
    500500    h = h->Next(); assume (h == NULL);
    501    
     501
    502502    return FALSE;
    503503  }
    … …  
    512512{
    513513  const SchreyerSyzygyComputationFlags attributes(currRingHdl);
    514      
     514
    515515  const BOOLEAN __DEBUG__      = attributes.__DEBUG__;
    516516//  const BOOLEAN __SYZCHECK__   = attributes.__SYZCHECK__;
    … …  
    528528  }
    529529
    530   assume( h != NULL ); 
     530  assume( h != NULL );
    531531
    532532  if( h->Typ() == IDEAL_CMD || h->Typ() == MODUL_CMD)
    … …  
    538538    if( __DEBUG__ )
    539539    {
    540       PrintS("ComputeLeadingSyzygyTerms::Input: \n");     
     540      PrintS("ComputeLeadingSyzygyTerms::Input: \n");
    541541      dPrint(id, r, r, 1);
    542542    }
    543    
     543
    544544    assume( !__LEAD2SYZ__ );
    545545
    … …  
    547547
    548548    const ideal newid = ComputeLeadingSyzygyTerms(id,  attributes);
    549    
     549
    550550    res->data = newid; res->rtyp = MODUL_CMD;
    551551    return FALSE;
    … …  
    580580  }
    581581
    582   assume( h != NULL ); 
     582  assume( h != NULL );
    583583
    584584  if(    (h->Typ() == IDEAL_CMD || h->Typ() == MODUL_CMD)
    585585      && (h->rtyp  == IDHDL) // must be a variable!
    586586      && (h->e == NULL) // not a list element
    587       ) 
     587      )
    588588  {
    589589    const ideal id = (const ideal)h->Data();
    … …  
    594594    {
    595595      PrintS("Sort_c_ds::Input: \n");
    596       dPrint(id, r, r, 1);     
     596      dPrint(id, r, r, 1);
    597597    }
    598598
    … …  
    605605//    res->data = id;
    606606//    res->rtyp = h->Typ();
    607    
     607
    608608    if( __DEBUG__ )
    609609    {
    … …  
    617617
    618618  WarnS("ComputeLeadingSyzygyTerms needs a single ideal/module argument (must be a variable!)...");
    619   return TRUE; 
     619  return TRUE;
    620620}
    621621
    … …  
    640640  }
    641641
    642   assume( h != NULL ); 
     642  assume( h != NULL );
    643643
    644644  assume( __LEAD2SYZ__ ); // ???
    645  
     645
    646646  if( h->Typ() == IDEAL_CMD || h->Typ() == MODUL_CMD)
    647647  {
    … …  
    690690  {
    691691    WerrorS(usage);
    692     return TRUE;   
    693   }
    694    
     692    return TRUE;
     693  }
     694
    695695  const poly product = (poly) h->Data(); assume (product != NULL);
    696696
    … …  
    700700  {
    701701    WerrorS(usage);
    702     return TRUE;   
     702    return TRUE;
    703703  }
    704704
    705705  poly syzterm = NULL;
    706706
    707   if(h->Typ()==VECTOR_CMD) 
     707  if(h->Typ()==VECTOR_CMD)
    708708    syzterm = (poly) h->Data();
    709709
    … …  
    714714  {
    715715    WerrorS(usage);
    716     return TRUE;   
    717   }
    718  
     716    return TRUE;
     717  }
     718
    719719  const ideal L = (ideal) h->Data(); h = h->Next();
    720720
    … …  
    758758    PrintS("FindReducer::Output: \n");
    759759    dPrint((poly)res->data, r, r, 2);
    760   }   
    761  
    762   return FALSE;   
    763  
     760  }
     761
     762  return FALSE;
     763
    764764}
    765765
    … …  
    781781
    782782  assume( __HYBRIDNF__ ); // ???
    783  
     783
    784784  if ((h==NULL) || (h->Typ() != VECTOR_CMD) || (h->Data() == NULL))
    785785  {
    786786    WerrorS(usage);
    787     return TRUE;   
     787    return TRUE;
    788788  }
    789789
    … …  
    795795  {
    796796    WerrorS(usage);
    797     return TRUE;   
     797    return TRUE;
    798798  }
    799799
    … …  
    804804  {
    805805    WerrorS(usage);
    806     return TRUE;   
     806    return TRUE;
    807807  }
    808808
    … …  
    814814  {
    815815    WerrorS(usage);
    816     return TRUE;   
     816    return TRUE;
    817817  }
    818818
    … …  
    851851      PrintS("LS: "); dPrint(LS, r, r, 0);
    852852    }
    853   } 
    854  
     853  }
     854
    855855  res->rtyp = VECTOR_CMD;
    856856  res->data = SchreyerSyzygyNF(syz_lead,
    … …  
    889889  {
    890890    WerrorS(usage);
    891     return TRUE;   
     891    return TRUE;
    892892  }
    893893
    894894  const poly multiplier = (poly) h->Data(); assume (multiplier != NULL);
    895895
    896  
     896
    897897  h = h->Next();
    898898  if ((h==NULL) || (h->Typ()!=VECTOR_CMD && h->Typ() !=POLY_CMD) || (h->Data() == NULL))
    899899  {
    900900    WerrorS(usage);
    901     return TRUE;   
     901    return TRUE;
    902902  }
    903903
    904904  const poly term4reduction = (poly) h->Data(); assume( term4reduction != NULL );
    905905
    906  
     906
    907907  poly syztermCheck = NULL;
    908  
     908
    909909  h = h->Next();
    910910  if ((h==NULL) || !((h->Typ()==VECTOR_CMD) || (h->Data() == NULL)) )
    911911  {
    912912    WerrorS(usage);
    913     return TRUE;   
    914   }
    915 
    916   if(h->Typ()==VECTOR_CMD) 
     913    return TRUE;
     914  }
     915
     916  if(h->Typ()==VECTOR_CMD)
    917917    syztermCheck = (poly) h->Data();
    918918
    919  
     919
    920920  h = h->Next();
    921921  if ((h==NULL) || (h->Typ()!=IDEAL_CMD && h->Typ() !=MODUL_CMD) || (h->Data() == NULL))
    922922  {
    923923    WerrorS(usage);
    924     return TRUE;   
     924    return TRUE;
    925925  }
    926926
    927927  const ideal L = (ideal) h->Data(); assume( IDELEMS(L) > 0 );
    928928
    929  
     929
    930930  h = h->Next();
    931931  if ((h==NULL) || (h->Typ()!=IDEAL_CMD && h->Typ() !=MODUL_CMD) || (h->Data() == NULL))
    932932  {
    933933    WerrorS(usage);
    934     return TRUE;   
     934    return TRUE;
    935935  }
    936936
    … …  
    960960    PrintS("t: "); dPrint(term4reduction, r, r, 2);
    961961    PrintS("syzterm: "); dPrint(syztermCheck, r, r, 2);
    962    
     962
    963963    PrintS("L: "); dPrint(L, r, r, 0);
    964964    PrintS("T: "); dPrint(T, r, r, 0);
    … …  
    977977    const int c = p_GetComp(syztermCheck, r) - 1;
    978978    assume( c >= 0 && c < IDELEMS(L) );
    979    
     979
    980980    const poly p = L->m[c];
    981     assume( p != NULL ); assume( pNext(p) == NULL );   
     981    assume( p != NULL ); assume( pNext(p) == NULL );
    982982
    983983    assume( p_EqualPolys(term4reduction, p, r) ); // assume? TODO
    … …  
    989989    assume( p_EqualPolys(multiplier, m, r) ); // assume? TODO
    990990
    991     p_Delete(&m, r);   
    992    
     991    p_Delete(&m, r);
     992
    993993// NOTE:   leadmonomial(syzterm) == m &&  L[leadcomp(syzterm)] == t
    994994  }
    … …  
    10041004    dPrint((poly)res->data, r, r, 2);
    10051005  }
    1006  
    1007  
     1006
     1007
    10081008  return FALSE;
    10091009}
    … …  
    10311031  {
    10321032    WerrorS(usage);
    1033     return TRUE;   
     1033    return TRUE;
    10341034  }
    10351035
    … …  
    10401040  {
    10411041    WerrorS(usage);
    1042     return TRUE;   
    1043   }
    1044 
    1045   const poly tail = (poly) h->Data(); 
     1042    return TRUE;
     1043  }
     1044
     1045  const poly tail = (poly) h->Data();
    10461046
    10471047  h = h->Next();
    … …  
    10501050  {
    10511051    WerrorS(usage);
    1052     return TRUE;   
     1052    return TRUE;
    10531053  }
    10541054
    … …  
    10611061  {
    10621062    WerrorS(usage);
    1063     return TRUE;   
     1063    return TRUE;
    10641064  }
    10651065
    … …  
    10691069
    10701070  h = h->Next();
    1071  
     1071
    10721072  ideal LS = NULL;
    10731073
    … …  
    11181118{
    11191119  const SchreyerSyzygyComputationFlags attributes(currRingHdl);
    1120    
     1120
    11211121  const BOOLEAN __DEBUG__      = attributes.__DEBUG__;
    1122    
     1122
    11231123  const char* usage = "`ComputeResolution(<ideal/module>[,int])` expected";
    11241124  const ring r = attributes.m_rBaseRing;
    … …  
    11301130  {
    11311131    WerrorS(usage);
    1132     return TRUE;   
     1132    return TRUE;
    11331133  }
    11341134
    … …  
    11441144  {
    11451145    WerrorS(usage);
    1146     return TRUE;   
    1147   }
    1148  
     1146    return TRUE;
     1147  }
     1148
    11491149  ideal L = (ideal)(h->CopyD()); // no copy!
    11501150  assume( IDELEMS(L) == size );
    1151  
     1151
    11521152  h = h->Next();
    11531153  if ((h==NULL) || (h->Typ()!=IDEAL_CMD && h->Typ() !=MODUL_CMD) || (h->Data() == NULL))
    11541154  {
    11551155    WerrorS(usage);
    1156     return TRUE;   
     1156    return TRUE;
    11571157  }
    11581158
    11591159  ideal T = (ideal)(h->CopyD()); // no copy!
    11601160  assume( IDELEMS(T) == size );
    1161  
     1161
    11621162  h = h->Next();
    11631163
    11641164  // length..?
    11651165  long length = 0;
    1166  
     1166
    11671167  if ((h!=NULL) && (h->Typ()==INT_CMD))
    11681168  {
    … …  
    11701170    h = h->Next();
    11711171  }
    1172  
     1172
    11731173  assume( h == NULL );
    11741174
    11751175  if( length <= 0 )
    1176     length = 1 + rVar(r); 
     1176    length = 1 + rVar(r);
    11771177
    11781178  if( __DEBUG__ )
    … …  
    11871187
    11881188  syStrategy _res=(syStrategy)omAlloc0(sizeof(ssyStrategy));
    1189  
     1189
    11901190//  class ssyStrategy; typedef ssyStrategy * syStrategy;
    11911191//  typedef ideal *            resolvente;
    … …  
    11981198//  if (attributes.__TREEOUTPUT__)
    11991199//    Print("{ \"RESOLUTION: HYBRIDNF:%d, TAILREDSYZ: %d, LEAD2SYZ: %d, IGNORETAILS: %d\": [\n", attributes.__HYBRIDNF__, attributes.__TAILREDSYZ__, attributes.__LEAD2SYZ__, attributes.__IGNORETAILS__);
    1200    
     1200
    12011201  while( (!idIs0(L)) && (index < length))
    12021202  {
    12031203    attributes.nextSyzygyLayer();
    1204     ideal LL, TT; 
    1205      
     1204    ideal LL, TT;
     1205
    12061206    ComputeSyzygy(L, T, LL, TT, attributes);
    12071207
    … …  
    12151215
    12161216    assume( size == IDELEMS(TT) );
    1217    
     1217
    12181218    id_Delete(&L, r); id_Delete(&T, r);
    12191219
    12201220    L = LL; T = TT;
    1221    
     1221
    12221222    // id_Add(T, L, r);
    12231223    M = idInit(size, 0);
    … …  
    12271227    }
    12281228    M->rank = id_RankFreeModule(M, r);
    1229    
     1229
    12301230    if( __DEBUG__ )
    12311231    {
    … …  
    12331233      PrintS("M = LL + TT: \n"); dPrint(M, r, r, 0);
    12341234    }
    1235  
     1235
    12361236    _res->fullres[index++] = M; // ???
    12371237  }
    … …  
    12401240
    12411241  id_Delete(&L, r); id_Delete(&T, r);
    1242  
     1242
    12431243  res->data = _res;
    12441244  res->rtyp = RESOLUTION_CMD;
    … …  
    12531253
    12541254//  omFreeSize(_res, sizeof(ssyStrategy));
    1255  
     1255
    12561256  return FALSE;
    12571257
    … …  
    12801280  {
    12811281    WerrorS(usage);
    1282     return TRUE;   
     1282    return TRUE;
    12831283  }
    12841284
    … …  
    12911291  {
    12921292    WerrorS(usage);
    1293     return TRUE;   
     1293    return TRUE;
    12941294  }
    12951295
    … …  
    12981298
    12991299
    1300   h = h->Next(); assume( h == NULL ); 
     1300  h = h->Next(); assume( h == NULL );
    13011301
    13021302  if( __DEBUG__ )
    … …  
    13171317
    13181318  l->m[1].rtyp = MODUL_CMD; l->m[1].data = reinterpret_cast<void *>(TT);
    1319  
     1319
    13201320  res->data = l; res->rtyp = LIST_CMD;
    1321  
     1321
    13221322  if( __DEBUG__ )
    13231323  {
    … …  
    13741374    } else
    13751375      res->data = reinterpret_cast<void *>(jjLONG2N(0));
    1376      
     1376
    13771377
    13781378    res->rtyp = BIGINT_CMD;
    … …  
    14321432  res->data = reinterpret_cast<void *>(rAssure_SyzComp(currRing, TRUE));
    14331433  res->rtyp = RING_CMD; // return new ring!
    1434   // QRING_CMD? 
     1434  // QRING_CMD?
    14351435
    14361436  return FALSE;
    … …  
    14551455    }
    14561456
    1457     sign = s;           
     1457    sign = s;
    14581458  }
    14591459
    … …  
    14611461  res->data = reinterpret_cast<void *>(rAssure_InducedSchreyerOrdering(currRing, TRUE, sign));
    14621462  res->rtyp = RING_CMD; // return new ring!
    1463   // QRING_CMD? 
     1463  // QRING_CMD?
    14641464  return FALSE;
    14651465}
    … …  
    15211521
    15221522
    1523  
     1523
    15241524  lists l=(lists)omAllocBin(slists_bin);
    15251525  l->Init(2);
    … …  
    15521552
    15531553
    1554 /* // the following turned out to be unnecessary...   
     1554/* // the following turned out to be unnecessary...
    15551555/// Finds p^th AM ordering, and returns its position in r->typ[] AND
    15561556/// corresponding &r->wvhdl[]
    … …  
    16051605// {
    16061606//   NoReturn(res);
    1607 // 
     1607//
    16081608//   const ring r = currRing;
    1609 // 
     1609//
    16101610//   int p = 0; // which IS-block? p^th!
    1611 // 
     1611//
    16121612//   if ((h!=NULL) && (h->Typ()==INT_CMD))
    16131613//     p = (int)((long)(h->Data())); h=h->next;
    1614 // 
     1614//
    16151615//   assume(p >= 0);
    1616 // 
     1616//
    16171617//   int d, w;
    1618 //   
     1618//
    16191619//   if( !rGetAMPos(r, p, d, w, TRUE) )
    16201620//   {
    … …  
    16221622//     return TRUE;
    16231623//   }
    1624 // 
     1624//
    16251625//   assume( r->typ[d].ord_typ == ro_am );
    16261626//   assume( r->order[w] == ringorder_am );
    1627 // 
    1628 // 
     1627//
     1628//
    16291629//   const short start = r->typ[d].data.am.start;  // bounds of ordering (in E)
    16301630//   const short end = r->typ[d].data.am.end;
    … …  
    16321632//   const int *weights = r->typ[d].data.am.weights; // pointers into wvhdl field of length (end-start+1) + len_gen
    16331633//   // contents w_1,... w_n, len, mod_w_1, .. mod_w_len, 0
    1634 // 
     1634//
    16351635//   assume( weights == r->wvhdl[w] );
    1636 // 
    1637 //   
     1636//
     1637//
    16381638//   lists l=(lists)omAllocBin(slists_bin);
    16391639//   l->Init(2);
    1640 // 
     1640//
    16411641//   const short V = end-start+1;
    16421642//   intvec* ww_vars = new intvec(V);
    16431643//   intvec* ww_gens = new intvec(len_gen);
    1644 // 
     1644//
    16451645//   for (int i = 0; i < V; i++ )
    16461646//     (*ww_vars)[i] = weights[i];
    1647 // 
     1647//
    16481648//   assume( weights[V] == len_gen );
    1649 // 
     1649//
    16501650//   for (int i = 0; i < len_gen; i++ )
    16511651//     (*ww_gens)[i] = weights[i - V - 1];
    1652 //   
    1653 // 
     1652//
     1653//
    16541654//   l->m[0].rtyp = INTVEC_CMD;
    16551655//   l->m[0].data = reinterpret_cast<void *>(ww_vars);
    1656 // 
     1656//
    16571657//   l->m[1].rtyp = INTVEC_CMD;
    16581658//   l->m[1].data = reinterpret_cast<void *>(ww_gens);
    1659 // 
    1660 // 
     1659//
     1660//
    16611661//   return FALSE;
    1662 // 
     1662//
    16631663// }
    16641664*/
    … …  
    17821782
    17831783  if ( ( (h!=NULL) && (h->Typ()== INT_CMD)  ) )
    1784     iLazyReduce = (int)((long)(h->Data())); 
    1785 
    1786   res->data = (void *)kNFLength(M, currQuotient, v, iSyzComp, iLazyReduce); // NOTE: currRing :(
     1784    iLazyReduce = (int)((long)(h->Data()));
     1785
     1786  res->data = (void *)kNFLength(M, currRing->qideal, v, iSyzComp, iLazyReduce); // NOTE: currRing :(
    17871787  return FALSE;
    17881788}
    … …  
    18301830      iComp = id_RankFreeModule(r->typ[posIS].data.is.F, r); // ;
    18311831  }
    1832  
     1832
    18331833  assume(iComp >= 0);
    18341834
    … …  
    18381838
    18391839  //           int add_row_shift = 0;
    1840   // 
     1840  //
    18411841  if (w!=NULL)
    18421842  {
    18431843    w = ivCopy(w);
    18441844  //             add_row_shift = ww->min_in();
    1845   // 
     1845  //
    18461846  //             (*ww) -= add_row_shift;
    1847   //             
    1848   //             if (idTestHomModule(I, currQuotient, ww))
     1847  //
     1848  //             if (idTestHomModule(I, currRing->qideal, ww))
    18491849  //             {
    18501850    hom = isHomog;
    … …  
    18671867
    18681868  ideal J = // idPrepare( I, hom, iComp, &w);
    1869            kStd(I, currQuotient, hom, &w, NULL, iComp);
     1869           kStd(I, currRing->qideal, hom, &w, NULL, iComp);
    18701870
    18711871  idTest(J);
    … …  
    18921892  const poly p = reinterpret_cast<poly>(h->Data());
    18931893
    1894  
     1894
    18951895  pTest(p);  pWrite(p); PrintLn();
    18961896
    1897  
    1898   p_Content( p, currRing);     
     1897
     1898  p_Content( p, currRing);
    18991899
    19001900  pTest(p);
    19011901  pWrite(p); PrintLn();
    1902  
     1902
    19031903  NoReturn(res);
    19041904  return FALSE;
    … …  
    19081908{
    19091909  int ret = 0;
    1910  
     1910
    19111911  if ( (h!=NULL) && (h->Typ()!=INT_CMD) )
    19121912  {
    … …  
    19221922}
    19231923
    1924    
     1924
    19251925
    19261926END_NAMESPACE
    19271927
    19281928
    1929 int SI_MOD_INIT(syzextra)(SModulFunctions* psModulFunctions) 
     1929int SI_MOD_INIT(syzextra)(SModulFunctions* psModulFunctions)
    19301930{
    19311931
    … …  
    19851985  //  ADD("", FALSE, );
    19861986
    1987 #undef ADD 
     1987#undef ADD
    19881988  return 0;
    19891989}
    19901990
    19911991#ifndef EMBED_PYTHON
    1992 extern "C" { 
     1992extern "C" {
    19931993int mod_init(SModulFunctions* psModulFunctions)
    1994 { 
    1995   return SI_MOD_INIT(syzextra)(psModulFunctions); 
     1994{
     1995  return SI_MOD_INIT(syzextra)(psModulFunctions);
    19961996}
    19971997}

  • Singular/dyn_modules/syzextra/myNF.cc

    r46c7c3 r984ff3  
    11// -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
    22/*****************************************************************************\
    3  * Computer Algebra System SINGULAR   
     3 * Computer Algebra System SINGULAR
    44\*****************************************************************************/
    55/** @file DebugPrint.cc
    6  * 
     6 *
    77 * Here we implement dPrint-s.
    88 *
    … …  
    303303    pp = p_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing);
    304304
    305     if(Q == currQuotient)
     305    if(Q == currRing->qideal)
    306306      Q = SCAQuotient(currRing);
    307307  }

  • Singular/dyn_modules/syzextra/syzextra.cc

    r46c7c3 r984ff3  
    11// -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
    22/*****************************************************************************\
    3  * Computer Algebra System SINGULAR   
     3 * Computer Algebra System SINGULAR
    44\*****************************************************************************/
    55/** @file syzextra.cc
    6  * 
     6 *
    77 * Here we implement the Computation of Syzygies
    88 *
    … …  
    5050#include <Singular/attrib.h>
    5151
    52 #include <Singular/ipid.h> 
     52#include <Singular/ipid.h>
    5353#include <Singular/ipshell.h> // For iiAddCproc
    5454
    … …  
    7373static int cmp_c_ds(const void *p1, const void *p2)
    7474{
    75   void *R = currRing; 
     75  void *R = currRing;
    7676#endif
    7777
    … …  
    151151  }
    152152
    153   return 0; 
    154 }
    155 
    156    
     153  return 0;
     154}
     155
     156
    157157static int cmp_poly(const poly &a, const poly &b)
    158158{
    … …  
    171171  assume( p_GetComp(a, r) == 0 );
    172172  assume( p_GetComp(b, r) == 0 );
    173    
     173
    174174#ifndef NDEBUG
    175175  const int __DEBUG__ = 0;
    … …  
    198198  }
    199199
    200   return 0; 
    201 }
    202    
     200  return 0;
     201}
     202
    203203END_NAMESPACE
    204204/* namespace SORT_c_ds */
    … …  
    213213    return;
    214214  }
    215    
     215
    216216  assume( r != NULL );
    217217  const coeffs C = r->cf; assume(C != NULL);
    … …  
    221221
    222222  do {
    223   assume( p != NULL );   
    224        
     223  assume( p != NULL );
     224
    225225  // write coef...
    226226  number& n = p_GetCoeff(p, r);
    227227
    228228  n_Normalize(n, C);
    229      
     229
    230230  BOOLEAN writeMult = FALSE; ///< needs * before pp or module generator
    231231
    232232  BOOLEAN writeOne = FALSE; ///< need to write something after '-'!
    233      
     233
    234234  if( n_IsZero(n, C) )
    235235  {
    … …  
    237237//    return; // yes?
    238238  }
    239  
     239
    240240  if (n_IsMOne(n, C))
    241   {     
     241  {
    242242    PrintS(" - "); writeOne = TRUE; writePlus = FALSE;
    243   }     
     243  }
    244244  else if (!n_IsOne(n, C))
    245245  {
    246246    if( writePlus && n_GreaterZero(n, C) )
    247247      PrintS(" + ");
    248    
    249     StringSetS(""); n_WriteLong(n, C); 
    250     if (true) 
     248
     249    StringSetS(""); n_WriteLong(n, C);
     250    if (true)
    251251    {
    252252      char *s = StringEndS(); PrintS(s); omFree(s);
    253253    }
    254      
    255      
     254
     255
    256256    writeMult = TRUE;
    257257    writePlus = TRUE;
    258258  } else
    259259     writeOne = TRUE;
    260    
     260
    261261  // missing '1' if no PP and gen...!?
    262262  // write monom...
    … …  
    268268  {
    269269    const long ee = p_GetExp(p, i+1, r);
    270    
     270
    271271    if (ee!=0L)
    272272    {
    … …  
    285285      else
    286286        Print(" %s ", rRingVar(i, r));
    287        
     287
    288288      writeOne = FALSE;
    289289      wrotePP = TRUE;
    … …  
    292292
    293293  writePlus = writePlus || wrotePP;
    294   writeMult = writeMult || wrotePP; 
     294  writeMult = writeMult || wrotePP;
    295295
    296296  // write module gen...
    297297  const long comp = p_GetComp(p, r);
    298  
     298
    299299  if (comp > 0 )
    300300  {
    301301    if (writeMult)
    302302      PrintS(" \\\\cdot ");
    303      else 
     303     else
    304304      if( writePlus )
    305305        PrintS(" + ");
    … …  
    309309    else
    310310      Print(" \\\\GENP{%ld} ", comp);
    311      
    312       writeOne = FALSE; 
    313   }
    314      
     311
     312      writeOne = FALSE;
     313  }
     314
    315315  if ( writeOne )
    316316    PrintS( writePlus? " + 1 " : " 1 " );
    317        
     317
    318318
    319319  pIter(p);
    320      
     320
    321321  writePlus = TRUE;
    322322  } while( (!bLTonly) && (p != NULL) );
    323    
    324 }
    325 
    326 
    327 
    328 
    329    
     323
     324}
     325
     326
     327
     328
     329
    330330/// return a new term: leading coeff * leading monomial of p
    331331/// with 0 leading component!
    … …  
    346346    p_Setm(m, r);
    347347
    348    
     348
    349349    assume( m != NULL );
    350350    assume( pNext(m) == NULL );
    351351    assume( p_LmTest(m, r) );
    352    
     352
    353353    if( bSetZeroComp )
    354354      assume( p_GetComp(m, r) == 0 );
    … …  
    359359
    360360
    361    
     361
    362362poly p_Tail(const poly p, const ring r)
    363363{
    … …  
    375375
    376376  const ideal newid = idInit(IDELEMS(id),id->rank);
    377  
     377
    378378  for (int i=IDELEMS(id) - 1; i >= 0; i--)
    379379    newid->m[i] = p_Tail( id->m[i], r );
    … …  
    381381  newid->rank = id_RankFreeModule(newid, currRing);
    382382
    383   return newid; 
     383  return newid;
    384384}
    385385
    … …  
    395395#define qsort_my(m, s, ss, r, cmp) qsort_r(m, s, ss, cmp)
    396396#endif
    397  
     397
    398398  if( sizeNew >= 2 )
    399399    qsort_my(id->m, sizeNew, sizeof(poly), r, FROM_NAMESPACE(SORT_c_ds, cmp_c_ds));
    … …  
    408408{
    409409  extern void id_Delete (ideal*, const ring);
    410    
     410
    411411  id_Delete(const_cast<ideal*>(&m_idTails), m_rBaseRing); // TODO!!!
    412412
    … …  
    422422    m_spoly_bucket = NULL;
    423423  }
    424    
     424
    425425  for( TCache::iterator it = m_cache.begin(); it != m_cache.end(); it++ )
    426426  {
    427427    TP2PCache& T = it->second;
    428      
     428
    429429    for(TP2PCache::iterator vit = T.begin(); vit != T.end(); vit++ )
    430     {   
     430    {
    431431      p_Delete( (&(vit->second)), m_rBaseRing);
    432432      p_Delete( const_cast<poly*>(&(vit->first)), m_rBaseRing);
    … …  
    465465  CReducersHash::const_iterator itr = m_hash.find(comp);
    466466
    467   if ( itr == m_hash.end() ) 
     467  if ( itr == m_hash.end() )
    468468    return 2; // no such leading component!!!
    469    
     469
    470470  assume( itr->first == comp );
    471    
    472   const bool bIdealCase = (comp == 0);   
     471
     472  const bool bIdealCase = (comp == 0);
    473473  const bool bSyzCheck = syzChecker.IsNonempty(); // need to check even in ideal case????? proof?  "&& !bIdealCase"
    474474
    … …  
    485485      const poly p = (*vit)->m_lt;
    486486
    487       assume( p_GetComp(p, r) == comp ); 
     487      assume( p_GetComp(p, r) == comp );
    488488
    489489      // TODO: check if coprime with Leads... if __TAILREDSYZ__ !
    490490      for( int var = N; var > 0; --var )
    491491        if( (p_GetExp(p, var, r) != 0) && (p_GetExp(t, var, r) != 0) )
    492         {       
     492        {
    493493#ifndef NDEBUG
    494494          if( __DEBUG__ | 0)
    495           {         
     495          {
    496496            PrintS("CReducerFinder::PreProcessTerm, 't' is NOT co-prime with the following leading term: \n");
    497497            dPrint(p, r, r, 1);
    498498          }
    499 #endif     
     499#endif
    500500          coprime = false; // t not coprime with p!
    501501          break;
    … …  
    513513#ifndef NDEBUG
    514514        if( __DEBUG__ && !coprime)
    515         {         
     515        {
    516516          PrintS("CReducerFinder::PreProcessTerm, 't' is co-prime with p but may lead to NOT divisible syz.term: \n");
    517517          dPrint(ss, r, r, 1);
    518518        }
    519519#endif
    520          
     520
    521521        p_LmDelete(&ss, r); // deletes coeff as well???
    522522      }
    … …  
    528528      PrintS("CReducerFinder::PreProcessTerm, the following 't' is 'co-prime' with all of leading terms! \n");
    529529#endif
    530      
    531     return coprime? 3: 0; // t was coprime with all of leading terms!!! 
     530
     531    return coprime? 3: 0; // t was coprime with all of leading terms!!!
    532532
    533533  }
    … …  
    536536  return 0;
    537537}
    538  
    539    
     538
     539
    540540void SchreyerSyzygyComputation::SetUpTailTerms()
    541541{
    542   const ideal idTails = m_idTails; 
     542  const ideal idTails = m_idTails;
    543543  assume( idTails != NULL );
    544544  assume( idTails->m != NULL );
    … …  
    557557  for( int p = IDELEMS(idTails) - 1; p >= 0; --p )
    558558    for( poly* tt = &(idTails->m[p]); (*tt) != NULL;  )
    559     {   
     559    {
    560560      const poly t = *tt;
    561561      const int k = m_div.PreProcessTerm(t, m_checker); // 0..3
    … …  
    565565      pp[k]++;
    566566#endif
    567        
     567
    568568      if( k )
    569569      {
    570570#ifndef NDEBUG
    571571        if( __DEBUG__)
    572         {         
     572        {
    573573          Print("SchreyerSyzygyComputation::SetUpTailTerms(): PP (%d) the following TT: \n", k);
    574574          dPrint(t, r, r, 1);
    … …  
    577577
    578578        (*tt) = p_LmDeleteAndNext(t, r); // delete the lead and next...
    579       }   
    580       else 
     579      }
     580      else
    581581        tt = &pNext(t); // go next?
    582582
    … …  
    588588    Print("%%      **!!**      SchreyerSyzygyComputation::SetUpTailTerms()::PreProcessing(): X: {c: %lu, C: %lu, P: %lu} + %lu\n", pp[1], pp[2], pp[3], pp[0]);
    589589#endif
    590    
     590
    591591#ifndef NDEBUG
    592592  if( !__TREEOUTPUT__ )
    … …  
    597597  }
    598598#endif
    599    
    600 }
    601 /* 
     599
     600}
     601/*
    602602  m_idTailTerms.resize( IDELEMS(idTails) );
    603  
     603
    604604  for( unsigned int p = IDELEMS(idTails) - 1; p >= 0; p -- )
    605605  {
    … …  
    609609
    610610    unsigned int pp = 0;
    611    
     611
    612612    while( t != NULL )
    613613    {
    614614      assume( t != NULL );
    615615      // TODO: compute L:t!
    616 //      ideal reducers;     
     616//      ideal reducers;
    617617//      CReducerFinder m_reducers
    618      
     618
    619619      CTailTerm* d = v[pp] = new CTailTerm();
    620      
     620
    621621      ++pp; pIter(t);
    622622    }
    … …  
    649649  if( size < 2 )
    650650  {
    651     const ideal newid = idInit(1, 0); newid->m[0] = NULL; // zero ideal...       
     651    const ideal newid = idInit(1, 0); newid->m[0] = NULL; // zero ideal...
    652652    return newid;
    653653  }
    … …  
    745745  const ring& r = m_rBaseRing;
    746746//  const SchreyerSyzygyComputationFlags& attributes = m_atttributes;
    747  
     747
    748748//   const BOOLEAN __DEBUG__      = attributes.__DEBUG__;
    749749//   const BOOLEAN __SYZCHECK__   = attributes.__SYZCHECK__;
    … …  
    751751//   const BOOLEAN __HYBRIDNF__   = attributes.__HYBRIDNF__;
    752752//  const BOOLEAN __TAILREDSYZ__ = attributes.__TAILREDSYZ__;
    753  
     753
    754754
    755755  // 1. set of components S?
    … …  
    762762  if( size < 2 )
    763763  {
    764     const ideal newid = idInit(1, 1); newid->m[0] = NULL; // zero module...   
     764    const ideal newid = idInit(1, 1); newid->m[0] = NULL; // zero module...
    765765    return newid;
    766766  }
    … …  
    768768
    769769  // TODO/NOTE: input is supposed to be sorted wrt "C,ds"!??
    770  
     770
    771771  // components should come in groups: count elements in each group
    772772  // && estimate the real size!!!
    … …  
    826826
    827827      p_SetCoeff0(m ,       n_Div(g, lc1, r), r);
    828       p_SetCoeff0(mm, n_Neg(n_Div(g, lc2, r), r), r);
     828      p_SetCoeff0(mm, n_InpNeg(n_Div(g, lc2, r), r), r);
    829829
    830830      n_Delete(&g, r);
    … …  
    863863      //      TEST_OPT_REDTAIL
    864864    assume( r == currRing );
    865  
     865
    866866    BITSET _save_test; SI_SAVE_OPT1(_save_test);
    867867    SI_RESTORE_OPT1(Sy_bit(OPT_REDTAIL) | Sy_bit(OPT_REDSB) | _save_test);
    868868
    869869    intvec* w=new intvec(IDELEMS(newid));
    870     ideal tmp = kStd(newid, currQuotient, isHomog, &w);
     870    ideal tmp = kStd(newid, currRing->qideal, isHomog, &w);
    871871    delete w;
    872872
    … …  
    887887
    888888  Sort_c_ds(newid, r);
    889  
     889
    890890  return newid;
    891891}
    … …  
    898898  const ring& R = m_rBaseRing;
    899899
    900   const int r = p_GetComp(a, R) - 1; 
     900  const int r = p_GetComp(a, R) - 1;
    901901
    902902  assume( r >= 0 && r < IDELEMS(T) );
    903903  assume( r >= 0 && r < IDELEMS(L) );
    904    
    905   assume( a != NULL );   
     904
     905  assume( a != NULL );
    906906
    907907  if( __TREEOUTPUT__ )
    … …  
    909909     PrintS("{ \"nodelabel\": \""); writeLatexTerm(a, R); PrintS("\", \"children\": [");
    910910  }
    911    
     911
    912912
    913913  poly aa = leadmonom(a, R); assume( aa != NULL); // :(
    914914
    915   poly t = TraverseTail(aa, r); 
    916    
     915  poly t = TraverseTail(aa, r);
     916
    917917  if( a2 != NULL )
    918918  {
    … …  
    929929    assume( r2 >= 0 && r2 < IDELEMS(T) );
    930930
    931     t = p_Add_q(a2, p_Add_q(t, TraverseTail(aa2, r2), R), R); 
     931    t = p_Add_q(a2, p_Add_q(t, TraverseTail(aa2, r2), R), R);
    932932
    933933    p_Delete(&aa2, R);
    934      
     934
    935935    if( __TREEOUTPUT__ )
    936936       PrintS("]},");
    … …  
    946946  {
    947947     PrintS("], \"noderesult\": \""); writeLatexTerm(t, R, true, false); PrintS("\" },");
    948   }   
     948  }
    949949  return t;
    950950}
    … …  
    971971  assume( IDELEMS(L) == IDELEMS(T) );
    972972#ifndef NDEBUG
    973   int t, r; 
     973  int t, r;
    974974#endif
    975975
    976976  if( __TREEOUTPUT__ )
    977977  {
    978     Print("\n{ \"syzygylayer\": \"%d\", \"hybridnf\": \"%d\", \"diagrams\": \n[", __SYZNUMBER__, __HYBRIDNF__ ); 
    979   } 
    980    
     978    Print("\n{ \"syzygylayer\": \"%d\", \"hybridnf\": \"%d\", \"diagrams\": \n[", __SYZNUMBER__, __HYBRIDNF__ );
     979  }
     980
    981981  if( m_syzLeads == NULL )
    982   {   
     982  {
    983983#ifndef NDEBUG
    984984    if( !__TREEOUTPUT__ )
    … …  
    988988      Print("%% %5d **!TIME4!** SchreyerSyzygyComputation::ComputeSyzygy::ComputeLeadingSyzygyTerms: t: %d, r: %d\n", r, t, r);
    989989    }
    990 #endif     
     990#endif
    991991    ComputeLeadingSyzygyTerms( __LEAD2SYZ__ && !__IGNORETAILS__ ); // 2 terms OR 1 term!
    992992#ifndef NDEBUG
    … …  
    998998    }
    999999#endif
    1000      
     1000
    10011001  }
    10021002
    … …  
    10101010  {
    10111011     if( __TREEOUTPUT__ )
    1012        PrintS("]},"); 
     1012       PrintS("]},");
    10131013     return;
    10141014  }
    1015    
     1015
    10161016
    10171017  // use hybrid method?
    … …  
    10301030      }
    10311031#endif
    1032        
     1032
    10331033      SetUpTailTerms();
    10341034#ifndef NDEBUG
    … …  
    10401040      }
    10411041#endif
    1042     }     
     1042    }
    10431043  }
    10441044
    … …  
    10511051  }
    10521052#endif
    1053    
     1053
    10541054  for( int k = size - 1; k >= 0; k-- )
    10551055  {
    10561056    const poly a = LL->m[k]; assume( a != NULL );
    10571057
    1058     poly a2 = pNext(a);   
     1058    poly a2 = pNext(a);
    10591059
    10601060    // Splitting 2-terms Leading syzygy module
    10611061    if( a2 != NULL )
    10621062      pNext(a) = NULL;
    1063      
     1063
    10641064    if( __IGNORETAILS__ )
    10651065    {
    … …  
    10891089    Print("%% %5d **!TIME4!** SchreyerSyzygyComputation::ComputeSyzygy::SyzygyLift: dt: %d, dr: %d\n", getRTimer(), t, r);
    10901090  }
    1091 #endif   
     1091#endif
    10921092
    10931093  TT->rank = id_RankFreeModule(TT, R);
    1094    
     1094
    10951095  if( __TREEOUTPUT__ )
    10961096    PrintS("\n]},");
    … …  
    11151115  {
    11161116    assume( !__LEAD2SYZ__ );
    1117    
     1117
    11181118    m_syzLeads = Compute1LeadingSyzygyTerms();
    11191119  }
    11201120//    m_syzLeads = FROM_NAMESPACE(INTERNAL, _ComputeLeadingSyzygyTerms(m_idLeads, m_rBaseRing, m_atttributes));
    1121  
     1121
    11221122  // NOTE: set m_LS if tails are to be reduced!
    11231123  assume( m_syzLeads!= NULL );
    … …  
    11271127    m_LS = m_syzLeads;
    11281128    m_checker.Initialize(m_syzLeads);
    1129 #ifndef NDEBUG   
     1129#ifndef NDEBUG
    11301130    if( __DEBUG__ )
    11311131    {
    … …  
    11461146poly SchreyerSyzygyComputation::SchreyerSyzygyNF(const poly syz_lead, poly syz_2) const
    11471147{
    1148  
     1148
    11491149  assume( !__IGNORETAILS__ );
    11501150
    … …  
    11601160    PrintS("{   \"nodelabel\": \""); writeLatexTerm(syz_lead, r); PrintS("\", \"children\": [");
    11611161  }
    1162    
     1162
    11631163  if( syz_2 == NULL )
    11641164  {
    1165     const int rr = p_GetComp(syz_lead, r) - 1; 
     1165    const int rr = p_GetComp(syz_lead, r) - 1;
    11661166
    11671167    assume( rr >= 0 && rr < IDELEMS(T) );
    … …  
    11751175      PrintS("{ \"nodelabel\": \""); writeLatexTerm(syz_2, r); PrintS("\" },");
    11761176    }
    1177 #else   
     1177#else
    11781178    poly aa = leadmonom(syz_lead, r); assume( aa != NULL); // :(
    11791179    aa = p_Mult_mm(aa, L->m[rr], r);
    … …  
    11831183      PrintS("{ \"nodelabel\": \""); writeLatexTerm(syz_2, r); PrintS("\", \"edgelable\": \""); writeLatexTerm(aa, r, false); PrintS("\" },");
    11841184    }
    1185      
     1185
    11861186    syz_2 = m_div.FindReducer(aa, syz_lead, m_checker);
    11871187
    11881188    p_Delete(&aa, r);
    11891189#endif
    1190    
    1191   }
    1192    
    1193   assume( syz_2 != NULL ); // by construction of S-Polynomial   
     1190
     1191  }
     1192
     1193  assume( syz_2 != NULL ); // by construction of S-Polynomial
    11941194
    11951195  assume( L != NULL );
    … …  
    12131213
    12141214//  kBucketInit(bucket, NULL, 0); // not needed!?
    1215      
    1216   poly p = leadmonom(syz_lead, r); // :( 
    1217 //  poly spoly = pp_Mult_qq(p, T->m[c], r); 
    1218   kBucket_Plus_mm_Mult_pp(bucket, p, T->m[c], 0); // TODO: store pLength(T->m[c]) separately!? 
     1215
     1216  poly p = leadmonom(syz_lead, r); // :(
     1217//  poly spoly = pp_Mult_qq(p, T->m[c], r);
     1218  kBucket_Plus_mm_Mult_pp(bucket, p, T->m[c], 0); // TODO: store pLength(T->m[c]) separately!?
    12191219  p_Delete(&p, r);
    1220  
    1221   kbTest(bucket); 
     1220
     1221  kbTest(bucket);
    12221222
    12231223  c = p_GetComp(syz_2, r) - 1;
    … …  
    12321232  // TODO: use bucket!?
    12331233//  const bool bUsePolynomial = TEST_OPT_NOT_BUCKETS; //  || (pLength(spoly) < MIN_LENGTH_BUCKET);
    1234 //  CPolynomialSummator tail(r, bUsePolynomial);                       
    1235   sBucket_Add_p(tail, syz_2, 1); // tail.AddAndDelete(syz_2, 1); 
    1236  
     1234//  CPolynomialSummator tail(r, bUsePolynomial);
     1235  sBucket_Add_p(tail, syz_2, 1); // tail.AddAndDelete(syz_2, 1);
     1236
    12371237  kbTest(bucket);
    12381238  for( poly spoly = kBucketExtractLm(bucket); spoly != NULL; p_LmDelete(&spoly, r), spoly = kBucketExtractLm(bucket))
    1239   {   
     1239  {
    12401240    kbTest(bucket);
    1241     poly t = m_div.FindReducer(spoly, NULL, m_checker);   
     1241    poly t = m_div.FindReducer(spoly, NULL, m_checker);
    12421242
    12431243    if( t != NULL )
    … …  
    12471247
    12481248      assume( c >= 0 && c < IDELEMS(T) );
    1249        
     1249
    12501250      if( __TREEOUTPUT__ )
    12511251      {
    … …  
    12701270  sBucketClearAdd(tail, &result, &len); // TODO: use Merge with sBucket???
    12711271  assume( pLength(result) == len );
    1272      
     1272
    12731273  if( __TREEOUTPUT__ )
    1274   {   
     1274  {
    12751275    PrintS("]},");
    12761276  }
    1277    
     1277
    12781278
    12791279  return result;
    12801280}
    12811281
    1282 // namespace     {   
     1282// namespace     {
    12831283
    12841284// };
    … …  
    12911291{
    12921292  const ring& r = m_rBaseRing;
    1293    
     1293
    12941294  assume(m_idTails !=  NULL && m_idTails->m != NULL);
    12951295  assume( tail >= 0 && tail < IDELEMS(m_idTails) );
    1296    
     1296
    12971297/*  return ComputeImage(multiplier, tail); */
    1298  
     1298
    12991299  // TODO: store (multiplier, tail) -.-^-.-^-.--> !
    13001300  TCache::iterator top_itr = m_cache.find(tail);
    1301    
     1301
    13021302  if ( top_itr != m_cache.end() )
    13031303  {
    … …  
    13051305
    13061306     TP2PCache& T = top_itr->second;
    1307      
     1307
    13081308     TP2PCache::iterator itr = T.find(multiplier);
    1309      
     1309
    13101310     if( itr != T.end() ) // Yey - Reuse!!!
    13111311     {
    13121312       assume( p_LmEqual(itr->first, multiplier, r) );
    1313        
     1313
    13141314       if( itr->second == NULL )
    1315         return (NULL);
    1316        
     1315        return (NULL);
     1316
    13171317       poly p = p_Copy(itr->second, r); // no copy???
    1318        
     1318
    13191319       if( __TREEOUTPUT__ )
    13201320       {
    1321 //         PrintS("{ \"nodelabel\": \""); writeLatexTerm(multiplier, r, false); 
     1321//         PrintS("{ \"nodelabel\": \""); writeLatexTerm(multiplier, r, false);
    13221322//         Print(" \\\\cdot \\\\GEN{%d}\", \"children\": [ ", tail + 1);
    1323           Print("{ \"lookedupnode\": \"1\", \"nodelabel\": \"");
    1324           writeLatexTerm(p, r, true, false);
     1323          Print("{ \"lookedupnode\": \"1\", \"nodelabel\": \"");
     1324          writeLatexTerm(p, r, true, false);
    13251325       }
    1326        
     1326
    13271327       if( !n_Equal( pGetCoeff(multiplier), pGetCoeff(itr->first), r) ) // normalize coeffs!?
    13281328       {
    1329          number n = n_Div( pGetCoeff(multiplier), pGetCoeff(itr->first), r); 
    1330          p = p_Mult_nn(p, n, r); 
     1329         number n = n_Div( pGetCoeff(multiplier), pGetCoeff(itr->first), r);
     1330         p = p_Mult_nn(p, n, r);
    13311331         n_Delete(&n, r);
    1332          
     1332
    13331333         if( __TREEOUTPUT__ )
    13341334           Print("\", \"RESCALEDRESULT\": \"1\" },");
    … …  
    13381338           Print("\", \"RESCALEDRESULT\": \"0\" },");
    13391339       }
    1340        
     1340
    13411341       return p;
    13421342     }
    … …  
    13451345     {
    13461346//        PrintS("{ \"nodelabel\": \""); writeLatexTerm(multiplier, r, false); Print(" \\\\cdot \\\\GEN{%d}\", \"children\": [", tail + 1);
    1347      }     
    1348      
     1347     }
     1348
    13491349     const poly p = ComputeImage(multiplier, tail);
    13501350     T.insert( TP2PCache::value_type(p_Copy(multiplier, r), p) ); //     T[ multiplier ] = p;
    … …  
    13521352//     if( p == NULL )
    13531353//        return (NULL);
    1354      
     1354
    13551355     if( __TREEOUTPUT__ )
    13561356     {
    1357 //      PrintS("], \"storedResult\": \""); writeLatexTerm(p, r, true, false); PrintS("\" },");
     1357//        PrintS("], \"storedResult\": \""); writeLatexTerm(p, r, true, false); PrintS("\" },");
    13581358     }
    1359      
     1359
    13601360     return p_Copy(p, r);
    13611361  }
    1362    
     1362
    13631363  CCacheCompare o(r); TP2PCache T(o);
    13641364
    … …  
    13671367//     PrintS("{ \"nodelabel\": \""); writeLatexTerm(multiplier, r, false); Print(" \\\\cdot \\\\GEN{%d}\", \"children\": [", tail + 1);
    13681368  }
    1369    
    1370    
     1369
     1370
    13711371  const poly p = ComputeImage(multiplier, tail);
    13721372
    13731373  T.insert( TP2PCache::value_type(p_Copy(multiplier, r), p) );
    1374    
     1374
    13751375  m_cache.insert( TCache::value_type(tail, T) );
    13761376
    13771377//  if( p == NULL )
    13781378//    return (NULL);
    1379    
     1379
    13801380  if( __TREEOUTPUT__ )
    13811381  {
    13821382//     PrintS("], \"storedResult\": \""); writeLatexTerm(p, r, true, false); PrintS("\" },");
    13831383  }
    1384    
     1384
    13851385  return p_Copy(p, r);
    13861386}
    … …  
    13961396}
    13971397
    1398    
     1398
    13991399poly SchreyerSyzygyComputation::TraverseTail(poly multiplier, poly tail) const
    14001400{
    … …  
    14191419    sBucket_pt& sum   = m_sum_bucket; assume( sum != NULL );
    14201420    poly s; int len;
    1421    
     1421
    14221422//    CPolynomialSummator sum(r, bUsePolynomial);
    14231423//    poly s = NULL;
    … …  
    14311431      // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    14321432      // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    1433      
     1433
    14341434      const int lp = pLength(rt);
    14351435      if( rt != NULL && lp != 0 )
    1436         sBucket_Add_p(sum, rt, lp); 
     1436        sBucket_Add_p(sum, rt, lp);
    14371437    }
    14381438
    … …  
    14741474    if( s == NULL ) // No Reducer?
    14751475     return s;
    1476      
     1476
    14771477    if( __TREEOUTPUT__ )
    14781478    {
    1479       PrintS("{ \"nodelabel\": \""); writeLatexTerm(s, r); 
    1480     }
    1481    
    1482 #else   
     1479      PrintS("{ \"nodelabel\": \""); writeLatexTerm(s, r);
     1480    }
     1481
     1482#else
    14831483    // NOTE: only LT(term4reduction) should be used in the following:
    14841484    poly product = pp_Mult_mm(multiplier, term4reduction, r);
    … …  
    14871487    if( s == NULL ) // No Reducer?
    14881488     return s;
    1489      
     1489
    14901490    if( __TREEOUTPUT__ )
    14911491    {
    1492       PrintS("{ \"nodelabel\": \""); writeLatexTerm(s, r); PrintS("\", \"edgelable\": \""); writeLatexTerm(product, r, false); 
    1493     }
    1494      
     1492      PrintS("{ \"nodelabel\": \""); writeLatexTerm(s, r); PrintS("\", \"edgelable\": \""); writeLatexTerm(product, r, false);
     1493    }
     1494
    14951495    p_Delete(&product, r);
    14961496#endif
    … …  
    14991499  if( s == NULL ) // No Reducer?
    15001500    return s;
    1501    
     1501
    15021502
    15031503  poly b = leadmonom(s, r);
    … …  
    15061506  assume( c >= 0 && c < IDELEMS(T) );
    15071507
    1508    
     1508
    15091509  if( __TREEOUTPUT__ )
    15101510     PrintS("\", \"children\": [");
    1511    
     1511
    15121512  const poly t = TraverseTail(b, c); // T->m[c];
    15131513
    15141514  if( t != NULL )
    1515     s = p_Add_q(s, t, r); 
     1515    s = p_Add_q(s, t, r);
    15161516
    15171517  if( __TREEOUTPUT__ )
    15181518  {
    1519        
     1519
    15201520    PrintS("], \"noderesult\": \"");
    1521     writeLatexTerm(s, r, true, false); 
     1521    writeLatexTerm(s, r, true, false);
    15221522    PrintS("\" },");
    15231523  }
    1524    
     1524
    15251525  return s;
    15261526}
    … …  
    15311531
    15321532BEGIN_NAMESPACE_NONAME
    1533    
     1533
    15341534static inline int atGetInt(idhdl rootRingHdl, const char* attribute, long def)
    15351535{
    … …  
    15371537}
    15381538
    1539 END_NAMESPACE   
    1540 
    1541      
     1539END_NAMESPACE
     1540
     1541
    15421542SchreyerSyzygyComputationFlags::SchreyerSyzygyComputationFlags(idhdl rootRingHdl):
    15431543#ifndef NDEBUG
    … …  
    15471547#endif
    15481548//    __SYZCHECK__( (BOOLEAN)atGetInt(rootRingHdl, "SYZCHECK", __DEBUG__) ),
    1549     __LEAD2SYZ__( atGetInt(rootRingHdl, "LEAD2SYZ", 1) ), 
    1550     __TAILREDSYZ__( atGetInt(rootRingHdl, "TAILREDSYZ", 1) ), 
     1549    __LEAD2SYZ__( atGetInt(rootRingHdl, "LEAD2SYZ", 1) ),
     1550    __TAILREDSYZ__( atGetInt(rootRingHdl, "TAILREDSYZ", 1) ),
    15511551    __HYBRIDNF__( atGetInt(rootRingHdl, "HYBRIDNF", 2) ),
    15521552    __IGNORETAILS__( atGetInt(rootRingHdl, "IGNORETAILS", 0) ),
    … …  
    15541554    __TREEOUTPUT__( atGetInt(rootRingHdl, "TREEOUTPUT", 0) ),
    15551555    m_rBaseRing( rootRingHdl->data.uring )
    1556 {   
     1556{
    15571557#ifndef NDEBUG
    15581558  if( __DEBUG__ )
    … …  
    15681568  }
    15691569#endif
    1570    
     1570
    15711571  // TODO: just current setting!
    15721572  assume( rootRingHdl == currRingHdl );
    … …  
    15761576}
    15771577
    1578    
     1578
    15791579
    15801580CLeadingTerm::CLeadingTerm(unsigned int _label,  const poly _lt, const ring R):
    … …  
    16011601
    16021602  assume( m_L == L );
    1603  
     1603
    16041604  if( L != NULL )
    16051605  {
    16061606    const ring& R = m_rBaseRing;
    16071607    assume( R != NULL );
    1608    
     1608
    16091609    for( int k = IDELEMS(L) - 1; k >= 0; k-- )
    16101610    {
    … …  
    16851685  const unsigned long p_sev = m_sev;
    16861686
    1687   assume( p_sev == p_GetShortExpVector(p, r) );     
     1687  assume( p_sev == p_GetShortExpVector(p, r) );
    16881688
    16891689  return p_LmShortDivisibleByNoComp(p, p_sev, product, not_sev, r);
    … …  
    17041704
    17051705  const unsigned long p_sev = m_sev;
    1706   assume( p_sev == p_GetShortExpVector(p, r) );     
     1706  assume( p_sev == p_GetShortExpVector(p, r) );
    17071707
    17081708  if (p_sev & not_sev)
    … …  
    17201720class CDivisorEnumerator: public SchreyerSyzygyComputationFlags
    17211721{
    1722   private: 
     1722  private:
    17231723    const CReducerFinder& m_reds;
    17241724    const poly m_product;
    … …  
    17421742    {
    17431743      assume( m_comp >= 0 );
    1744       assume( m_reds.m_L != NULL ); 
     1744      assume( m_reds.m_L != NULL );
    17451745    }
    17461746
    … …  
    17481748    {
    17491749      m_active = false;
    1750      
     1750
    17511751      m_itr = m_reds.m_hash.find(m_comp);
    17521752
    … …  
    17631763
    17641764//      m_active = true;
    1765       return true;     
     1765      return true;
    17661766    }
    17671767
    … …  
    17731773      return *(*m_current);
    17741774    }
    1775  
     1775
    17761776    inline bool MoveNext()
    17771777    {
    … …  
    17821782      else
    17831783        m_active = true; // for Current()
    1784      
     1784
    17851785      // looking for the next good entry
    17861786      for( ; m_current != m_finish; ++m_current )
    … …  
    18041804      // the end... :(
    18051805      assume( m_current == m_finish );
    1806      
     1806
    18071807      m_active = false;
    18081808      return false;
    … …  
    18191819
    18201820  return itr.MoveNext();
    1821  
    1822 /* 
     1821
     1822/*
    18231823  const ring& r = m_rBaseRing;
    1824  
     1824
    18251825  const long comp = p_GetComp(product, r);
    18261826  const unsigned long not_sev = ~p_GetShortExpVector(product, r);
    … …  
    18301830  CReducersHash::const_iterator it = m_hash.find(comp); // same module component
    18311831
    1832   assume( m_L != NULL ); 
     1832  assume( m_L != NULL );
    18331833
    18341834  if( it == m_hash.end() )
    18351835    return false;
    18361836  // assume comp!
    1837  
     1837
    18381838  const TReducers& reducers = it->second;
    18391839
    … …  
    18551855
    18561856  return false;
    1857 */ 
     1857*/
    18581858}
    18591859
    … …  
    18921892class CDivisorEnumerator2: public SchreyerSyzygyComputationFlags
    18931893{
    1894   private: 
     1894  private:
    18951895    const CReducerFinder& m_reds;
    18961896    const poly m_multiplier, m_term;
    … …  
    19141914    {
    19151915      assume( m_comp >= 0 );
    1916       assume( m_reds.m_L != NULL ); 
    1917       assume( m_multiplier != NULL ); 
     1916      assume( m_reds.m_L != NULL );
     1917      assume( m_multiplier != NULL );
    19181918      assume( m_term != NULL );
    19191919//      assume( p_GetComp(m_multiplier, m_rBaseRing) == 0 );
    … …  
    19231923    {
    19241924      m_active = false;
    1925      
    1926       m_itr = m_reds.m_hash.find(m_comp); 
     1925
     1926      m_itr = m_reds.m_hash.find(m_comp);
    19271927
    19281928      if( m_itr == m_reds.m_hash.end() )
    … …  
    19371937        return false;
    19381938
    1939       return true;     
     1939      return true;
    19401940    }
    19411941
    … …  
    19471947      return *(*m_current);
    19481948    }
    1949  
     1949
    19501950    inline bool MoveNext()
    19511951    {
    … …  
    19541954      if( m_active )
    19551955        ++m_current;
    1956       else 
     1956      else
    19571957        m_active = true;
    1958    
    1959      
     1958
     1959
    19601960      // looking for the next good entry
    19611961      for( ; m_current != m_finish; ++m_current )
    … …  
    19741974//          m_active = true;
    19751975          return true;
    1976          
     1976
    19771977        }
    19781978      }
    … …  
    19801980      // the end... :(
    19811981      assume( m_current == m_finish );
    1982      
     1982
    19831983      m_active = false;
    19841984      return false;
    19851985    }
    19861986};
    1987    
     1987
    19881988poly CReducerFinder::FindReducer(const poly multiplier, const poly t,
    19891989                                 const poly syzterm,
    … …  
    20182018
    20192019    poly pr = p_Mult_q( leadmonom(multiplier, r, false), leadmonom(t, r, false), r);
    2020    
     2020
    20212021    assume( p_EqualPolys(lm, pr, r) );
    20222022
    … …  
    20242024    //  def @@product = leadmonomial(syzterm) * L[@@r];
    20252025
    2026     p_Delete(&lm, r);   
    2027     p_Delete(&pr, r);   
    2028   }
    2029    
    2030   const BOOLEAN to_check = (syz_checker.IsNonempty()); // __TAILREDSYZ__ && 
     2026    p_Delete(&lm, r);
     2027    p_Delete(&pr, r);
     2028  }
     2029
     2030  const BOOLEAN to_check = (syz_checker.IsNonempty()); // __TAILREDSYZ__ &&
    20312031
    20322032  const poly q = p_New(r); pNext(q) = NULL;
    … …  
    20392039    const poly p = itr.Current().m_lt;
    20402040    const int k  = itr.Current().m_label;
    2041      
     2041
    20422042    p_ExpVectorSum(q, multiplier, t, r); // q == product == multiplier * t // TODO: do it once?
    20432043    p_ExpVectorDiff(q, q, p, r); // (LM(product) / LM(L[k]))
    2044    
     2044
    20452045    p_SetComp(q, k + 1, r);
    20462046    p_Setm(q, r);
    … …  
    20552055          Print("_FindReducer::Test SYZTERM: q == syzterm !:((, syzterm is: ");
    20562056          dPrint(syzterm, r, r, 1);
    2057         }   
     2057        }
    20582058#endif
    20592059        continue;
    20602060      }
    20612061
    2062     // while the complement (the fraction) is not reducible by leading syzygies 
    2063     if( to_check && syz_checker.IsDivisible(q) ) 
     2062    // while the complement (the fraction) is not reducible by leading syzygies
     2063    if( to_check && syz_checker.IsDivisible(q) )
    20642064    {
    20652065#ifndef NDEBUG
    … …  
    20732073
    20742074    number n = n_Mult( p_GetCoeff(multiplier, r), p_GetCoeff(t, r), r);
    2075     p_SetCoeff0(q, n_Neg( n_Div(n, p_GetCoeff(p, r), r), r), r);
     2075    p_SetCoeff0(q, n_InpNeg( n_Div(n, p_GetCoeff(p, r), r), r), r);
    20762076    n_Delete(&n, r);
    2077    
     2077
    20782078    return q;
    20792079  }
    2080    
     2080
    20812081/*
    20822082  const long comp = p_GetComp(t, r); assume( comp >= 0 );
    … …  
    20862086//   {
    20872087//     const poly p = L->m[k];
    2088 // 
     2088//
    20892089//     if ( p_GetComp(p, r) != comp )
    20902090//       continue;
    2091 // 
     2091//
    20922092//     const unsigned long p_sev = p_GetShortExpVector(p, r); // to be stored in m_hash!!!
    20932093
    … …  
    20992099
    21002100  // assume comp!
    2101  
     2101
    21022102  assume( m_L != NULL );
    21032103
    … …  
    21132113
    21142114//    const unsigned long p_sev = (*vit)->m_sev;
    2115 //    assume( p_sev == p_GetShortExpVector(p, r) );     
     2115//    assume( p_sev == p_GetShortExpVector(p, r) );
    21162116
    21172117//    if( !p_LmShortDivisibleByNoComp(p, p_sev, product, not_sev, r) )
    2118 //      continue;     
     2118//      continue;
    21192119
    21202120    if( !(*vit)->DivisibilityCheck(multiplier, t, not_sev, r) )
    21212121      continue;
    2122    
    2123    
     2122
     2123
    21242124//    if (p_sev & not_sev) continue;
    2125 //    if( !_p_LmDivisibleByNoComp(p, multiplier, t, r) ) continue;     
    2126 
    2127 
    2128     p_ExpVectorSum(q, multiplier, t, r); // q == product == multiplier * t       
     2125//    if( !_p_LmDivisibleByNoComp(p, multiplier, t, r) ) continue;
     2126
     2127
     2128    p_ExpVectorSum(q, multiplier, t, r); // q == product == multiplier * t
    21292129    p_ExpVectorDiff(q, q, p, r); // (LM(product) / LM(L[k]))
    2130    
     2130
    21312131    p_SetComp(q, k + 1, r);
    21322132    p_Setm(q, r);
    … …  
    21402140          Print("_FindReducer::Test SYZTERM: q == syzterm !:((, syzterm is: ");
    21412141          dPrint(syzterm, r, r, 1);
    2142         }   
     2142        }
    21432143
    21442144        continue;
    21452145      }
    21462146
    2147     // while the complement (the fraction) is not reducible by leading syzygies 
    2148     if( to_check && syz_checker.IsDivisible(q) ) 
     2147    // while the complement (the fraction) is not reducible by leading syzygies
     2148    if( to_check && syz_checker.IsDivisible(q) )
    21492149    {
    21502150      if( __DEBUG__ )
    … …  
    21572157
    21582158    number n = n_Mult( p_GetCoeff(multiplier, r), p_GetCoeff(t, r), r);
    2159     p_SetCoeff0(q, n_Neg( n_Div(n, p_GetCoeff(p, r), r), r), r);
     2159    p_SetCoeff0(q, n_InpNeg( n_Div(n, p_GetCoeff(p, r), r), r), r);
    21602160    n_Delete(&n, r);
    2161    
     2161
    21622162    return q;
    21632163  }
    2164 */ 
     2164*/
    21652165
    21662166  p_LmFree(q, r);
    21672167
    21682168  return NULL;
    2169  
     2169
    21702170}
    21712171
    … …  
    22032203    //  def @@product = leadmonomial(syzterm) * L[@@r];
    22042204
    2205     p_Delete(&lm, r);   
    2206   }
    2207 
    2208 
    2209   const BOOLEAN to_check = (syz_checker.IsNonempty()); // __TAILREDSYZ__ && 
     2205    p_Delete(&lm, r);
     2206  }
     2207
     2208
     2209  const BOOLEAN to_check = (syz_checker.IsNonempty()); // __TAILREDSYZ__ &&
    22102210
    22112211  const poly q = p_New(r); pNext(q) = NULL;
    … …  
    22182218    const poly p = itr.Current().m_lt;
    22192219    const int k  = itr.Current().m_label;
    2220      
     2220
    22212221    p_ExpVectorDiff(q, product, p, r); // (LM(product) / LM(L[k]))
    22222222    p_SetComp(q, k + 1, r);
    … …  
    22322232          Print("_FindReducer::Test SYZTERM: q == syzterm !:((, syzterm is: ");
    22332233          dPrint(syzterm, r, r, 1);
    2234         }   
     2234        }
    22352235#endif
    22362236        continue;
    22372237      }
    22382238
    2239     // while the complement (the fraction) is not reducible by leading syzygies 
    2240     if( to_check && syz_checker.IsDivisible(q) ) 
     2239    // while the complement (the fraction) is not reducible by leading syzygies
     2240    if( to_check && syz_checker.IsDivisible(q) )
    22412241    {
    22422242#ifndef NDEBUG
    … …  
    22492249    }
    22502250
    2251     p_SetCoeff0(q, n_Neg( n_Div( p_GetCoeff(product, r), p_GetCoeff(p, r), r), r), r);
    2252    
     2251    p_SetCoeff0(q, n_InpNeg( n_Div( p_GetCoeff(product, r), p_GetCoeff(p, r), r), r), r);
     2252
    22532253    return q;
    22542254  }
    2255    
    2256    
    2257    
    2258 /*   
     2255
     2256
     2257
     2258/*
    22592259  const long comp = p_GetComp(product, r);
    22602260  const unsigned long not_sev = ~p_GetShortExpVector(product, r);
    … …  
    22652265//   {
    22662266//     const poly p = L->m[k];
    2267 // 
     2267//
    22682268//     if ( p_GetComp(p, r) != comp )
    22692269//       continue;
    2270 // 
     2270//
    22712271//     const unsigned long p_sev = p_GetShortExpVector(p, r); // to be stored in m_hash!!!
    2272  
     2272
    22732273   // looking for an appropriate diviser p = L[k]...
    22742274  CReducersHash::const_iterator it = m_hash.find(comp); // same module component
    … …  
    22812281  const TReducers& reducers = it->second;
    22822282
    2283   const BOOLEAN to_check = (syz_checker.IsNonempty()); // __TAILREDSYZ__ && 
     2283  const BOOLEAN to_check = (syz_checker.IsNonempty()); // __TAILREDSYZ__ &&
    22842284
    22852285  const poly q = p_New(r); pNext(q) = NULL;
    … …  
    22872287  if( __DEBUG__ )
    22882288    p_SetCoeff0(q, 0, r); // for printing q
    2289  
     2289
    22902290  for(TReducers::const_iterator vit = reducers.begin(); vit != reducers.end(); vit++ )
    22912291  {
    … …  
    23002300    const unsigned long p_sev = (*vit)->m_sev;
    23012301
    2302     assume( p_sev == p_GetShortExpVector(p, r) );     
     2302    assume( p_sev == p_GetShortExpVector(p, r) );
    23032303
    23042304    if( !p_LmShortDivisibleByNoComp(p, p_sev, product, not_sev, r) )
    2305       continue;     
     2305      continue;
    23062306
    23072307//     // ... which divides the product, looking for the _1st_ appropriate one!
    … …  
    23212321          Print("_FindReducer::Test SYZTERM: q == syzterm !:((, syzterm is: ");
    23222322          dPrint(syzterm, r, r, 1);
    2323         }   
     2323        }
    23242324
    23252325        continue;
    23262326      }
    23272327
    2328     // while the complement (the fraction) is not reducible by leading syzygies 
    2329     if( to_check && syz_checker.IsDivisible(q) ) 
     2328    // while the complement (the fraction) is not reducible by leading syzygies
     2329    if( to_check && syz_checker.IsDivisible(q) )
    23302330    {
    23312331      if( __DEBUG__ )
    … …  
    23332333        PrintS("_FindReducer::Test LS: q is divisible by LS[?] !:((: ");
    23342334      }
    2335      
     2335
    23362336      continue;
    23372337    }
    23382338
    2339     p_SetCoeff0(q, n_Neg( n_Div( p_GetCoeff(product, r), p_GetCoeff(p, r), r), r), r);
     2339    p_SetCoeff0(q, n_InpNeg( n_Div( p_GetCoeff(product, r), p_GetCoeff(p, r), r), r), r);
    23402340    return q;
    23412341  }
    … …  
    23762376    }
    23772377
    2378     m_compute = true;   
     2378    m_compute = true;
    23792379  }
    23802380}
    … …  
    23852385  assume( m != NULL );
    23862386  if( m_compute && (m != NULL))
    2387   { 
     2387  {
    23882388    const ring& R = m_rBaseRing;
    23892389
    … …  
    24002400}
    24012401
    2402 CCacheCompare::CCacheCompare(): m_ring(currRing) {} 
     2402CCacheCompare::CCacheCompare(): m_ring(currRing) {}
    24032403
    24042404

  • Singular/eigenval_ip.cc

    r46c7c3 r984ff3  
    199199           pNext(pNext(e0->m[i]))==NULL)
    200200        {
    201           number e1=nNeg(nCopy(pGetCoeff(e0->m[i])));
     201          number e1=nInpNeg(nCopy(pGetCoeff(e0->m[i])));
    202202          if(pGetExp(pNext(e0->m[i]),1)==0)
    203203            e->m[k]=pNSet(nDiv(pGetCoeff(pNext(e0->m[i])),e1));

  • Singular/fevoices.h

    r46c7c3 r984ff3  
    1313
    1414#include <kernel/structs.h>
     15
     16enum   feBufferTypes
     17{
     18  BT_none  = 0,  // entry level
     19  BT_break = 1,  // while, for
     20  BT_proc,       // proc
     21  BT_example,    // example
     22  BT_file,       // <"file"
     23  BT_execute,    // execute
     24  BT_if,         // if
     25  BT_else        // else
     26};
    1527
    1628enum   feBufferInputs

  • Singular/fglm.cc

    r46c7c3 r984ff3  
    5353};
    5454
    55 // Has to be called, if currQuotient != NULL. ( i.e. qring-case )
     55// Has to be called, if currRing->qideal != NULL. ( i.e. qring-case )
    5656// Then a new ideal is build, consisting of the generators of sourceIdeal
    57 // and the generators of currQuotient, which are completely reduced by
     57// and the generators of currRing->qideal, which are completely reduced by
    5858// the sourceIdeal. This means: If sourceIdeal is reduced, then the new
    5959// ideal will be reduced as well.
    … …  
    6363    int k, l, offset;
    6464    BOOLEAN found;
    65     ideal newSource= idInit( IDELEMS( sourceIdeal ) + IDELEMS( currQuotient ), 1 );
     65    ideal newSource= idInit( IDELEMS( sourceIdeal ) + IDELEMS( currRing->qideal ), 1 );
    6666    for ( k= IDELEMS( sourceIdeal )-1; k >=0; k-- )
    6767        (newSource->m)[k]= pCopy( (sourceIdeal->m)[k] );
    6868    offset= IDELEMS( sourceIdeal );
    69     for ( l= IDELEMS( currQuotient )-1; l >= 0; l-- )
    70     {
    71         if ( (currQuotient->m)[l] != NULL )
     69    for ( l= IDELEMS( currRing->qideal )-1; l >= 0; l-- )
     70    {
     71        if ( (currRing->qideal->m)[l] != NULL )
    7272        {
    7373            found= FALSE;
    7474            for ( k= IDELEMS( sourceIdeal )-1; (k >= 0) && (found == FALSE); k-- )
    75                 if ( pDivisibleBy( (sourceIdeal->m)[k], (currQuotient->m)[l] ) )
     75                if ( pDivisibleBy( (sourceIdeal->m)[k], (currRing->qideal->m)[l] ) )
    7676                    found= TRUE;
    7777            if ( ! found )
    7878            {
    79                 (newSource->m)[offset]= pCopy( (currQuotient->m)[l] );
     79                (newSource->m)[offset]= pCopy( (currRing->qideal->m)[l] );
    8080                offset++;
    8181            }
    … …  
    8686}
    8787
    88 // Has to be called, if currQuotient != NULL, i.e. in qring-case.
     88// Has to be called, if currRing->qideal != NULL, i.e. in qring-case.
    8989// Gets rid of the elements of result which are contained in
    90 // currQuotient and skips Zeroes.
     90// currRing->qideal and skips Zeroes.
    9191// Assumes that currRing == destRing
    9292void
    … …  
    100100        {
    101101            found= FALSE;
    102             for ( l= IDELEMS( currQuotient )-1; (l >= 0) && ( found == FALSE ); l-- )
    103                 if ( pDivisibleBy( (currQuotient->m)[l], (result->m)[k] ) )
     102            for ( l= IDELEMS( currRing->qideal )-1; (l >= 0) && ( found == FALSE ); l-- )
     103                if ( pDivisibleBy( (currRing->qideal->m)[l], (result->m)[k] ) )
    104104                    found= TRUE;
    105105            if ( found ) pDelete( & ((result->m)[k]) );
    … …  
    302302        {
    303303            ideal sourceIdeal;
    304             if ( currQuotient != NULL )
     304            if ( currRing->qideal != NULL )
    305305                sourceIdeal= fglmUpdatesource( IDIDEAL( ih ) );
    306306            else
    … …  
    311311                // Now the settings are compatible with FGLM
    312312                assumeStdFlag( (leftv)ih );
    313                 if ( fglmzero( IDRING(sourceRingHdl), sourceIdeal, IDRING(destRingHdl), destIdeal, FALSE, (currQuotient != NULL) ) == FALSE )
     313                if ( fglmzero( IDRING(sourceRingHdl), sourceIdeal, IDRING(destRingHdl), destIdeal, FALSE, (currRing->qideal != NULL) ) == FALSE )
    314314                    state= FglmNotReduced;
    315315            }
    … …  
    321321    {
    322322        case FglmOk:
    323             if ( currQuotient != NULL ) fglmUpdateresult( destIdeal );
     323            if ( currRing->qideal != NULL ) fglmUpdateresult( destIdeal );
    324324            break;
    325325        case FglmHasOne:

  • Singular/grammar.cc

    r46c7c3 r984ff3  
    235235    Werror("leaving %s",VoiceName());
    236236  }
    237   // libfac:
    238   extern int libfac_interruptflag;
    239   libfac_interruptflag=0;
    240237}
    241238

  • Singular/grammar.y

    r46c7c3 r984ff3  
    171171    Werror("leaving %s",VoiceName());
    172172  }
    173   // libfac:
    174   extern int libfac_interruptflag;
    175   libfac_interruptflag=0;
    176173}
    177174

  • Singular/iparith.cc

    r46c7c3 r984ff3  
    19811981  }
    19821982#endif
    1983   if(currQuotient==NULL)
     1983  if(currRing->qideal==NULL)
    19841984    res->data = (char *)((long)scDimInt((ideal)(v->Data()),(ideal)w->Data()));
    19851985  else
    19861986  {
    1987     ideal q=idSimpleAdd(currQuotient,(ideal)w->Data());
     1987    ideal q=idSimpleAdd(currRing->qideal,(ideal)w->Data());
    19881988    res->data = (char *)((long)scDimInt((ideal)(v->Data()),q));
    19891989    idDelete(&q);
    … …  
    24082408    Print("//       performed for generic fibre, that is, over Q\n");
    24092409    intvec *module_w=(intvec*)atGet(&uuAsLeftv,"isHomog",INTVEC_CMD);
    2410     intvec *iv=hFirstSeries(uu,module_w,currQuotient);
     2410    intvec *iv=hFirstSeries(uu,module_w,currRing->qideal);
    24112411    int returnWithTrue = 1;
    24122412    switch((int)(long)v->Data())
    … …  
    24332433  assumeStdFlag(u);
    24342434  intvec *module_w=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
    2435   intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient);
     2435  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currRing->qideal);
    24362436  switch((int)(long)v->Data())
    24372437  {
    … …  
    24992499  kModW=w;
    25002500  pSetDegProcs(currRing,kHomModDeg);
    2501   res->data=(void *)(long)idHomModule(v_id,currQuotient,&w);
     2501  res->data=(void *)(long)idHomModule(v_id,currRing->qideal,&w);
    25022502  currRing->pLexOrder=save_pLexOrder;
    25032503  kHomW=NULL;
    … …  
    25112511  assumeStdFlag(u);
    25122512  res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(long)(v->Data()),
    2513                     currQuotient);
     2513                    currRing->qideal);
    25142514  return FALSE;
    25152515}
    … …  
    25582558  intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
    25592559  res->data = (char *)scKBase((int)(long)v->Data(),
    2560                               (ideal)(u->Data()),currQuotient, w_u);
     2560                              (ideal)(u->Data()),currRing->qideal, w_u);
    25612561  if (w_u!=NULL)
    25622562  {
    … …  
    26462646     else
    26472647     {
    2648        if ((!idTestHomModule(u_id,currQuotient,w_v))
    2649        || (!idTestHomModule(v_id,currQuotient,w_v)))
     2648       if ((!idTestHomModule(u_id,currRing->qideal,w_v))
     2649       || (!idTestHomModule(v_id,currRing->qideal,w_v)))
    26502650       {
    26512651         WarnS("wrong weights");
    … …  
    30003000{
    30013001  assumeStdFlag(v);
    3002   res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
     3002  res->data = (char *)kNF((ideal)v->Data(),currRing->qideal,(poly)u->Data());
    30033003  return FALSE;
    30043004}
    … …  
    30083008  ideal ui=(ideal)u->Data();
    30093009  ideal vi=(ideal)v->Data();
    3010   res->data = (char *)kNF(vi,currQuotient,ui);
     3010  res->data = (char *)kNF(vi,currRing->qideal,ui);
    30113011  return FALSE;
    30123012}
    … …  
    30313031  {
    30323032    maxl = currRing->N-1+2*(iiOp==MRES_CMD);
    3033     if (currQuotient!=NULL)
     3033    if (currRing->qideal!=NULL)
    30343034    {
    30353035      Warn(
    … …  
    30413041  if (weights!=NULL)
    30423042  {
    3043     if (!idTestHomModule(u_id,currQuotient,weights))
     3043    if (!idTestHomModule(u_id,currRing->qideal,weights))
    30443044    {
    30453045      WarnS("wrong weights given:");weights->show();PrintLn();
    … …  
    30563056  }
    30573057  else
    3058     idHomModule(u_id,currQuotient,&ww);
     3058    idHomModule(u_id,currRing->qideal,&ww);
    30593059  weights=ww;
    30603060
    … …  
    30693069  {
    30703070    int dummy;
    3071     if((currQuotient!=NULL)||
     3071    if((currRing->qideal!=NULL)||
    30723072    (!idHomIdeal (u_id,NULL)))
    30733073    {
    … …  
    30813081  {
    30823082    int dummy;
    3083     if((currQuotient!=NULL)||
     3083    if((currRing->qideal!=NULL)||
    30843084    (!idHomIdeal (u_id,NULL)))
    30853085    {
    … …  
    30933093  {
    30943094    int dummy;
    3095     if((currQuotient!=NULL)||
     3095    if((currRing->qideal!=NULL)||
    30963096    (!idHomIdeal (u_id,NULL)))
    30973097    {
    … …  
    31463146  {
    31473147    maxl = currRing->N-1+2*(iiOp==MRES_CMD);
    3148     if (currQuotient!=NULL)
     3148    if (currRing->qideal!=NULL)
    31493149    {
    31503150      Warn(
    … …  
    31563156  if (weights!=NULL)
    31573157  {
    3158     if (!idTestHomModule(u_id,currQuotient,weights))
     3158    if (!idTestHomModule(u_id,currRing->qideal,weights))
    31593159    {
    31603160      WarnS("wrong weights given:");weights->show();PrintLn();
    … …  
    31803180  {
    31813181    int dummy;
    3182     if((currQuotient!=NULL)||
     3182    if((currRing->qideal!=NULL)||
    31833183    (!idHomIdeal (u_id,NULL)))
    31843184    {
    … …  
    31943194  {
    31953195    int dummy;
    3196     if((currQuotient!=NULL)||
     3196    if((currRing->qideal!=NULL)||
    31973197    (!idHomIdeal (u_id,NULL)))
    31983198    {
    … …  
    32063206  {
    32073207    int dummy;
    3208     if((currQuotient!=NULL)||
     3208    if((currRing->qideal!=NULL)||
    32093209    (!idHomIdeal (u_id,NULL)))
    32103210    {
    … …  
    33993399  if (w!=NULL)
    34003400  {
    3401     if (!idTestHomModule(u_id,currQuotient,w))
     3401    if (!idTestHomModule(u_id,currRing->qideal,w))
    34023402    {
    34033403      WarnS("wrong weights:");w->show();PrintLn();
    … …  
    34103410    }
    34113411  }
    3412   result=kStd(u_id,currQuotient,hom,&w,(intvec *)v->Data());
     3412  result=kStd(u_id,currRing->qideal,hom,&w,(intvec *)v->Data());
    34133413  idSkipZeroes(result);
    34143414  res->data = (char *)result;
    … …  
    34793479    if (w!=NULL)
    34803480    {
    3481       if (!idTestHomModule(i1,currQuotient,w))
     3481      if (!idTestHomModule(i1,currRing->qideal,w))
    34823482      {
    34833483        // no warnung: this is legal, if i in std(i,p)
    … …  
    34963496    /* ii0 appears to be the position of the first element of il that
    34973497       does not belong to the old SB ideal */
    3498     result=kStd(i1,currQuotient,hom,&w,NULL,0,ii0);
     3498    result=kStd(i1,currRing->qideal,hom,&w,NULL,0,ii0);
    34993499    SI_RESTORE_OPT1(save1);
    35003500    idDelete(&i1);
    … …  
    36483648{
    36493649  number n=(number)u->CopyD(BIGINT_CMD);
    3650   n=n_Neg(n,coeffs_BIGINT);
     3650  n=n_InpNeg(n,coeffs_BIGINT);
    36513651  res->data = (char *)n;
    36523652  return FALSE;
    … …  
    36603660{
    36613661  number n=(number)u->CopyD(NUMBER_CMD);
    3662   n=nNeg(n);
     3662  n=nInpNeg(n);
    36633663  res->data = (char *)n;
    36643664  return FALSE;
    … …  
    38603860    Print("//       generic fibre, that is, over Q\n");
    38613861    intvec *module_w=(intvec*)atGet(&vvAsLeftv,"isHomog",INTVEC_CMD);
    3862     scDegree(vv,module_w,currQuotient);
     3862    scDegree(vv,module_w,currRing->qideal);
    38633863    idDelete(&vv);
    38643864    rChangeCurrRing(origR);
    … …  
    38683868  assumeStdFlag(v);
    38693869  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
    3870   scDegree((ideal)v->Data(),module_w,currQuotient);
     3870  scDegree((ideal)v->Data(),module_w,currRing->qideal);
    38713871  char *s=SPrintEnd();
    38723872  int l=strlen(s)-1;
    … …  
    39873987    /* drop degree zero generator from vv (if any) */
    39883988    if (i != -1) pDelete(&vv->m[i]);
    3989     long d = (long)scDimInt(vv, currQuotient);
     3989    long d = (long)scDimInt(vv, currRing->qideal);
    39903990    if (rField_is_Ring_Z(currRing) && (i == -1)) d++;
    39913991    res->data = (char *)d;
    … …  
    39963996  }
    39973997#endif
    3998   res->data = (char *)(long)scDimInt((ideal)(v->Data()),currQuotient);
     3998  res->data = (char *)(long)scDimInt((ideal)(v->Data()),currRing->qideal);
    39993999  return FALSE;
    40004000}
    … …  
    41804180    Print("//       performed for generic fibre, that is, over Q\n");
    41814181    intvec *module_w=(intvec*)atGet(&vvAsLeftv,"isHomog",INTVEC_CMD);
    4182     //scHilbertPoly(vv,currQuotient);
    4183     hLookSeries(vv,module_w,currQuotient);
     4182    //scHilbertPoly(vv,currRing->qideal);
     4183    hLookSeries(vv,module_w,currRing->qideal);
    41844184    idDelete(&vv);
    41854185    rChangeCurrRing(origR);
    … …  
    41904190  assumeStdFlag(v);
    41914191  intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
    4192   //scHilbertPoly((ideal)v->Data(),currQuotient);
    4193   hLookSeries((ideal)v->Data(),module_w,currQuotient);
     4192  //scHilbertPoly((ideal)v->Data(),currRing->qideal);
     4193  hLookSeries((ideal)v->Data(),module_w,currRing->qideal);
    41944194  return FALSE;
    41954195}
    … …  
    42124212  if (w==NULL)
    42134213  {
    4214     res->data=(void *)(long)idHomModule(v_id,currQuotient,&w);
     4214    res->data=(void *)(long)idHomModule(v_id,currRing->qideal,&w);
    42154215    if (res->data!=NULL)
    42164216    {
    … …  
    42284228  else
    42294229  {
    4230     res->data=(void *)(long)idTestHomModule(v_id,currQuotient,w);
     4230    res->data=(void *)(long)idTestHomModule(v_id,currRing->qideal,w);
    42314231    if((res->data==NULL) && (v->rtyp==IDHDL))
    42324232    {
    … …  
    43054305{
    43064306  assumeStdFlag(v);
    4307   res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
     4307  res->data=(void *)scIndIntvec((ideal)(v->Data()),currRing->qideal);
    43084308  return FALSE;
    43094309}
    43104310static BOOLEAN jjINTERRED(leftv res, leftv v)
    43114311{
    4312   ideal result=kInterRed((ideal)(v->Data()), currQuotient);
     4312  ideal result=kInterRed((ideal)(v->Data()), currRing->qideal);
    43134313  #ifdef HAVE_RINGS
    43144314  if(rField_is_Ring(currRing))
    … …  
    43914391{
    43924392  assumeStdFlag(v);
    4393   res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
     4393  res->data = (char *)scKBase(-1,(ideal)(v->Data()),currRing->qideal);
    43944394  return FALSE;
    43954395}
    … …  
    45724572  int t=v->Typ();
    45734573  ideal r,m;
    4574   r=kMin_std((ideal)v->Data(),currQuotient,testHomog,NULL,m);
     4574  r=kMin_std((ideal)v->Data(),currRing->qideal,testHomog,NULL,m);
    45754575  lists l=(lists)omAllocBin(slists_bin);
    45764576  l->Init(2);
    … …  
    45864586{
    45874587  assumeStdFlag(v);
    4588   res->data = (char *)(long)scMultInt((ideal)(v->Data()),currQuotient);
     4588  res->data = (char *)(long)scMultInt((ideal)(v->Data()),currRing->qideal);
    45894589  return FALSE;
    45904590}
    … …  
    47444744  if (w!=NULL)
    47454745  {
    4746     if (!idTestHomModule(v_id,currQuotient,w))
     4746    if (!idTestHomModule(v_id,currRing->qideal,w))
    47474747    {
    47484748      WarnS("wrong weights");
    … …  
    48514851#endif
    48524852
    4853   if ((currQuotient!=NULL) && !bIsSCA)
     4853  if ((currRing->qideal!=NULL) && !bIsSCA)
    48544854  {
    48554855    WerrorS("qring not supported by slimgb at the moment");
    … …  
    48664866  if (w!=NULL)
    48674867  {
    4868     if (!idTestHomModule(u_id,currQuotient,w))
     4868    if (!idTestHomModule(u_id,currRing->qideal,w))
    48694869    {
    48704870      WarnS("wrong weights");
    … …  
    48954895  if (w!=NULL)
    48964896  {
    4897     if (!idTestHomModule(v_id,currQuotient,w))
     4897    if (!idTestHomModule(v_id,currRing->qideal,w))
    48984898    {
    48994899      WarnS("wrong weights");
    … …  
    49064906    }
    49074907  }
    4908   result=kSba(v_id,currQuotient,hom,&w,1,0);
     4908  result=kSba(v_id,currRing->qideal,hom,&w,1,0);
    49094909  idSkipZeroes(result);
    49104910  res->data = (char *)result;
    … …  
    49214921  if (w!=NULL)
    49224922  {
    4923     if (!idTestHomModule(v_id,currQuotient,w))
     4923    if (!idTestHomModule(v_id,currRing->qideal,w))
    49244924    {
    49254925      WarnS("wrong weights");
    … …  
    49324932    }
    49334933  }
    4934   result=kSba(v_id,currQuotient,hom,&w,(int)(long)u->Data(),0);
     4934  result=kSba(v_id,currRing->qideal,hom,&w,(int)(long)u->Data(),0);
    49354935  idSkipZeroes(result);
    49364936  res->data = (char *)result;
    … …  
    49474947  if (w!=NULL)
    49484948  {
    4949     if (!idTestHomModule(v_id,currQuotient,w))
     4949    if (!idTestHomModule(v_id,currRing->qideal,w))
    49504950    {
    49514951      WarnS("wrong weights");
    … …  
    49584958    }
    49594959  }
    4960   result=kSba(v_id,currQuotient,hom,&w,(int)(long)u->Data(),(int)(long)t->Data());
     4960  result=kSba(v_id,currRing->qideal,hom,&w,(int)(long)u->Data(),(int)(long)t->Data());
    49614961  idSkipZeroes(result);
    49624962  res->data = (char *)result;
    … …  
    49734973  if (w!=NULL)
    49744974  {
    4975     if (!idTestHomModule(v_id,currQuotient,w))
     4975    if (!idTestHomModule(v_id,currRing->qideal,w))
    49764976    {
    49774977      WarnS("wrong weights");
    … …  
    49844984    }
    49854985  }
    4986   result=kStd(v_id,currQuotient,hom,&w);
     4986  result=kStd(v_id,currRing->qideal,hom,&w);
    49874987  idSkipZeroes(result);
    49884988  res->data = (char *)result;
    … …  
    50345034    add_row_shift=w->min_in();
    50355035    (*w)-=add_row_shift;
    5036     if (idTestHomModule(v_id,currQuotient,w))
     5036    if (idTestHomModule(v_id,currRing->qideal,w))
    50375037      hom=isHomog;
    50385038    else
    … …  
    51965196{
    51975197  assumeStdFlag(v);
    5198   res->data = (char *)(long)scMult0Int((ideal)v->Data(),currQuotient);
     5198  res->data = (char *)(long)scMult0Int((ideal)v->Data(),currRing->qideal);
    51995199  return FALSE;
    52005200}
    … …  
    59085908    Print("//       performed for generic fibre, that is, over Q\n");
    59095909    intvec *module_w=(intvec*)atGet(&uuAsLeftv,"isHomog",INTVEC_CMD);
    5910     intvec *iv=hFirstSeries(uu,module_w,currQuotient,wdegree);
     5910    intvec *iv=hFirstSeries(uu,module_w,currRing->qideal,wdegree);
    59115911    int returnWithTrue = 1;
    59125912    switch((int)(long)v->Data())
    … …  
    59335933  assumeStdFlag(u);
    59345934  intvec *module_w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
    5935   intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
     5935  intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currRing->qideal,wdegree);
    59365936  switch((int)(long)v->Data())
    59375937  {
    … …  
    65536553{
    65546554  assumeStdFlag(v);
    6555   res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data(),
     6555  res->data = (char *)kNF((ideal)v->Data(),currRing->qideal,(poly)u->Data(),
    65566556    0,(int)(long)w->Data());
    65576557  return FALSE;
    … …  
    65606560{
    65616561  assumeStdFlag(v);
    6562   res->data = (char *)kNF((ideal)v->Data(),currQuotient,(ideal)u->Data(),
     6562  res->data = (char *)kNF((ideal)v->Data(),currRing->qideal,(ideal)u->Data(),
    65636563    0,(int)(long)w->Data());
    65646564  return FALSE;
    … …  
    65826582    {
    65836583      l=1;
    6584       if (!idTestHomModule(u_id,currQuotient,iv))
     6584      if (!idTestHomModule(u_id,currRing->qideal,iv))
    65856585      {
    65866586        WarnS("wrong weights");
    … …  
    66316631  if (ww!=NULL)
    66326632  {
    6633     if (!idTestHomModule(u_id,currQuotient,ww))
     6633    if (!idTestHomModule(u_id,currRing->qideal,ww))
    66346634    {
    66356635      WarnS("wrong weights");
    … …  
    66436643  }
    66446644  result=kStd(u_id,
    6645               currQuotient,
     6645              currRing->qideal,
    66466646              hom,
    66476647              &ww,                  // module weights
    … …  
    77597759  if (ww!=NULL)
    77607760  {
    7761     if (!idTestHomModule(i1,currQuotient,ww))
     7761    if (!idTestHomModule(i1,currRing->qideal,ww))
    77627762    {
    77637763      WarnS("wrong weights");
    … …  
    77747774  si_opt_1|=Sy_bit(OPT_SB_1);
    77757775  result=kStd(i1,
    7776               currQuotient,
     7776              currRing->qideal,
    77777777              hom,
    77787778              &ww,                  // module weights

  • Singular/ipassign.cc

    r46c7c3 r984ff3  
    471471    res->data=(void*)p;
    472472    jiAssignAttr(res,a);
    473     if (TEST_V_QRING && (currQuotient!=NULL) && (!hasFlag(res,FLAG_QRING))) jjNormalizeQRingP(res);
     473    if (TEST_V_QRING && (currRing->qideal!=NULL) && (!hasFlag(res,FLAG_QRING))) jjNormalizeQRingP(res);
    474474  }
    475475  else
    … …  
    643643    setFlag(res,FLAG_STD);
    644644  }
    645   if (TEST_V_QRING && (currQuotient!=NULL)&& (!hasFlag(res,FLAG_QRING))) jjNormalizeQRingId(res);
     645  if (TEST_V_QRING && (currRing->qideal!=NULL)&& (!hasFlag(res,FLAG_QRING))) jjNormalizeQRingId(res);
    646646  return FALSE;
    647647}
    … …  
    661661  pNormalize(I->m[0]);
    662662  res->data=(void *)I;
    663   if (TEST_V_QRING && (currQuotient!=NULL))
     663  if (TEST_V_QRING && (currRing->qideal!=NULL))
    664664  {
    665665    if (hasFlag(a,FLAG_QRING)) setFlag(res,FLAG_QRING);
    … …  
    677677  id_Normalize((ideal)m, currRing);
    678678  res->data=(void *)m;
    679   if (TEST_V_QRING && (currQuotient!=NULL)) jjNormalizeQRingId(res);
     679  if (TEST_V_QRING && (currRing->qideal!=NULL)) jjNormalizeQRingId(res);
    680680  return FALSE;
    681681}
    … …  
    11721172  l1->CleanUp();
    11731173  r->CleanUp();
    1174   //if (TEST_V_QRING && (currQuotient!=NULL)) jjNormalizeQRingP(l);
     1174  //if (TEST_V_QRING && (currRing->qideal!=NULL)) jjNormalizeQRingP(l);
    11751175  return FALSE;
    11761176}
    … …  
    19091909void jjNormalizeQRingId(leftv I)
    19101910{
    1911   if ((currQuotient!=NULL) && (!hasFlag(I,FLAG_QRING)))
     1911  if ((currRing->qideal!=NULL) && (!hasFlag(I,FLAG_QRING)))
    19121912  {
    19131913    if (I->e==NULL)
    … …  
    19201920        {
    19211921          ideal F=idInit(1,1);
    1922           ideal II=kNF(F,currQuotient,I0);
     1922          ideal II=kNF(F,currRing->qideal,I0);
    19231923          idDelete(&F);
    19241924          if (I->rtyp!=IDHDL)
    … …  
    19441944void jjNormalizeQRingP(leftv I)
    19451945{
    1946   if ((currQuotient!=NULL) && (!hasFlag(I,FLAG_QRING)))
     1946  if ((currRing->qideal!=NULL) && (!hasFlag(I,FLAG_QRING)))
    19471947  {
    19481948    poly p=(poly)I->Data();
    … …  
    19501950    {
    19511951      ideal F=idInit(1,1);
    1952       poly II=kNF(F,currQuotient,p);
     1952      poly II=kNF(F,currRing->qideal,p);
    19531953      idDelete(&F);
    19541954      if ((I->rtyp==POLY_CMD)

  • Singular/ipid.h

    r46c7c3 r984ff3  
    9090
    9191/*extern ring     currRing;  in ring.h */
    92 /*extern ideal      currQuotient; in structs.h */
    9392
    9493idhdl enterid(const char * a, int lev, int t, idhdl* root, BOOLEAN init=TRUE, BOOLEAN serach=TRUE);

  • Singular/ipshell.cc

    r46c7c3 r984ff3  
    14631463  if (rHasLocalOrMixedOrdering_currRing())
    14641464  {
    1465     scComputeHC(I,currQuotient,ak,po);
     1465    scComputeHC(I,currRing->qideal,ak,po);
    14661466    if (po!=NULL)
    14671467    {
    … …  
    34443444  #endif
    34453445
    3446   ideal stdJ = kStd(J,currQuotient,isNotHomog,NULL);
     3446  ideal stdJ = kStd(J,currRing->qideal,isNotHomog,NULL);
    34473447  idSkipZeroes( stdJ );
    34483448
    … …  
    35113511  poly hc = (poly)NULL;
    35123512
    3513   scComputeHC( stdJ,currQuotient, 0,hc );
     3513  scComputeHC( stdJ,currRing->qideal, 0,hc );
    35143514
    35153515  if( hc!=(poly)NULL )
    … …  
    55555555    {
    55565556      // all dependend stuff is done, clean global vars:
    5557       if (r->qideal!=NULL)
    5558       {
    5559         currQuotient=NULL;
    5560       }
    55615557      if ((currRing->ppNoether)!=NULL) pDelete(&(currRing->ppNoether));
    55625558      if (sLastPrinted.RingDependend())

  • Singular/ipshell.h

    r46c7c3 r984ff3  
    1111#include <kernel/ideals.h>
    1212#include <Singular/lists.h>
     13#include <Singular/fevoices.h>
    1314
    1415struct _ssubexpr;

  • Singular/libsingular.h

    r46c7c3 r984ff3  
    99#include <coeffs/numbers.h>
    1010#include <coeffs/longrat.h>
    11 #include <kernel/oswrapper/febase.h>
     11#include <kernel/oswrapper/feread.h>
    1212#include <polys/monomials/ring.h>
    1313#include <omalloc/omalloc.h>

  • Singular/links/ssiLink.cc

    r46c7c3 r984ff3  
    5757#include <time.h>
    5858
    59 #define SSI_VERSION 7
     59#define SSI_VERSION 8
    6060// 5->6: changed newstruct representation
    6161// 6->7: attributes
     62// 7->8: qring
    6263
    6364// 64 bit version:
    … …  
    9192volatile BOOLEAN ssiToBeClosed_inactive=TRUE;
    9293
     94// forward declarations:
     95void ssiWritePoly_R(const ssiInfo *d, int typ, poly p, const ring r);
     96void ssiWriteIdeal(const ssiInfo *d, int typ,ideal I);
     97poly ssiReadPoly_R(const ssiInfo *D, const ring r);
     98ideal ssiReadIdeal_R(const ssiInfo *d,const ring r);
     99
    93100// the helper functions:
    94101void ssiSetCurrRing(const ring r)
    95102{
     103  //  if (currRing!=NULL)
     104  //  Print("need to change the ring, currRing:%s, switch to: ssiRing%d\n",IDID(currRingHdl,nr);
     105  //  else
     106  //  Print("no ring, switch to ssiRing%d\n",nr);
    96107  if (!rEqual(r,currRing,1))
    97108  {
    … …  
    108119}
    109120// the implementation of the functions:
    110 void ssiWriteInt(ssiInfo *d,const int i)
     121void ssiWriteInt(const ssiInfo *d,const int i)
    111122{
    112123  fprintf(d->f_write,"%d ",i);
    … …  
    114125}
    115126
    116 void ssiWriteString(ssiInfo *d,const char *s)
     127void ssiWriteString(const ssiInfo *d,const char *s)
    117128{
    118129  fprintf(d->f_write,"%d %s ",(int)strlen(s),s);
    119130  //if (d->f_debug!=NULL) fprintf(d->f_debug,"stringi: %d \"%s\" ",strlen(s),s);
    120131}
    121 
    122132
    123133void ssiWriteBigInt(const ssiInfo *d, const number n)
    … …  
    142152}
    143153
    144 void ssiWritePoly_R(const ssiInfo *d, int typ, poly p, const ring r);
    145154void ssiWriteNumber_CF(const ssiInfo *d, const number n, const coeffs cf)
    146155{
    … …  
    176185}
    177186
    178 void ssiWriteRing(ssiInfo *d,const ring r)
    179 {
    180   /* 5 <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... */
     187void ssiWriteRing_R(ssiInfo *d,const ring r)
     188{
     189  /* 5 <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... <extRing> <Q-ideal> */
    181190  /* ch=-1: transext, coeff ring follows */
    182191  /* ch=-2: algext, coeff ring and minpoly follows */
    183   if (r==currRing) // see recursive calls for transExt/algExt
    184   {
    185     if (d->r!=NULL) rKill(d->r);
    186     d->r=r;
    187   }
    188192  if (r!=NULL)
    189193  {
    190     /*d->*/r->ref++;
    191194    if (rField_is_Q(r) || rField_is_Zp(r))
    192195      fprintf(d->f_write,"%d %d ",n_GetChar(r->cf),r->N);
    … …  
    242245    || (rFieldType(r)==n_algExt))
    243246    {
    244       ssiWriteRing(d,r->cf->extRing);
     247      ssiWriteRing_R(d,r->cf->extRing);
    245248      if  (rFieldType(r)==n_algExt)
    246249      {
    … …  
    248251      }
    249252    }
     253    /* Q-ideal :*/
     254    if (r->qideal!=NULL)
     255    {
     256      ssiWriteIdeal(d,IDEAL_CMD,r->qideal);
     257    }
     258    else
     259    {
     260      fprintf(d->f_write,"0 "/*ideal with 0 entries */);
     261    }
    250262  }
    251263  else /* dummy ring r==NULL*/
    252264  {
    253     fprintf(d->f_write,"0 0 0 "/*,r->ch,r->N, blocks*/);
    254   }
    255 }
    256 
     265    fprintf(d->f_write,"0 0 0 0 "/*,r->ch,r->N, blocks, q-ideal*/);
     266  }
     267}
     268
     269void ssiWriteRing(ssiInfo *d,const ring r)
     270{
     271  /* 5 <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... <extRing> <Q-ideal> */
     272  /* ch=-1: transext, coeff ring follows */
     273  /* ch=-2: algext, coeff ring and minpoly follows */
     274  if (r==currRing) // see recursive calls for transExt/algExt
     275  {
     276    if (d->r!=NULL) rKill(d->r);
     277    d->r=r;
     278  }
     279  if (r!=NULL)
     280  {
     281    /*d->*/r->ref++;
     282  }
     283  ssiWriteRing_R(d,r);
     284}
    257285void ssiWritePoly_R(const ssiInfo *d, int typ, poly p, const ring r)
    258286{
    259287  fprintf(d->f_write,"%d ",pLength(p));//number of terms
    260   int i;
    261288
    262289  while(p!=NULL)
    … …  
    279306}
    280307
    281 void ssiWriteIdeal(ssiInfo *d, int typ,ideal I)
     308void ssiWriteIdeal(const ssiInfo *d, int typ,ideal I)
    282309{
    283310   // syntax: 7 # of elements <poly 1> <poly2>.....
    … …  
    320347}
    321348
    322 void ssiWriteProc(ssiInfo *d,procinfov p)
     349void ssiWriteProc(const ssiInfo *d,procinfov p)
    323350{
    324351  if (p->data.s.body==NULL)
    … …  
    341368  }
    342369}
    343 void ssiWriteIntvec(ssiInfo *d,intvec * v)
     370void ssiWriteIntvec(const ssiInfo *d,intvec * v)
    344371{
    345372  fprintf(d->f_write,"%d ",v->length());
    … …  
    350377  }
    351378}
    352 void ssiWriteIntmat(ssiInfo *d,intvec * v)
     379void ssiWriteIntmat(const ssiInfo *d,intvec * v)
    353380{
    354381  fprintf(d->f_write,"%d %d ",v->rows(),v->cols());
    … …  
    360387}
    361388
    362 void ssiWriteBigintmat(ssiInfo *d,bigintmat * v)
     389void ssiWriteBigintmat(const ssiInfo *d,bigintmat * v)
    363390{
    364391  fprintf(d->f_write,"%d %d ",v->rows(),v->cols());
    … …  
    370397}
    371398
    372 char *ssiReadString(ssiInfo *d)
     399char *ssiReadString(const ssiInfo *d)
    373400{
    374401  char *buf;
    … …  
    388415}
    389416
    390 number ssiReadBigInt(ssiInfo *d)
     417number ssiReadBigInt(const ssiInfo *d)
    391418{
    392419  int sub_type=-1;
    … …  
    413440}
    414441
    415 static number ssiReadQNumber(ssiInfo *d)
    416 {
    417   int sub_type=-1;
    418   sub_type=s_readint(d->f_read);
    419   switch(sub_type)
    420   {
    421      case 0:
    422      case 1:
    423        {// read mpz_t, mpz_t
    424          number n=nlRInit(0);
    425          mpz_init(n->n);
    426          s_readmpz(d->f_read,n->z);
    427          s_readmpz(d->f_read,n->n);
    428          n->s=sub_type;
    429          return n;
    430        }
    431 
    432      case 3:
    433        {// read mpz_t
    434          number n=nlRInit(0);
    435          s_readmpz(d->f_read,n->z);
    436          n->s=3; /*sub_type*/
    437          return n;
    438        }
    439      case 4:
    440        {
    441          LONG dd=s_readlong(d->f_read);
    442          //#if SIZEOF_LONG == 8
    443          return INT_TO_SR(dd);
    444          //#else
    445          //return nlInit(dd,NULL);
    446          //#endif
    447        }
    448      case 5:
    449      case 6:
    450        {// read raw mpz_t, mpz_t
    451          number n=nlRInit(0);
    452          mpz_init(n->n);
    453          s_readmpz_base (d->f_read,n->z, SSI_BASE);
    454          s_readmpz_base (d->f_read,n->n, SSI_BASE);
    455          n->s=sub_type-5;
    456          return n;
    457        }
    458      case 8:
    459        {// read raw mpz_t
    460          number n=nlRInit(0);
    461          s_readmpz_base (d->f_read,n->z, SSI_BASE);
    462          n->s=sub_type=3; /*subtype-5*/
    463          return n;
    464        }
    465 
    466      default: Werror("error in reading number: invalid subtype %d",sub_type);
    467               return NULL;
    468   }
    469   return NULL;
    470 }
    471 
    472 poly ssiReadPoly_R(ssiInfo *D, const ring r);
    473 number ssiReadNumber_CF(ssiInfo *d, const coeffs cf)
     442number ssiReadNumber_CF(const ssiInfo *d, const coeffs cf)
    474443{
    475444  if (cf->cfReadFd!=NULL)
    … …  
    495464}
    496465
    497 number ssiReadNumber(ssiInfo *d)
     466number ssiReadNumber(const ssiInfo *d)
    498467{
    499468  return ssiReadNumber_CF(d,d->r->cf);
    500469}
    501470
    502 ring ssiReadRing(ssiInfo *d)
    503 {
    504 /* syntax is <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... */
    505   int ch, N,i,l;
     471ring ssiReadRing(const ssiInfo *d)
     472{
     473/* syntax is <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... <Q-ideal> */
     474  int ch, N,i;
    506475  char **names;
    507476  ch=s_readint(d->f_read);
    … …  
    561530    return NULL;
    562531  }
    563   else if (ch>=0) /* Q, Z/p */
    564     return rDefault(ch,N,names,num_ord,ord,block0,block1,wvhdl);
    565   else if (ch==-1) /* trans ext. */
    566   {
    567     TransExtInfo T;
    568     T.r=ssiReadRing(d);
    569     coeffs cf=nInitChar(n_transExt,&T);
    570     return rDefault(cf,N,names,num_ord,ord,block0,block1,wvhdl);
    571   }
    572   else if (ch==-2) /* alg ext. */
    573   {
    574     TransExtInfo T;
    575     T.r=ssiReadRing(d);
    576     T.r->qideal=idInit(1,1);
    577     T.r->qideal->m[0]=ssiReadPoly_R(d,T.r);
    578     coeffs cf=nInitChar(n_algExt,&T);
    579     return rDefault(cf,N,names,num_ord,ord,block0,block1,wvhdl);
    580   }
    581532  else
    582533  {
    583     Werror("ssi: read unknown coeffs type (%d)",ch);
    584     return NULL;
    585   }
    586 }
    587 
    588 poly ssiReadPoly_R(ssiInfo *D, const ring r)
     534    ring r=NULL;
     535    if (ch>=0) /* Q, Z/p */
     536      r=rDefault(ch,N,names,num_ord,ord,block0,block1,wvhdl);
     537    else if (ch==-1) /* trans ext. */
     538    {
     539      TransExtInfo T;
     540      T.r=ssiReadRing(d);
     541      coeffs cf=nInitChar(n_transExt,&T);
     542      r=rDefault(cf,N,names,num_ord,ord,block0,block1,wvhdl);
     543    }
     544    else if (ch==-2) /* alg ext. */
     545    {
     546      TransExtInfo T;
     547      T.r=ssiReadRing(d);
     548      T.r->qideal=idInit(1,1);
     549      T.r->qideal->m[0]=ssiReadPoly_R(d,T.r);
     550      coeffs cf=nInitChar(n_algExt,&T);
     551      r=rDefault(cf,N,names,num_ord,ord,block0,block1,wvhdl);
     552    }
     553    else
     554    {
     555      Werror("ssi: read unknown coeffs type (%d)",ch);
     556      return NULL;
     557    }
     558    ideal q=ssiReadIdeal_R(d,r);
     559    if (IDELEMS(q)==0) omFreeBin(q,sip_sideal_bin);
     560    else r->qideal=q;
     561    return r;
     562  }
     563}
     564
     565poly ssiReadPoly_R(const ssiInfo *D, const ring r)
    589566{
    590567// < # of terms> < term1> < .....
    … …  
    593570  //Print("poly: terms:%d\n",n);
    594571  poly p;
    595   int j;
    596   j=0;
    597572  poly ret=NULL;
    598573  poly prev=NULL;
    … …  
    619594}
    620595
    621 poly ssiReadPoly(ssiInfo *D)
     596poly ssiReadPoly(const ssiInfo *D)
    622597{
    623598// < # of terms> < term1> < .....
    … …  
    625600}
    626601
    627 ideal ssiReadIdeal(ssiInfo *d)
     602ideal ssiReadIdeal_R(const ssiInfo *d,const ring r)
    628603{
    629604  int n,i;
    … …  
    633608  for(i=0;i<IDELEMS(I);i++) // read n terms
    634609  {
    635     I->m [i]=ssiReadPoly(d);
     610    I->m [i]=ssiReadPoly_R(d,r);
    636611  }
    637612  return I;
    638613}
    639614
    640 matrix ssiReadMatrix(ssiInfo *d)
    641 {
    642   int n,m,i,j;
     615ideal ssiReadIdeal(const ssiInfo *d)
     616{
     617  return ssiReadIdeal_R(d,d->r);
     618}
     619
     620matrix ssiReadMatrix(const ssiInfo *d)
     621{
     622  int n,m;
    643623  m=s_readint(d->f_read);
    644624  n=s_readint(d->f_read);
    … …  
    700680}
    701681
    702 procinfov ssiReadProc(ssiInfo *d)
     682procinfov ssiReadProc(const ssiInfo *d)
    703683{
    704684  char *s=ssiReadString(d);
    … …  
    728708  return L;
    729709}
    730 intvec* ssiReadIntvec(ssiInfo *d)
     710intvec* ssiReadIntvec(const ssiInfo *d)
    731711{
    732712  int nr;
    … …  
    739719  return v;
    740720}
    741 intvec* ssiReadIntmat(ssiInfo *d)
     721intvec* ssiReadIntmat(const ssiInfo *d)
    742722{
    743723  int r,c;
    … …  
    751731  return v;
    752732}
    753 bigintmat* ssiReadBigintmat(ssiInfo *d)
     733bigintmat* ssiReadBigintmat(const ssiInfo *d)
    754734{
    755735  int r,c;
    … …  
    889869          d->fd_read=pc[0];
    890870          d->fd_write=cp[1];
    891           //d->r=currRing;
    892           //if (d->r!=NULL) d->r->ref++;
     871          //d->r=currRing;
     872          //if (d->r!=NULL) d->r->ref++;
    893873          l->data=d;
    894874          omFree(l->mode);
    … …  
    928908          SI_LINK_SET_RW_OPEN_P(l);
    929909          d->send_quit_at_exit=1;
    930           //d->r=currRing;
    931           //if (d->r!=NULL) d->r->ref++;
     910          //d->r=currRing;
     911          //if (d->r!=NULL) d->r->ref++;
    932912        }
    933913        else
    … …  
    944924        int sockfd, newsockfd, portno, clilen;
    945925        struct sockaddr_in serv_addr, cli_addr;
    946         int n;
    947926        sockfd = socket(AF_INET, SOCK_STREAM, 0);
    948927        if(sockfd < 0)
    … …  
    1005984        int sockfd, newsockfd, portno, clilen;
    1006985        struct sockaddr_in serv_addr, cli_addr;
    1007         int n;
    1008986        sockfd = socket(AF_INET, SOCK_STREAM, 0);
    1009987        if(sockfd < 0)
    … …  
    10881066      {
    10891067        char* host = (char*)omAlloc(256);
    1090         int sockfd, portno, n;
     1068        int sockfd, portno;
    10911069        struct sockaddr_in serv_addr;
    10921070        struct hostent *server;
    … …  
    12961274    case 5:{
    12971275             d->r=ssiReadRing(d);
    1298              res->rtyp=RING_CMD;
    12991276             res->data=(char*)d->r;
     1277             if (d->r->qideal==NULL)
     1278               res->rtyp=RING_CMD;
     1279             else
     1280               res->rtyp=QRING_CMD;
    13001281             // we are in the top-level, so set the basering to d->r:
    13011282             if (d->r!=NULL)
    … …  
    13981379             break;
    13991380  }
     1381  // if currRing is required for the result, but lost
     1382  // define "ssiRing%d" as currRing:
     1383  if ((d->r!=NULL)
     1384  && (currRing!=d->r)
     1385  && (res->RingDependend()))
     1386  {
     1387    ssiSetCurrRing(d->r);
     1388  }
    14001389  return res;
    14011390no_ring: WerrorS("no ring");
    … …  
    14701459                          ssiWriteNumber(d,(number)dd);
    14711460                        break;
     1461          case QRING_CMD:
    14721462          case RING_CMD:fputs("5 ",d->f_write);
    14731463                        ssiWriteRing(d,(ring)dd);
    … …  
    15781568  && (strcmp(request, "read") == 0))
    15791569  {
    1580     fd_set  mask, fdmask;
     1570    fd_set  mask;
    15811571    struct timeval wt;
    15821572    if (s_isready(d->f_read)) return "ready";
    … …  
    18381828  }
    18391829  int portno;
    1840   int n;
    18411830  ssiReserved_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    18421831  if(ssiReserved_sockfd < 0)

  • Singular/newstruct.cc

    r46c7c3 r984ff3  
    388388                Werror("different ring %lx(data) - %lx(basering)",
    389389                  (long unsigned)(al->m[nm->pos-1].data),(long unsigned)currRing);
     390                Werror("name of basering: %s",IDID(currRingHdl));
     391                rWrite(currRing,TRUE);PrintLn();
     392                idhdl hh=rFindHdl((ring)(al->m[nm->pos-1].data),NULL);
     393                const char *nn="??";
     394                if (hh!=NULL) nn=IDID(hh);
     395                Werror("(possible) name of ring of data: %s",nn);
     396                rWrite((ring)(al->m[nm->pos-1].data),TRUE);PrintLn();
     397
    390398                return TRUE;
    391399              }

  • Singular/subexpr.cc

    r46c7c3 r984ff3  
    139139        case MODUL_CMD:
    140140        case IDEAL_CMD:
    141           if ((TEST_V_QRING)  &&(currQuotient!=NULL)
     141          if ((TEST_V_QRING)  &&(currRing->qideal!=NULL)
    142142          &&(!hasFlag(this,FLAG_QRING)))
    143143          {
    … …  
    151151        case POLY_CMD:
    152152        case VECTOR_CMD:
    153           if ((TEST_V_QRING)  &&(currQuotient!=NULL)
     153          if ((TEST_V_QRING)  &&(currRing->qideal!=NULL)
    154154          &&(!hasFlag(this,FLAG_QRING)))
    155155          {

  • Tst/Buch/Example_4_6_26.res.gz.uu

    r46c7c3 r984ff3  
    11begin 644 Example_4_6_26.res.gz
    2 M'XL("*_O<D\``T5X86UP;&5?-%\V7S(V+G)E<P"%4\U/@S`4O^^O>#$>6H&R
    3 MMH@:`@>CAR7.P^;-3();XYKL*[2+_/F64@HF+O9`7_I^'^U[O.7;T^P5`&@!
    4 M+[-'N-)*DYW\O,HF2Y=A!9C#4AZD1CB;M#L4!3PWU?ZT$V52IB5+R4%\$Z4K
    5 M[6F\`!\G!.(X_V\!B$[3X%/"4H"+4*]\2P:7E$`M#U\F6N33L$$)(12'F]/P
    6 ME+L"Y$94.X!9'C6(XIL&,1RX*&DCCD,/OR?@UP"/F-T^F$5;7D0'TL.?I%[>
    7 M&5ERK^?SO0:=CC0"A^<6[-]"3</VE:YE`_-\O:WJ4HE:"H5F(XQIG:O(,D>V
    8 M)!B;+R6$V\+$L3Z"$@+T5D`MU'FGX5OJK8DC+\)'1G)?G=`BG.-LN&`<JY-8
    9 M:S!2K<QZ>U3B`,=Z(UIO+Y,4,,\F\W<:TE6.F"M#U`6!K07'`8J2+L,#.NTQ
    10 M+@HXMGRVRFW;4%?Z[I!?$J4&Z!/)2(C]NDC`_`TZ_\A1Q@3CW#7?H3IS9LV=
    11 BC/?L9;UC7XC;83"H^67;V6H'YZP,+;N>_`#/&O,XD0,`````
     2M'XL("/KI;%,``T5X86UP;&5?-%\V7S(V+G)E<P"%4\U/@S`4O^^O>%D\M`)E
     3M;1EJ"!R,'I8X#YLW,PENC6NRK]`NX\^WE%)FHK$'^M+W^WCOE2[?GF:O`$`+
     4M>)D]PE@K37;R<YR-EB[#"C"'I3Q(C7`V:G<H"GANJOUI)\JD3$N6DH.X$*4K
     5M[6F\`!\G!.(X_V\!B$[3X%/"4H`_H5YY2@:7E$`M#U\F6N23L$$)(12'F]/0
     6MRET!<B.J'<`LCQI$\6V#&`Y<E+01QZ&'WQ/P:X!'S&X?S*(M+Z(#Z>%74B_O
     7MC"RYU_/Y7H-.KC0"A^<6['NAYL+VE:YE`_-\O:WJ4HE:"H5F5QAS=6XBRQS9
     8MD6!LOI00;@<3Q_H(2@C06P&U4.>=AHO46Q-'7H1?&<E]=4*+<(ZSH<`X5B>Q
     9MUF"D6IGU]JC$`8[U1K3>7B8I8)Z-YN\TI*L<L7X,MG6.`Q39`]YMS&X!QY;`
     10M5GDW<X>*:'?.C5"/M\.D7H=%G4-D)=@/3Y<*J+=.N@P/Z*3'N"AP?%-"5\#@
     11ISSK_H1/W*_A"?";QI?3#F`Z/@YK?MGU?[>,Y*\/,;D;?/=8PWY4#````
    1212`
    1313end

  • Tst/Buch/Example_4_6_26.stat

    r46c7c3 r984ff3  
    1 1 >> tst_memory_0 :: 1332932526:3143- exported :3-1-4:ix86-Linux:mamawutz:183104
    2 1 >> tst_memory_1 :: 1332932526:3143- exported :3-1-4:ix86-Linux:mamawutz:2240272
    3 1 >> tst_memory_2 :: 1332932526:3143- exported :3-1-4:ix86-Linux:mamawutz:2273056
    4 1 >> tst_timer_1 :: 1332932526:3143- exported :3-1-4:ix86-Linux:mamawutz:15
     11 >> tst_memory_0 :: 1399646713:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:175096
     21 >> tst_memory_1 :: 1399646713:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2240344
     31 >> tst_memory_2 :: 1399646713:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2281316
     41 >> tst_timer_1 :: 1399646713:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:18

  • Tst/Manual/Branches_of_space_curve_singularities.res.gz.uu

    r46c7c3 r984ff3  
    1 begin 640 Branches_of_space_curve_singularities.res.gz
    2 M'XL(",HG<DX``T)R86YC:&5S7V]F7W-P86-E7V-U<G9E7W-I;F=U;&%R:71I
    3 M97,N<F5S`,586W/KMA%^UZ]`,YV)98DZ)BCY6IV'DTR2,Y.D'=LO2<;R0"1D
    4 MH8<D%(*T1?[Z[BXNI&2==CI]J!],<G?Q`=C[ZN'Q^\^_,L;BC^SGSY_8-[6I
    5 M9[E:?W/'X.U9E:H^&]^-\,D^?F2?*E&F6VF>]>;9[$0JG].F>I7/1I4O32XJ
    6 M52MI9J5\FYE:U*,'!\X_PK\*9%BUO)B>[:?MM!M/,W,7)!*44)D4.5/+_6H>
    7 MM>?=BD_WYVW4K9)IN^+1?I6<=W>,??C`ZJUDM#VC[5F_?1L0YXCXY_9-JI=M
    8 M?:;@$O&43^/`7R`?L!X!ZT6]RO)KB$P9]F<CC-KJ0K_(4NK&S-A/L@3A-Y`7
    9 M)=L)8P+PY<P"UYK.N=-Y6^I"P<U0`[,@=S4+2CG0RJ[7RO50*ZH0N[-JBC?Q
    10 M_!O2JS0Z;VJE2Z;@?5G`OS,UO>CEX@O"`?K="+Z8_4O<D[OGJ*K8WZ((`,-S
    11 M-+IPS/A8.&#'3H\_5+JPAJFK)JV;2C*](4)_P"DJS$@)9%$3[SN]E67TBT@%
    12 M:#L8+^9>A^TNP#@C'1J&AR6)71*^YP[B9UFSQK!2O[%<ZR]LHRN"6SM7!B;:
    13 M@$Q5J2*3*0/_KT35!E/%"\2B\'`B-D0"_Q)UX%@/OY&S_1$_W8*RF7_"WS.\
    14 M+_=1%S[YT[+C44MB_#^+>9ECR"Z)]NU0>I],]KR;[#L^V;>3MD=*@,>1REO@
    15 M=,#BDY:?VO]_QO2JN4+59'(#2ETB4*^TH7/S9:Z0Z;P+S):*/+?N)%-=9D$P
    16 M++\9Q*^+62D+@V&W%?#%>PNO6_:&#H?1JHM=4\NLM[H'Y!?.843^HL&]M@4Z
    17 MWL-6%;H5A8A^TU_H)7@%C]V"7\&UZ*2B\!L("D?8%^D_*E&6*GJLQ(NLHM]%
    18 MN@7W%:;?Z#9`DM\[1_KQ\?=_ZTD1*OK`1-9GCDUY4NZKOG0-!KP$`W;S29O@
    19 MROG!TFXQ039RT>AM,O2#J`,GZ;>:>\\@\M#;B+TX[53O//'_>R)OF<2YVT_B
    20 M%1TG^)'/&Y`OP,V1K(VRR;@$'\S49B,K68+SB19,7F8!T2>HK474ZUJHTB&2
    21 M*Y5-L985>J'W9,J?!18T)O<[F=8AD0;4A4-]OQC3905!E+>,3]FZJ7WU`F;Z
    22 M!4`410KDQP(2;(_HZYE/G*I\1?\M:X/HIXLF=`&]4U\=9F9^[0"+ABU9+1H6
    23 ML9I-H,2<X1;'I?84]CA@W3BLMRUH&1$S6>H:+HLG_47E)2!:54QI*R0__K.!
    24 MLBN\B@8V27P..%6<J!@%R?CP4@D?7@KL+O-:P,4JO%@02@Y.:V6&!R9*]-DK
    25 M&(_&K-+?FS.`SH].XCT`KXOF70^R'MBW+W>IKJ`T[R"[(F57Z51F6+8?8[:!
    26 M8AX`O0/@0BQ\(0,F9%DC:]O%A-2>4&JG>NG7],4RH<3]^!Q3<@/83!7X"6J+
    27 MDQ&%/%C^['(\X=TYOBW&(XIT?)^/)\F>$YDC.;'D9#S!1XPDC'&W#II(*QE9
    28 M).(O/#\&\@#J\FG9NG6X1]=SKCSG$.CZ:<G;(R0ZZPW6Z_XSO@C?M"[&\I[T
    29 M\#&W66E`P9K:#47@4MW<?SM%SJFK"]KOU3_W+9GM4=$/(+3CA-RI1M>#.*-@
    30 M03(X[J>&_!U25HTDA3G,J'5N^[0`&YJR[6%_O(5:5K_I098";NHWD-BUX<[6
    31 MW14FP0#I`T*5M83B^)?`\,GQ04-B?%60!_*6LE^F,NCEZI!KK7/GLI9Y"S>1
    32 M$*M&TA$WJC*U.U3`]<$!QS"%UO5VRG29M^\[#1<Y2-<E-/I;E6X],>P=$L<\
    33 M),FF0@V'$)E?O6]#81<#F[C`AG0K<M79CH%:73S;8=/3PUV'3M0N/(RM.<66
    34 MY9PI#O&%`?:M)7S+4DC_F`4$-&.F!C-!4@/>E+8%`\I<%E"JS`Q7/6K7J4N2
    35 MMMG/5DI88Y'/\14BEJQJQ0`JIJGFS(P]CDA3:6R&4U&]M4./7?F'>II29X^^
    36 M!RD9ZIX]U[V:6G\-VV(3>8]IPJV,H5WTWG\?WR%997?V]CO*+#^XBJ71)+2K
    37 ML1.%=8TS!8!X=+(#5EPX?*N;BJT%^!#*C^W681N"=6%4HB%K53:200!@Z;J/
    38 MZ<;WZ@.=Q4.+S08*.[9[$KS1CS/O#'__X1_/RI8&1,$/-5`:N5R)G03(BJ->
    39 MPV&J$M*\]YK,G]5JY,2F2,5,#UJ`KMD?>S8P+7]G6@)'VY)'I\H'22Y``DMV
    40 M)6I=(8(_$YW&@H&U9]BPE^ZT$/05QEJNC9L7K1*400"'A@YKV'UDFG6ALR8/
    41 M`V&M:S=4(V53B11OA4T,KHX_P.'.!QN?:J1!CC'LQV&MK."2*F6W[&)$]+[F
    42 M0CTV0+^T=/I;YQJ:)AR,;YFN()KQ&-EN(-'_W9)W&7Q]A!H`_SC^2\8G\/A_
    43 MA[=G+>M.P"1#F.^^VNX?S@5'0]VP;>["X+6X\!-=5>KELXO$P(T/BE*I>PYW
    44 MN0F"=$0/&DY0%^?0<#L2'`-5=(XSBJ4D2.%(08V=>_+<"783AT#<O7UT$R^V
    45 M\%NTDV[%'?'2KUWA6&UI5VX;I!&&9UP[X7;B<.P.*VY?8$AP@C=6D!CQF*1)
    46 M9!+[ZUXX*&1%@1K;G=V^GLJ#;#*F&WB&UP=!?VTGTDYB,>.P%)31K6"P#W>+
    47 M01/[%8P\*XXVH%OM\4I!S?$52G#+@6>+?)"EG^<F[:IWBV0PC[L,9`8A#)VG
    48 M&/X6!M,1UE7J=-<VIC/(!E!QYK;8!F#?"FP@1C7$85_O,8-HD.]A:22A%$]*
    49 MZ8?UA2_\[F<J96>I+R7-[N['*)]*WF=*EX@S5>'091K\;2!`^]H_/_ZMSQS?
    50 MLC^.;PMLBX8U!]3]`E-)[N8=:JJ@F4)]A`ENES>8C6WG@L@!S\]4MD]YPVH#
    51 MQ3[#F1026T&#)9C@Y*3:G\I/4W^'\VSH,#`@-'GM[F\;QUNV""<*2R]A<L(?
    52 4C/%GW\:`S]W]=?0OXY+%`5L6````
     1begin 644 Branches_of_space_curve_singularities.res.gz
     2M'XL("$^_<%,``T)R86YC:&5S7V]F7W-P86-E7V-U<G9E7W-I;F=U;&%R:71I
     3M97,N<F5S`,586V_K-A)^]Z_@%@LTCBV?2+)S79^'TT7;`_2&)"]M$0>T1,?<
     4M(XFN2"66?OW.#"^2'9\%%EA@_6#)P^''X=S'#X___/P+8RS^R'[Z_(E]8[29
     5M%7+]S1V#MV=927,VOAOADWW\R#[5O,JV0C^KS;/>\4P\9TW]*IZUK%Z:@M?2
     6M2*%GE7B;:</-Z,&!)Q_AJP8>5B\OIF?[:3OMQM-<WP6.%#ED+GC!Y'*_FD?M
     7M>;=*IOOS-NI6Z;1=)=%^E9YW=XQ]^,#,5C`ZGM'QK#^^#8AS1/QK^R;DR]:<
     8M2;A$/$VF<5A?X#I@/0+6BWP5U=<0F=3LKX9KN56E>A&54(V>L1]%!<QOP,\K
     9MMN-:!^#+F04VBN3<J:*M5"GA9JB!6>"[F@6E'&AEUVOE>J@56?+=63W%F_CU
     10M&]*KT*IHC%05D_"^+.'K3$XO>K[X@G"`?C>"7\Q^4O=,W'-4U^P?402`X3D:
     11M7;C%^)@Y8,=.C]_7JK2&,763F:863&V(T`LX185I(8#,#:U]I[:BBG[F&0=M
     12M!^/%B==ANPLPSDB'ADG"EM1N";_G#N(G85BC6:7>6*'4%[91-<&MG2O#(MJ`
     13M3%7+,A<9`_^O>=T&4\4+Q*+P<"PV1,+Z)>K`+3W\3L[V9_QT"\IF_@F?9WA?
     14M=FFT;P,A>5KNT\D^Z2;[+IGLVTG;A;44UA*D)BVL=+"43-J$,)/_,:8'/!9V
     15M'W5#V"Z)VE/GGV+SJKE"U>1B`TI=(G.OM*%SQ\M"PM8[YUU@MHP7!1EE(VMM
     16M`E_8?3,(7Q>R0I0:HV[+X5?2&WC=LC?T-PQ65>X:(_+>Z!XPN7#^PHL7!=ZU
     17M+='O'K:R5"TO>?2[^D(OP2F2V&WX!3R+_)Z7_@!.T0CG(OT'R:M*1H\U?Q%U
     18M]`?/MN"]7/<'W09(<GOG1S\\_O$?'2E"TQT8W5KAV#@G^;YF\.X:7.(27**;
     19M3]H4=\X/MG:+"2[C*KI1FPX]*^K`[?JCYM[7B#ST7UI>G';3=[[]_Y7(6R9U
     20M[O8C?T7'"7[DTP:D"_!R)"LM;2ZNP`=SN=F(6E3@?+P%DU=Y0/3Y:6L1U=IP
     21M63E$<J6J*=>B1B_TGDSIL\1ZQL1^)S(3\FA`73C4]YLQ6]801$7+DBE;-\87
     22M+UC,O@"(I$B!]%A"?NT1?3GS>5-6K^B_E=&(?KIF0A/0._7586).KAU@V;`E
     23M,[QA$3-L`A7F#(\XKK2GL,<!Z\9AO6U!RXB8BTH9N"Q*^K,L*D"TJIC244A^
     24M_%<#59=[%0ULDOH<<*HV42T*G/'AI=)D>"FPNR@,AXO5>+'`E!Y(:WF&`A,E
     25M^NP5C*(QJ_3WY@R@\R-)O`?@==&\ZT'6`_OVU2Y3-53FG:IRI.QJE8D<J_9C
     26MS#90RP.@=P#<B'4O9,"4+*N%L4U,R.PI978JEWY/7RM32MR/SS$E-X#-98D_
     27M06UQ.J*0!\N?78XG27>.;XOQB"(=W^?C2;I/B)P@.;7D=#S!1XPDC'&W#WI(
     28MRQE9)%I?^/48R`.HRZ=EZ_;A&5V_<N57#H&NGY9)>X1$LMY@!>Q_QA?A-^V+
     29ML6"F/7R<V*PTH&"5[H8L<*EN[G\[1<ZIJ0O:[]4_]QV9;5'1#R"TXY3<R:#K
     30M09Q1L"`9'/=30_X.*<L@26(.TW)=V#8MP(:>;'O8'F^AEIDW-<A2L)KY`P0V
     31M;7BR=7>)23!`^H"0E1%0'/\6%GQR?%"0&%\EY(&BI>R7RQQ:.1-RK77N0AA1
     32MM'`3`;&JA141..!8*U4`]M$!<NA2*;.=,E45[;M.PT4.DE4%??Y69EM/#&>'
     33MQ#$/2;*I4<,A1.97[[M0$$O#(2ZP(=WR0G:V8Z!.%T0[['EZM.O0A]I]AZ$U
     34MI]"R*V<RAO#"^/K6$KYE&61_3`(<6C%MP$J0TV!M2J>"_40A2JA4>H:['I7K
     35MTP5QV^1G"R7LL<CG^`H!2T:U;``5TTQSIL<>AV>9T#;!R<AL[<AC=_XIGZ;4
     36MUZ/K04:&LF?ENI=3ZZ[A6&PA[S%+N)W020;GOX_OD"SS.WO['266[UW!4F@1
     37M.E7;><)J]TP"((I.9L"""\*WJJG9FH,+(?_8'AV.(5@7117:T<BJ$0S\'RO7
     38M?4PWOI<?2!8/S3<;J.O8[0GP13_,O+/[_8??GJ6M#(B"/^1`:>1Q%382P,N/
     39M6@V'*2O(\MYK<B^KU<B)0Y&*B1ZT`$VS%WLV,&WRSK0$CK8EA\ZDCY&"`P=6
     40M[)H;52."EXFDL6!@[1GVZY63%F*^QE`KE';3HE6"U`C@T-!A-;N/=+,N5=X4
     41M81PTRKB1&BF;FF=X*^QA<'?\`80['QQ\JH\&/L:P'8>]HH9+RHS=LHL1T?N2
     42M"^58`_W2TNFS+A3T3#@6WS)50S"C&/ENP-%_;LF[-+X^0@F`KP2_TO$)O.2_
     43MP]NSEG4G8-(AS'=?[?8/QX*C*7'8-7=AS%Y<^'FNKA0-=,.9;A$?U*1*]2N)
     44MRTT0I"-ZT&R"NCB'?MN10`Q4T3F.*):2(B5!"FKLW)/GCK&;.`1:W=M'-_%L
     45M"W]$.^E6B2->^KTKG%,M[<H=@S3"\`O7CKF=.!Q[PBJQ+S`C.,8;RT@+\9BX
     46MB642^^M>."A<B@(UMB>[<STU";SIF&[@%[P^"/IK)Y%V4HL9AZV@C&Z51OMP
     47MMQ@TL5_!Q+-*T`9TJSU>*:@YOD*.Q*[`L\5UX*4_YR;MJG>+=#".NPRD!R$,
     48MC2<?_A,&PQ&656ITUS:F<\@&4''FMM8&8-\);"!&%<1A7^XQ@RC@[V%I(J$4
     49M3TKI9_6%+_ON3RII1ZDO%8WN[J\HGTK>9TJ7B'-9X\RE&_QK($#[TC\__J=/
     50M']^R%\=W!;9#PYH#ZGZ!H:1PXP[U5-!+H3["`+<K&LS&MF]!Y(#G1RK;IKQA
     51MM8%BG^-("HFMI+D23'!R4.VE\L/4KR#/AH2!^:`IC+N_[1MOV2)(%+9>PN"$
     525?Q?CG[Z-!I^[^_OHWV0\F-A9%@``
    5353`
    5454end

  • Tst/Manual/Branches_of_space_curve_singularities.stat

    r46c7c3 r984ff3  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:406444
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:913408
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:971112
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:44
     11 >> tst_memory_0 :: 1399897935:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:411768
     21 >> tst_memory_1 :: 1399897935:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2490368
     31 >> tst_memory_2 :: 1399897935:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2546268
     41 >> tst_timer_1 :: 1399897935:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:43

  • Tst/Manual/Branches_of_space_curve_singularities.tst

    r46c7c3 r984ff3  
    1515  LIB "primdec.lib";
    1616  primdecSY(i);
    17   def li=_[2];
    18   ideal i2=li[2];       // call the second ideal i2
     17  def li=_[1];
     18  ideal i1=li[2];       // call the first ideal i1
    1919  // The curve seems to have 2 branches by what we computed using the
    2020  // algorithm of Shimoyama-Yokoyama.
    … …  
    4242  // the singularity has two branches, since mu is even and delta is an
    4343  // integer!
    44   // So obviously, we did not decompose completely. Because the first branch
    45   // is smooth, only the second ideal can be the one which can be decomposed
     44  // So obviously, we did not decompose completely. Because the second branch
     45  // is smooth, only the first ideal can be the one which can be decomposed
    4646  // further.
    47   // Let us now consider the normalization of this second ideal i2.
     47  // Let us now consider the normalization of this first ideal i1.
    4848  LIB "normal.lib";
    49   normal(i2);
     49  normal(i1);
    5050  def rno=_[1][1];
    5151  setring rno;

  • Tst/Manual/minAssChar.res.gz.uu

    r46c7c3 r984ff3  
    1 begin 640 minAssChar.res.gz
    2 M'XL("#`J<DX``VUI;D%S<T-H87(N<F5S`$V074_#(!2&[_D5)XL7K;!&J/.K
    3 M*8D?-TO,;N;=,I=J&SU)5QE@%'Z]8&?Q"EZ>)R]PUD\/RQ4`<`F/RSN866.+
    4 M'E]F%83=#@>T65Z1N(*4L,?AUIC[]T870_=5&-M8LCXVB&.#TKAON]>Q9:*E
    5 M!(W#&X"&&LY8]LT<\SEK55+.):B/W@&HH'A!>4*+/W2(J*0BH0L)V'9-#QB0
    6 M.CT\"^;F_I]P*:%'8T'%F],',LR3<Q7Z=44V?'M#0MR%3>W%W(U!;&OGJ1A#
    7 E&8*@PI-PG&1'^>3&IT_-U_)WD'%2GR;C>75"?@#S3?KW<P$`````
     1begin 644 minAssChar.res.gz
     2M'XL(",+=;%,``VUI;D%S<T-H87(N<F5S`$V02T_#,!"$[_X5JXI#@MT(.Y17
     3M%$L\+I50+^56E2J0"%9*@VL;@?WKL4F).>V,OM&LO>NGA^4*`+B$Q^4=S*RQ
     4M18\OLPJ"VN&`-LLK$B=("7L<;HVY?V]T,71?A;&-)>MC@S@V*(W[MGL=6R9:
     5M2M`XO`%HJ.&,9=_,,9^S5J7(N03UT3L`%2)>4)[0X@\=(BJI2.A"`K9=TP,&
     6MI$X/SX*YN?\7N)30H[&@XN;T@0SSE+D*_;HB&[Z](<'N@J@=Y:,6VSJ^A@21
     7EJ!=S-V'GJ1A-&8R@PD_-U_+WD/%2GR;C>75"?@`*>#)=<P$`````
    88`
    99end

  • Tst/Manual/minAssChar.stat

    r46c7c3 r984ff3  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:225204
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:669460
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:720736
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:12
     11 >> tst_memory_0 :: 1399643586:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:217240
     21 >> tst_memory_1 :: 1399643586:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2242444
     31 >> tst_memory_2 :: 1399643586:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2300880
     41 >> tst_timer_1 :: 1399643586:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:7

  • Tst/Manual/primdecSY.res.gz.uu

    r46c7c3 r984ff3  
    1 begin 640 primdecSY.res.gz
    2 M'XL("$5?<DX``W!R:6UD96-362YR97,`C9%/2\-`$,7O^RD>Q4-BUF"V:?T3
    3 ML@?Q4A`O\2)22[5!!M:8)BN:?'IG:[81>K!SF1G>C\<;IGBX7=P#2#3N%C>8
    4 MV-;&AEXF&7A:444V"#/A.K1&W=#[IGPM'N.J_(I;N[:B&`S48#`@OR9[=:K1
    5 M4/4&-,AQ+H-OV<D^E*8>D93M/TP'U(ST*DI&:>:EK9.FD1JEN09MRK4!L52?
    6 M;I^5[,[Z/\"%AJ'6<G0'^/P!A2-RZ0[+Q%.RO!:\^LZUXCEW6?:[6N;.?\>I
    7 I?SA>/7/@.8]2/B0]RI<//N!\]BN]>Y1[Q6<;)&%V(GX`DI$%R-,!````
     1begin 644 primdecSY.res.gz
     2M'XL("%C=;%,``W!R:6UD96-362YR97,`C9%/3\,P#,7O^11/$X>6AHIF9?RI
     3MF@/B,@EQZ2X(C6FP"ED*I6N#H/WT.*-9T78A%]MY/SW;<K&XFS\`2#3NY[>8
     4MV-;&AEXF&3A;444V"#/A(K1&W=#[IGPM'N.J_(I;N[:B&`S48#`@OR9[=:K1
     5M4/4&-,AQ+H-OV<D^E*8>D93M/TP'U(ST*DI&Z<)+6R=-(S5*,PW:E&L#8JD^
     6MW3XKV9WU?X!+#4.MY=$=X.</*!R1*[=8)IZ2Y8W@TD=^*\[S?A:EW#3=_ZEE
     7L[GKL6'7`\G!'G(>.C'G)?YD><ESZV:_U[E#N%)]MD(39B?@!$(R[;],!````
    88`
    99end

  • Tst/Manual/primdecSY.stat

    r46c7c3 r984ff3  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:243744
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:782336
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:798720
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:13
     11 >> tst_memory_0 :: 1399643479:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:235848
     21 >> tst_memory_1 :: 1399643479:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2338816
     31 >> tst_memory_2 :: 1399643479:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2370208
     41 >> tst_timer_1 :: 1399643479:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:10

  • Tst/New.lst

    r868d77d r984ff3  
    5151New/qring_ZmtoZmn_errorCoprime.tst
    5252New/qring_ZtoZm.tst
     53New/AnnExt_R_bug.tst

  • Tst/Old.lst

    r46c7c3 r984ff3  
    331331Old/zahlen0.tst
    332332; Old/algmap.tst
    333 ; Old/m25si.tst ; needs MP!

  • Tst/Old/ok_g.lst

    r46c7c3 r984ff3  
    156156m23si
    157157m24si
    158 ; m25si: trouble with rings
    159158m27si
    160159m28si

  • Tst/Old/singular.lst

    r46c7c3 r984ff3  
    2424m23si
    2525m24si
    26 m25si
    2726m27si
    2827m28si

  • Tst/Old/universal.lst

    r46c7c3 r984ff3  
    156156m23si
    157157m24si
    158 ;m25si
    159158m27si
    160159m28si

  • Tst/Short/bug_15.res.gz.uu

    r46c7c3 r984ff3  
    11begin 644 bug_15.res.gz
    2 M'XL("&G9(E,``V)U9U\Q-2YR97,`I99=:\(P%(;O^RL.L@N+336MW])<C,$0
    3 M9!=3!EL0\:.X0!6QE;7_?M5:M6V.1.N%;<S#V]ASWC<93]Z&'P!`&8R&KU`)
    4 M_,#TQ*(RT,;G&8M!_.-,;$50U0?:\0J,P>*PGM&6N77_3#^8!Q?<9G"Y;YJ)
    5 MZ&XO-BMWF1-N,=B+[1H^'=NHAD:D&][N.MMF(%;NW`/A1$T2VB0TPE[\%?5(
    6 M=*4Z##SA!^`YYV>\3WZJ0K\"W1@8:)Q.^UH\2J_Q9Q;?.]%E8$V=\$1862*\
    7 M)2(MG2X(U6A&*AGFQ204MQ%!HB18I'@3$;34EBC!>`N5S"^`8*(2D+<Q6:(J
    8 M*P-Y1Z76%O+W"Q#OJE7<(M@JI2#OJ=4=EY6"G#94RQ^I-L`1Y!1S4!XGJKHD
    9 MT<4,)6F92+6W8I]2S%=%_,Z;D**<HA8K]&,-6;,,Y!3U6;'/T37+T30.>PSJ
    10 M=?AR]VO/%<M?%S8BZ*>SM&$F:3I*TW3\?1NF]+A)W`G3IS,0ZX&G,Q`O_M,9
    11 MB,=JJ0Q\H.2/9"`:K>6['XO7DH;%8K:DI["8+6\I/&I+[@QHU);=&O"H+;<U
    12 MJ+KMT:T!LUR&E0IF"3Q8LZ])]4B0QJ%U/>I2VSR=DH]'X8-?I?K@1?L'$.6.
    13 %3EL+````
     2M'XL("+S9;%,``V)U9U\Q-2YR97,`K9;;:L)`$(;O\Q1#Z47$;'03SY*]*(4B
     3M2"^J%-I%Q$.P"U%$(TW>OM$8#\F.K&Z],%GWXW>2F?EW!L/7WCL`4`;]W@L\
     4MA=O0#L3TJ6L,CCL.@^3'L5B)T"QUC?T5&(/I;C&F=7OE_]K;<!*><)?!Z;YF
     5MIZ+KC5C._5E.N,Y@(U8+^/!<RXRLN&0%Z_-N@X&8^Y,`A!?72.22R(K:R5?<
     6M)O&9:C((Q#:$P#O^Q]OPVQ2E,]!*@*[!Z:AC)*OLFGS&R;T7GQ;.R(L.A'--
     7M1)=$;&3;!:$RO9)*EWDQ"<5=1)`H"18I7D,$';40)1BOHY+Y``@F*@%Y`Y,E
     8MJK(RD#=5<NT@CU^`>$LMXP[!HI2"O*V6=UQ6"G):54U_K%H`>Y!3K(/R.%'5
     9M):DNUE"2DHE5:ROI4XKU51&_\2:D**=HBQ7JL8S$+`,Y1?NL6.=HS'(TL\,V
     10M@TH%/OW-(O#%[,>'I0@[V2ZMVJF;]C,W'7Q=FBG='Q(Z9IHC4#/5K"D\]5HM
     11M@&5=LV.QI&OZRQWF>F<MH0:K6?Z8T6HZ`6:T_V$$J-GJG6`WS%;KP+UAM@_/
     12M!JC1/CS`H/;Z\(R%&NMUXZB.!)D=.N=1E[KV84K>C\*[K4E+W6?C#V:A/\E;
     13#"P``
    1414`
    1515end

  • Tst/Short/bug_15.stat

    r46c7c3 r984ff3  
    1 1 >> tst_memory_0 :: 1394792809:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:315844
    2 1 >> tst_memory_1 :: 1394792809:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2387968
    3 1 >> tst_memory_2 :: 1394792809:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2516996
    4 1 >> tst_timer_1 :: 1394792809:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:43
     11 >> tst_memory_0 :: 1399642556:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:317748
     21 >> tst_memory_1 :: 1399642556:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2387968
     31 >> tst_memory_2 :: 1399642556:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2517208
     41 >> tst_timer_1 :: 1399642556:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:43

  • Tst/Short/bug_17.res.gz.uu

    r46c7c3 r984ff3  
    1 begin 640 bug_17.res.gz
    2 M'XL("(<JO4X``V)U9U\Q-RYR97,`"PYQ\?134%`PM%/P\7124"HI+M'+R4Q2
     1begin 644 bug_17.res.gz
     2M'XL("/_9;%,``V)U9U\Q-RYR97,`"PYQ\?134%`PM%/P\7124"HI+M'+R4Q2
    33MLN8*ALH8V2D`!>,S\S)+-#2MN4"T@IV=0E)I>KRAN5Y>:KE><4EB"5RYL9T"
    44MG&VB!S&TH"@S-R4U&<U@4SN%HLR\=(4@6R,=C0J=2ITJ39V<`H2\F9U"9DIJ
    55M8HY"IFV5D7:5MJ%.I9%V)9"JT*Y$J#*W4X`:[QX2I9$)=&&T8:P5%U`&1@-!
    6 M/)`--00N8A1K6ZE=!><:Q]H"S07K,R)#'TP3498B"9!H+:9.6#A8P,,A.)+2
    7 G8*@:F&"`"E`8$):(!&AHH`=.NZ`$6EJL8:AIK<(%`/]54&/Q`@``
     6M/)`--00N8A1K6ZE=!><:Q]H"S07K,R)#'TP3498B"9!H+:9.6#A8P,,A.)+T
     7M8$`W%RI`IIM("@PTB\F.`5A`6"(2H*&!'CCM@A)H:;&&H::U"A<`E^3XW/$"
     8"````
    89`
    910end

  • Tst/Short/bug_17.stat

    r46c7c3 r984ff3  
    1 1 >> tst_memory_0 :: 1321020039:3133- 14004 :3-1-3:ix86-Linux:mamawutz:312124
    2 1 >> tst_memory_1 :: 1321020039:3133- 14004 :3-1-3:ix86-Linux:mamawutz:864256
    3 1 >> tst_memory_2 :: 1321020039:3133- 14004 :3-1-3:ix86-Linux:mamawutz:949536
    4 1 >> tst_timer_1 :: 1321020039:3133- 14004 :3-1-3:ix86-Linux:mamawutz:15
     11 >> tst_memory_0 :: 1399642623:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:304588
     21 >> tst_memory_1 :: 1399642623:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2428928
     31 >> tst_memory_2 :: 1399642623:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2520924
     41 >> tst_timer_1 :: 1399642623:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:16

  • Tst/Short/bug_charseries.res.gz.uu

    r46c7c3 r984ff3  
    1 begin 640 bug_charseries.res.gz
    2 M'XL("%`INT8``V)U9U]C:&%R<V5R:65S+G)E<P#5E$V/FS`0AN_Y%:.H!P*4
    3 MQ082D@@J5>UAI:J5DDI556VRA)C4*B6L(=HNO[X##M@*JMIKN?CC?69LCU^\
    4 M_?SN_B,`D!@^W+^%:5W53LX/T_5D>U5H##BYYP6OC=EZTK80QW"XG/;I]T14
    5 M3'!6.05[=JHZJ8<P+X:[.T@*8$*<!22'\Z6&BA\9L"QC:5W!.8,OG;@%7@`N
    6 MFB4I",1XP:K5D,AW8.@'CMQE*?C/(TMO=CJ/0?#B!`(B<&WCE_UB-S,[+Q6Q
    7 MB.'(,BBC9D?!`J*44"I/J'BH4*4LI5(E)T;=J`03GG9*)JXFD^CE=:.+6%4\
    8 M<9(#CV2\+3E%8'5_\#R'VWE/GW?5O*\MYT77.FR_&GRFF"`&%(K:D!0JW\C#
    9 M:H)GZ5O\]MB/&FJ184P?VNW3CJ-_X7#8,Z.<<\MO/,O_I[R>14=<?PR\SJ&_
    10 M</YTM6@RTP3!L"IHS0XQS2$NU,KECVZ=X-V^WVP^;8QI5^QR/<5BX6;>P'4L
    11 M!]+"YS2]"%RH=:M,D*-3,<D*'D=9'OLUJ&Z08&0O2C1Y'FD"U82%M$\`NRNH
    12 M,$_#0HGYZ%$9IC#=-\L;F]*@MVDK>Z[,$DJO+A4V5SD\HGE/1BD#4OS-)/1_
    13 =.H^&RGETZ73/7_NV72J#S-:O)K\!.VTP'#0%````
     1begin 644 bug_charseries.res.gz
     2M'XL("%?:;%,``V)U9U]C:&%R<V5R:65S+G)E<P#5E%%OFS`0Q]_S*4[1'@A0
     3MBFU(2".8-&T/E:9-2BI54]5$)#&I-4:H(=K*I]\%!VP13=IK><'<_W>'??>'
     4MU</G^V\`0!+X>O\)QG55>[G8CA>CU46A"6!P(PI16Y/%Z'R')('MZ;#9O:2R
     5MXE+PRBOX;Z^JT[I/8PG<WD):`)?R*"'='D\U5&+/@6<9W]45'#-X;,45B`+P
     6MI5FZ`XF8*'AUUQ<*/.C7H:=V64KQ:\]W@YU.$Y"B.("$&'S7^N.^N<W$S4M-
     7MS!+8\PS*N%E3<(!H)5+**RH,%:J5N5*J],"I'Y=@P^M:R\0W9!*_W32FB%W%
     8M$Z<YB%CENXK3!';WI\AS&,:9&?=U/#!>Q^)+'U8_+#'13)@`"D5M*0J5)_)\
     9M-\*S='>\-KB.FZD3-,P)^AA]/A^!MBP=L,RA5UP'716F#OFOHD,.'[MCX#C[
     10M]<S[UVC19+8-DF-7T)HM8MM]7F2T*[B:.L'9?EDNOR^M<=OL<C'&9N%>/L+E
     11MN2.I.>;PRB24&/(T-@1J"#-E@A#6%U!CS,`BA07H-)6F,7/Z\X'9:-B9[2PS
     12M7U6)E./F&IOJ&HP8#E)9VD84/Q8%O4__T$C[A\Z]]B=V_D.=*HM,%A]&?P$D
     13')3>H^@0`````
    1414`
    1515end

  • Tst/Short/bug_charseries.stat

    r46c7c3 r984ff3  
    1 1 >> tst_memory_0 :: 1186670893:2007080817:3-0-3:ix86-Linux:nepomuck:247436 1292524760:3120- 13145 :3-1-2:ix86-Linux:mamawutz:244100
    2 1 >> tst_memory_1 :: 1186670893:2007080817:3-0-3:ix86-Linux:nepomuck:832260 1292524760:3120- 13145 :3-1-2:ix86-Linux:mamawutz:782336
    3 1 >> tst_memory_2 :: 1186670893:2007080817:3-0-3:ix86-Linux:nepomuck:832260 1292524760:3120- 13145 :3-1-2:ix86-Linux:mamawutz:802604
    4 1 >> tst_timer_1 :: 1186670893:2007080817:3-0-3:ix86-Linux:nepomuck:19 1292524760:3120- 13145 :3-1-2:ix86-Linux:mamawutz:11
     11 >> tst_memory_0 :: 1399642710:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:236720
     21 >> tst_memory_1 :: 1399642710:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2338816
     31 >> tst_memory_2 :: 1399642710:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2375480
     41 >> tst_timer_1 :: 1399642710:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:12

  • Tst/Short/bug_charseries2.res.gz.uu

    r46c7c3 r984ff3  
    11begin 644 bug_charseries2.res.gz
    2 M'XL("(C9(E,``V)U9U]C:&%R<V5R:65S,BYR97,`[54[;\(P$-[S*TZH0P*6
    3 MP4[2A])XJ+I$JKK0K2HH@`%+*$&V<2M5_>^])&#*PMPA'B[W_.[S1?)-WYZ+
    4 M5P!@`EZ*)QA88^E.+099,#U&N`!TSE6E;!AE0?,%(6!QV,R7VU(;J94TG%;R
    5 MDQI;6E\7"QB/H:Q`:EUK*!?UP<)R6]=&51M8*[E;@?RRLC*JKHPO2RAX/:6@
    6 MFV2=<Q(Z1APG+B8N(2Z-R&I_YG@K0*UDN8,B=_&,CQP;NA@E`9<T)A^Z!"7Q
    7 M!7<47'I,Q&#:*:UCAC8_0]\+*+*@>&<?^1&U:X`NCJX.N6N"KKC):A'^()Y:
    8 M8$,/^R!@7>M05194/LG4(T,Q&D6G!#:A\.T-1F&/D[!A,_%Y-_*PB")/D\44
    9 M!OG5<_ZE#.?Z$US<AEQ<A+2<V['%+7^,I.1ZQ44N=">XSJBGT%/H*?04_B.%
    10 <TU.)F\7KN#2:3=ALN8,)693=!+^1GL)H/P<`````
     2M'XL("+[:;%,``V)U9U]C:&%R<V5R:65S,BYR97,`[55-;\(P#+WW5UAHAQ:B
     3M0))V'^J:P[1+I6D7=IL&*A`@$FI1$K))T_[[DA;"N'#=I3FXMF,_/[M2/'U[
     4M+E\!@'!X*9]@8+3!.[D8Y-'T>$,Y..=<UM+$21[Y+W`.B\-FOMQ62@LEA::X
     5M%I]8F\J$/,9A/(:J!J%4HZ!:-`<#RVW3:%EO8"W%;@7BRXA:RZ;6(2W%$/0,
     6M@_+!JJ`HM@19BBQ#-D4V2]!J?^9XRT&N1+6#LK!L1D>6#"US$H%-O4F'-G42
     7MA80[##8[!KK+K%-:Q\S9]`Q]SZ',H_*=?!1'U*Z`<U'GZI"[(L[%?%2+\`?Q
     8M5,(5#+`/'-:-BF5M0!:37#X2)T:CY!1`)AB^@T$P[-TD3.PG/N]&'I=)$F@2
     9MAF%07#WG7TK<7'^BBV[012.MQ5KFSI<A\.=Z`FE;ODB+KO/I"?0$>@(]@?\G
     10=<'H6W18)NEL0?NOYC7;0,4GRF^@7:K+$>2L'````
    1111`
    1212end

  • Tst/Short/bug_charseries2.stat

    r46c7c3 r984ff3  
    1 1 >> tst_memory_0 :: 1394792840:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:701556
    2 1 >> tst_memory_1 :: 1394792840:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2387200
    3 1 >> tst_memory_2 :: 1394792840:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2428172
    4 1 >> tst_timer_1 :: 1394792840:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:222
     11 >> tst_memory_0 :: 1399642813:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:495016
     21 >> tst_memory_1 :: 1399642813:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2377264
     31 >> tst_memory_2 :: 1399642813:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2418236
     41 >> tst_timer_1 :: 1399642813:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:98

  • Tst/Short/charseries.res.gz.uu

    r46c7c3 r984ff3  
    11begin 644 charseries.res.gz
    2 M'XL("-D^*%,``V-H87)S97)I97,N<F5S`-582V_C-A"^YU<0BQYL2_)J9O@2
    3 M`OM0])+=8B_;6Q$':3?;&C721:*B\K\O7Q*I5^)X?6D06!(Y,R2_;_0-J<^_
    4 M_'3SB3$&6_;SS8_L7?U<KP_[W]Y=7WT./;AEW3VMF3&XVS_NZ\7R^LI>V7;+
    5 M?O_S_NGYX6G_\+Q^?/AW_5S?UYT+3]S%FCWM'_]@3YLR7S20-Y@WE#<\;T1^
    6 M7.:';W%4N67?_CX<V5?8+!;'K(%50UF#YF:Y6AP+7#6X,T]D?ER+?3`VMFFY
    7 MC&'4ENV_/-P?V,W&#+C#HC&>8(S,;V'_S0Q<,[EFVQ">K*F+GQ>VPPW6L_&]
    8 MQC893K?#?=C<Y%\A=E0>I#N/$EM\,$YWOT(.MQNP,]JIC+NK+-`.LQ.9N_`"
    9 MP%XIXRLW"6'G`,X7;S>%L[1V=L+2>7A+NX)PYWQVZ)9D(;+@V46X('2[\>Y4
    10 M\+X[%3UG<FX['X-"#"K\5+A91BG(34!FH+G4;A&%Q@ITB,LK[FZ-LU!<^?4@
    11 MY]+AJE4I5H;&0@,W,?$[H,%+0(,7@08M-*1)M=``H`[8@."R#.`(B0X&`PZ'
    12 MJ@S@@"PA`2=#H%*:J/0=X-`EP*&+@$,6G(*`!W0*DT/2IXO(I"YE6`HI\*TF
    13 MJC$(\8!750).@5S*]GV#,JH.P)K]M3\<V%/W.D*B:6`T[?W[1):XTR2K"T&6
    14 MOD19`FZ-O3!A$*96C[B]R88*!,)ZM!K$HI`X/'@6M<0\%0VW3SSW9M@W<S;H
    15 M1O!FW1C2CL&ZOYR!%\,BR*8/`5D4-Q><MR*6C&Z<_>!!3+WD>=MV"HGVM6YF
    16 M2G')*B[9Z2#&+FV[1DK8]E;KCA8LK>6`-X3$``>\C<I)PAM2Y(TL;XZPJ.FA
    17 MB$28>:@XF%")/*6RL-0D$2*R'3)90,83$@N/JR$!2$]ND<))'8$#ZCK2[`L4
    18 MR.HF)[H<F.,/BN"?,$[9D#V4`_8H=JF7V$.=D%--L$=E-"`X>2M`V&X%^(8M
    19 M7*5?N+4L5Y:PP)M["QNK1PEC1+'\>UC`I+=#TMXX'-#<^$R(;CR6<680B."0
    20 MF*_C/GY;F0-E78WU>=$6RX"[>Q36V.B7(<?)QW&';?WK0F(_)/9#8C\DNI`F
    21 M4%LINC#4#T/],-0/0S9,2.1C!X",RDEJ)*RDD^[J9(IYV5(L)BDV=<:3;.K+
    22 M!,T<(LUS+/M[3[1_C.[8IUO$'CJ7;LB&C(>6"_">QL:IV&],@#0>3<6;S`2>
    23 M;.RY&&4"3Q*%J],S0;>9(%TFQ(U_$.BHS6[73[V6)"6JUU,BS8?.492MXT<K
    24 M?C)VP"`7/I[YZD]E0=.NPZSHK)=_3'\:]"PA&&5`1\71Q&A12792@D99()(D
    25 M$:>?_H1,LV"<!%,Y8<OK*CV,"75N"NBY%!B>XBZ=`A[:B_`?X,@&;ZU,-L9R
    26 MO#&6"9V24K[J_$7&))]AK.XS5B>,U4/&I!@P5I_(F)0SC$DUSUCM3O7G,E;'
    27 M-1U;QKJ(9S%6SS"6E%19C1A3":$*WL"8PI<9FZ9(T9D4*3Y#D1INJ?Y_%*FD
    28 MUJGQID@E#*JX*:)71%"7ERF%>GYWE"7[H_[V*!*G<88X/=P<O::&H2$"G<&8
    29 MO/!!R6TX[!%F%1>%_MO"*AR:(.FB[ICL?GV[/2-%YB?E-#0,IH034WIC40T-
    30 B@\`T$7BVM.JD=FKA/[S:+ZO_/"]@>?W#U7\,(I[LNA4`````
     2M'XL("!;8;%,``V-H87)S97)I97,N<F5S`-5836_C-A"]YU<0BQYL2_)J9O@A
     3M(;`/12_9+7K9WHHXR':SK5$C7=@J*O_[\DLD)=F)[?BP#0*;(F>&XGNC-R-_
     4M^O6GNU\88[!D/]_]R-XUNV:^67]^=WOSR:_@DH4QS9DV>%@_KYO)]/;&?+/E
     5MDOW^Y^-V][1=/^WFST__SG?-8Q-<>.(NYFR[?OZ#;1=E/FDA;S%O*6]YWHI\
     6M/\TWW^*N<LF^_;W9LZ^PF$SV60NSEK(6]6`ZF^P+G+6XTE>D/^R,N=`V9FHZ
     7MC6'4DJV_/#UNV-U";[C"HM6>H(WT9V'^]1W8:;+39L)?&5,;/R_,@MVL9^-6
     8MM6VR7=5M]V%QEW^%N%`[D!X<2FSR03L]_`8YW"_`W-%*9=Q^RP+--BN1V2]>
     9M`)AOROC,WH0P]P#6%^\7QK`P9N;DTCE80WL`-RJ$];386(0<`FACT/W"^_L=
     10MHC]E/6^R?AYF\D'(WPK780BXDNX(4`H)E3N&K$KICT(*W"QE0ANX>`7PNK;(
     11M5JH4,TTMEU('Q3=@@U?`!J^##1ILJ"(/308`6#EH"A!<EG;,,R'1P40%A[I4
     12M+A[($A)L,@0J#3CT!G#H"N#0=<`A`XY.%NK`J;CTV%18@X>&\YJ[M"E0*.ZA
     13M0<YE`HU.I`IX][Q!&54'8,[^6F\V;!L>1T@T#;2FO7^?R!*WFF1TP<O2ERA+
     14MP(VQ$R;TPM3I$3>#;*A`((Q'IT$L"DEAX.!9U!)]5;3<7/'<F6'?S-J@W<&9
     15MA3VDV8.%OYR!8ZSPLNE"0!;%S0;GG8@ENVOG0%:4/&?;W4*B?9V;OJ5X9!6/
     16M;'40XU)EED9*V*W6\T`+EL9RP!M"8H`#WD;E).$-*?)&AC=+6-1T7T0BS+S+
     17MUH1*Y"F5A:$FB1"1#<AD'AE'2"P\MH9X(!VY10HG!0('U`72M$U'5K@Y$7+@
     18M&']0>/^$<<J&[*$<L$=Q2;W$'E8).?4!]JB,!@0GMP*$72O`%VQB*_W$GF4Z
     19M,X1YWNQ3V!HY2A@CBN7?P0(ZO2V29F!Q0#UPF1#=>"SC3",0P2%QO(Z[^+$R
     20M6\JZ(NOSHBN6'G=[*8R2VG39=V4OA,)^*.R'PGXH-*'TZKXK$"$,]<-0/PSU
     21MPY`-`[H2ZW2Q@J8A#P#(J)RD1L)*5;)<GTPQ+SN*Q4&*=9EQ).OR<H!F#I'F
     22M8RR[L2/:749W[-,MX@I=2C=D0\;]S!MX3V/BH9AG)D`:CP[%>S$3>-+8<S'*
     23M!)XD"E>G9T+598*TF1`;?R_049MMUT^]F20EZM=3(LV'X"C*SO&C$3\9%V"0
     24M"Q\O?/1'61".N/?<GZL`XQQP$4-RG:\&A](@AEQ10"7II`2-LD`D22).?_L3
     25M,LV"<1(<R@E37F?IRYA0EZ9`=2P%AF]QWW$*>#A"$O@CR*0QEN/&6"9T2DKY
     26M:O(7&9/\"&--G[$F8:P9,B;%@+'F1,:D/,*85,<9:^Q;_:6,-;/A0X:]H!>1
     27M5C2N8S<M7J0LJ:FR'E&F$D85G$&9PI<I.\R1H@LY4OP(1VK84_T/.5))M5/C
     28MMD@E%*K8%M$K,EB5URF&U?'^*$LZI'Z#%)FK\`ASU;`]>DT/_42$.?Y\%($N
     29MX&Q5]!.#N'@@[IGET4\,`M.!P.3Z.?/6-8LLH$T4-_"\A$%XL[>?;MZ\UD6Q
     30<KI+J60GWTZOY;?6?W02FMS_<_`=5@1@MO!4`````
    3131`
    3232end

  • Tst/Short/charseries.stat

    r46c7c3 r984ff3  
    1 1 >> tst_memory_0 :: 1395146457:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:1207228
    2 1 >> tst_memory_1 :: 1395146457:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:13295616
    3 1 >> tst_memory_2 :: 1395146457:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:21684224
    4 1 >> tst_timer_1 :: 1395146457:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:11894
     11 >> tst_memory_0 :: 1399642133:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:1170504
     21 >> tst_memory_1 :: 1399642133:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:15392768
     31 >> tst_memory_2 :: 1399642133:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:15392768
     41 >> tst_timer_1 :: 1399642133:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:8632

  • Tst/Short/charseries_p.res.gz.uu

    r46c7c3 r984ff3  
    11begin 644 charseries_p.res.gz
    2 M'XL("(QK7U,``V-H87)S97)I97-?<"YR97,`[5I+;^,V$+[OKQ`6/=@K(Q"?
    3 MHA#8AZ*7!$4OV]LB#21MMC4:I$$BHU9_?4G))(<<2::SZ*7(:2F9I$;?@S.C
    4 M[.=??[KY)<LRLLM^OODQ^]B]=E>/^^;C]8?/IU_H+M,W[_=/^VZUOOY@_LUV
    5 MNZS]HWYY?7C9/[S>/U\]/?Q]]=K5G5O$=ID;\ZOL9?_T>_:RI9M5MVDV]:9?
    6 M;[X^^T>(7;;_^E`_9OMM3?.NV30\;_3`SY"[[/FOQS[[MEWU9L;ZTZK/&Z9G
    7 MF9&YDW=T[>>7=L>;[7[SS=]78^#W8^39ZD:ON?]"-N1N>WKF<$GOMGK'F@X7
    8 M3/]FGI3W^I*&4RF<2LW4+J^'B2R<R.!$9B:::3:LRL-%BJOLS_WC8_;BHB8$
    9 M_$Q#-&N-9X@F8>?0)/PR-(F81I/(>31KI;>H>=X)"^@0BP6TEGEG?F7]<(??
    10 M;0L+KH.UMI`VPT#/<;@Z1&N+9I.387B:Q5$,',;`(5/</EZ@10(N$I8U,QR6
    11 M6!Q*P(_"]`%V:8'I:R,"*8D);&G>YIA'2B=XI(9(/7O@M,V[248IFV:4\C<S
    12 MVND@S8W6$MKIIX_LBC1VVV$@EFFV)+<GOLWT8<CM`FX7<*^+@>(!Q?%*F`WZ
    13 M1,KAFXGQS:P*3F\F[;.E?;:TP4H?K+3O5MKII9U>^E#+(-32KE$H4`4#57&@
    14 MRFPSAJELF!7:HX)[5/$>U;`';?6-7MM5W\R[?KA_VI`4]DWTZ/0J>N3>18_A
    15 MR^C+$7A]904G@#<DL@X%SJ(JP3I5HG58$5BG7O^F4KW#R+1W&'WWSO_).UCW
    16 MH9$ZYQ_KG3&(*@BB\I*W?@G%4`1J*)`<!@L9B3H#N;S#0)7%.#(/`]YB\KQY
    17 M6)EJ'@7,PRXS3S5M'EZ\F^?=//^1>=B4>3@HJCE%YN'`6WRB@XG-PU$/,V,>
    18 M/M7*)'F'SS0U_(U-C0ZPR<^X9JG3<>LIU":UZ\\V0&X]\[4*LZMYN)K#U3Q8
    19 M/5BLT>#U.H+V5-$+4-%WUERCQ,8RWEK*:4V@VH2#NEW@KDP``0D:*Z1%7:Y`
    20 M?=F,0L14>Y:D$#'3J(F%1BU2"!`%@WI)50@0!8-Z254($`6#>DE3"!`%@WIQ
    21 M"FE=SW=.(4`8W.HE5H@`Y:G`C9\``I*H\6M1YRY3&S_YYL9/SC1^\J+&+TRY
    22 M#";D"_*O.SJ:A/SKZ!BDT/@D;!T_F81;GX0;RWI_8G4R_X8IE\&$?$'^=<%*
    23 M'^RY)-SZ)-PDY-\PY3*8D),;O[#7`WM\1^,'FST.^L#8.A(4IQ(W?A(X2T:-
    24 M7SOQT4NF-GYE\5;KE#-]7[G0][4J;V'Z-1=MF(+U8[UQZ@GC^#UHO`<-]J">
    25 M^?"(]3NP>`<6[#`6N!H*3;NYZ<_+\-2%YZVU&+.VX[[V!=6;"`,1<2`B"$3`
    26 M<T0$=5L)"K,2-STET%4I8^'@;\]E:M-3JC<+9Z;G40L]3R0<H!,6RRA5.$`G
    27 M+)91FG"`3E@LH^\2#NB5ZA3A`)VP6$:SPE&@7E.XX%=`5RHJ^`^G?OFXZ3?_
    28 M!/)1J.S/1N&TF\R$=?`S?=U_-"?Q49_$O/4_SQ3W:J&XKXG4>YASO3I8I81?
    29 MV>V1SUV97^?'A-2,6^/C?&H&G]Y;R_C1,A[%B+_"AS&.&J#YT19U`8.@GJIP
    30 M05X!@BN*&33VQPQ6J"R?8[#BBPQ6,\5WM?17DBD&(]+B\BJ-05Q<+3#HFC!0
    31 M5RTS&)'&(*D+#%8@K5>X8*X\P:0H8@;'O(\8)`4JFV<8)`5=8I`4T\4Q*1:*
    32 MX^Z@3Z9DZAPL,_2YQJEV]`V,S!#H^J3:$8CHLP&F\98?8\Y((0`IJ%(C10E^
    33 M5C%GXZ>2"<Y0O3;'&2D6.2/351DA"U59HW+]L,XY+OQ3[QB&2ZV-I8Q&2_$'
    34 M$;^46C!M-#ZY$(**%D(`Q$1B#(WR,88$E2ZS&*IE#*<+%$(7"I080P@;^G"P
    35 MC"&$+?YF`#"D_G@G%.5O0@'$%.7OL?3#&-+4_$WH8OXF=#I_$[J0OX.SXP(`
    36 M[;J+T`-'*T.YDS``+IO(G?K<#7!C4=8<8/-@L2!5KKK\L/YD``,S'/"WVPP"
    37 MQN)T>0O2)2B)S?.<9X=CBX(I%$P9<#F:OZ#81X`CBZ$L1!B`BJ,L-.@HP(*3
    38 M12PX/8<%9S-8\#CQW`;?[8*B;P(+]_X4X!)AP<'1P_71X\8E&&N,S'\!,O_#
    39 3Y_"Z(NOK[(</_P*M9D<H.20`````
     2M'XL("`C9;%,``V-H87)S97)I97-?<"YR97,`[5I+;^,V$+[G5PB+'NR58(@<
     3M4@\$]J'H)4'1R_96I(&DS;9&@S1(9-3NKR_UH#CDB#+MW4,/>XHL<4CZ>W!F
     4MY'SZ]:>[7Z(H8KOHY[L?HP_M>[MYWM<?;F\^C4_X+E(W'_<O^W:UOKWI_D:[
     5M7=3\6;V]/[WMG]X?7S<O3_]LWMNJG8)@%TW78A.][5_^B-ZV/%FU29U4R6F=
     6M?'XU2\A=M/_\5#U'^VW%X[9.:A'7ZL*,R';1Z]_/I^C+=G7J1JP_KDYQ#6I4
     7M=]7=B5N^-N-S/>/==I]\,?>+8>./P\ZCU9V*>?R-)>QA.Z[9?^0/6S5CQ?L/
     8M\+"MXI.ZY/8PCH?Q;E@;#P/!'@AX('0#^YVKH7I;I8&+I9OHK_WS<_0V[9HQ
     9M])C;:%8*3QM-!N?09.(R-)F<1Y-E?C2K0DU1B;B5&M!^+S:@+!$/VU0C.V%:
     10M:3SKF/67:M0$ZP1H-8'97XQC!%E<X,4%IDGHY24)DCA(]CO.XK9["J?^3A^I
     11M<<@1/P6E#['+4TI?XQ#(F4M@P^,FICQR/L,C[XA4HWM.F[B=993#/*-<7,UH
     12MJS;9W6@TKQ5OU(V30DW=C-N!;QG*=_^5AT\JIHE/_0>?`L:'.`[&.*V)=I*"
     13MEL$0):PHT46=M"3:20E:!;4F?Q@N^^']9:8#,AV0Z8"L#^@OQMES/3C7@W,]
     14M.#>SYWIX0?`O,/Z%BW_1XQ\/H2/D)9FCQ'.4[AQE-X=V2JEG82F50FII(25B
     15M2(>9!B[4)XFLPR7R1D:LPY&S>!%@G3+0.I!:UJG6OQ>AW@$V[QW@W\X[W9:^
     16MQB\AIR6RR9)))HN$N&,T!=Z/Q/[UF61\B.,RX]]+W-)?7N<7>E[]S\T#J,H"
     17M0<P#R%N0G3</Y*'F*9!YX#+SE//F$>DW-`]\-\]W\YPSCT!%M>#$/`)Y2\QT
     18M,*YY!.EA/.81<ZU,D'>$IZD15S8U:H-U/+FF5LN?%.@C6//FT9X![:/E2FVI
     19M!9I6!U.L@%Y5V-$"1PLK6F"Q"!TO[7B)XZ45+[%$I*T05+=+VI5))"#)784T
     20MI,N5I"_S*$3.M6=!"I&>1DTN-&J.0I`H`.ME4D@35X$*0<(06B]G%()$`5@O
     21M80I!H@"LEU"%(%$`UHM7(1*5IY(V?A()*".-7T,Z]RRT\<NN;OPR3^.77=3X
     22MV2D7<$*^KO&SI5)[CA.:CU&W)TP;>*[QTZV>T!EZ.3$W)C'7-R$]'TK#PN3G
     23MY=:OT?FXOCG?^-GI%W!R#F[\[(P+.!]?E'Z=A`M60O:GWPP5IQEM_#+DK,QI
     24M_)J9EUY9:..7I]=:)_?T??E"W]<4<8/3;_>AL5.P6E8;IYU-OF8.[L[!K3F&
     25M;*R^B/)>=].<U5Q/:-L(N0>TJ8B-1J]8&Q'N1H2U$6%4:)^W9@;ISB"M&236
     26MH'WFYJ@PRVG3DR-=Y9DK'/KN.0]M>O+B:N%X>IYBH>=QA(-T`JZ,0H6#=`*N
     27MC+Y*..CM6Q4B'*03<&44)ARD$W!EY!5.@>JU@A;\!=)5X13\A[%?/B:GY%]+
     28M/@4I^Z-!.$T2==LZF)&F[C]VI^A1G:*B,8\]Q7VQ4-Q7+%-S=&=R>=!*L=^R
     29MZ^-:H+>R\5$+*[P_UE(X^E.Q:8VU!HZ:?V>?](6\O<]1!4>C`HT%JJ=*6I"7
     30MB."24P8[^U,&2U*6^Q@LQ2*#I:?X+I=^)9ECT"&-EE>A##8S!=4"@U,S5H<Q
     31MZ)`&F%0/@R5*ZR4MF$M#,$M3E\$A[Q,&64K*9@^#+.5+#+)TOCAFZ4)QW![4
     32MR11,70^)A[9&TU8%T39U296?-KVY,+XF75F<L50B4DBEQM(</2Y<SH97)3.<
     33MD7K-QQE+%SEC\U498PM565W$:K%V<ISU5F3<ADT9=\+H3[\FK*=./>O!U+LQ
     34MR84Q4K0PAB!F&<6P4S[%D)'2Q8MAL8SA?('"^$*!XF*(87-?'"Q@B&$##"G%
     35MD)OCG7&2OQE'$'.2OX?2CV+(0_,WXXOYF_'Y_,WX0OZVSHY``'7,Q>BAHQ5(
     36M[F2`P(69W*G.70LW<+)F#YL!"ZQ4N6KCP_IC!Q@:,0%_OXTP8."FRWN4+E%)
     37MW*VGP3H./Y=Q-(:C,6,Y<YR60$<6D"S$`$$E2!;J=61A(=@B%H*?PT*`!POA
     38M)IY[Z[V=5?3-83%]?XYPL;$0Z.@1ZNB9KG-TK3#J_@6H^P^?P_N*K6^C'V[^
     39)`X/,>R<Y)```
    4040`
    4141end

  • Tst/Short/charseries_p.stat

    r46c7c3 r984ff3  
    1 1 >> tst_memory_0 :: 1398762379:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:755604
    2 1 >> tst_memory_1 :: 1398762379:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2465792
    3 1 >> tst_memory_2 :: 1398762379:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2465792
    4 1 >> tst_timer_1 :: 1398762379:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:5400
     11 >> tst_memory_0 :: 1399642375:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:664412
     21 >> tst_memory_1 :: 1399642375:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2465792
     31 >> tst_memory_2 :: 1399642375:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2465792
     41 >> tst_timer_1 :: 1399642375:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2344

  • Tst/Short/ok_e.lst

    r46c7c3 r984ff3  
    5858modulo_s
    5959monodromy_s
    60 mpsr_s
    6160normal
    6261pAdd_s

  • Tst/Short/ok_g.lst

    r46c7c3 r984ff3  
    7070mora_8.tst
    7171mora_9.tst
    72 mpsr_s
    7372normal
    7473pAdd_s

  • Tst/Short/primdec_s.res.gz.uu

    r46c7c3 r984ff3  
    11begin 644 primdec_s.res.gz
    2 M'XL("';9(E,``W!R:6UD96-?<RYR97,`[5Q9;^2X$7[O7R$L\F!'DE<L'J(R
    3 M:`.;#;!88!$$._N2#)Q!7_;T2'8FMA<K]:\/25TD14I]>.Q!T`_NEJJ*K&*)
    4 MK/J*5/O];W_[^>]!$*#KX)>?_QI\]_ST?%5LE]^]F[UO.'`=".+'[</V^>+R
    5 MW4Q^!]?7P9?'[?UZL_KX=/6P^>/JZ7GQW+7`UT%W3:[J?AMQJV^J2;*KX''[
    6 M<!<\SC$D"8XN%M$R6D7K:!/=7D87/T;K+Y=]R_0ZV*XWBR+8SCL:OPH6L%K?
    7 M0M21LJM@:9)0(J66!@D)*6Q00`B9%"PH2S!(I-:WZ2FT5J=16*U-HZ1*F4;@
    8 M2I=&R&I5/0626E.O&U"M2:-`K4FC8*5)(Q"E22/06I-&4?:N0!LFI$J505*>
    9 M7JYTDO0TUBE8&FU2D%)GD&JK]<ZQ-)OH!&7V4J<HN[%.D7:+1MT$P6D_M;`P
    10 MM]@^/8LYB^;WVX<?GIY^^NU?%]M^.N&LFTYH_KA8;U>+0N>3I./#?//?W[>_
    11 M.F3$$FJTP+Q='I8>`IT,;BSY\=/B\6(;(4T(=T)DWO3S_I^6#+D.[A?/C]LR
    12 MN)^O1!<?GS:/V\V3H8S*58K>S3Z@F[_,Q&+X*"[FM_45W,S7,_'9,Y8=8]'U
    13 MP,2P10=;I`1NY87DJPLL*&MY001EW361"U,\ABVT3:!M`FT3L)IP:2?T=K;?
    14 MG<G0W2FSI0A8(J9$R[9[6AH]+<#5U=(0F0FC]S!JT]V(,:Z=_=[ZY6?"(4XE
    15 M*[W-$NN-%MI8I#NAMYN*6^PRP>S.Z&TF6CE-6!OC7('>2D8@W0@1;70C1#SH
    16 M;IFX)=U=JNSOA;FZ[Z4S>=\/%R5R@)HNA-2(-8)ZG,N^!X05H3<722=I]B'E
    17 M):T!D_>]4Y"TD;B\N#8<8OC#>"+=_,[D_,8GK$.:R!Z(?X4<,Z\]2\08W>WT
    18 M3%Y[5\AK3E[/^MD,!],V.F*1^E;(R`+1)ABQYCBU9BPSYV-J+!AN+HC,GMR)
    19 M-7G12TU>*K+:_;O9_0<4R3[5A?+__0>(5'_R0GJW:R$!X^;I^1\B<RT>JPL1
    20 MVB.9E5`G(/);OBV*X+%+593TV9K2#@@FXR"0LB$(I.D`!%(^`($T&X!`EM@@
    21 MD"$;!#(8@$"&;1#(B`T"&;5!(&,6"&2I!0(9MT$@RVP0F"8V"$R1#0)3L$!@
    22 MBBT0F!(;!*9T``)3-@"!:3H`@2FW06":V2"0)P,0R-$`!'*P0"#'-@CDQ`:!
    23 MG%H@D+-^6O%T"@1R/@X">38-`K-D&@1F:`\0F,$T",SP-`C,R*D@,*,'@\",
    24 M'0P"L_0,`L\@\/\7!&;\5!"896<0>`:!;P$"49(<"`)1@L9!($K`!H$HZ?<-
    25 M42*2>W=-M>O!+F$95='.AH8H&>X/HD2@D[*"'<1(?H5E55_NHDXBDQ)8LJ"G
    26 MRAW#LB*J54\4F*6$N@?0NI`[AX*`%5D3%_"E)#M))CL(H<3B6GY"6((B"[MZ
    27 M::(ZT6V@LGTE+,.Z,N$-$&0(F:#+3]%(&(]#PU2!?$HJFDK-XD-IEW;+@=;N
    28 MT#5)+[$JQ"65'Z22*CN_HJQ_1G)7<A11(4"CB`H!3"(J!'@242$@TX@*`9U$
    29 M5`C8)*)"D+H0U:X+V)49R35&C&;M.BM#U(5,)59U8HI%-%;9:>8Z$A,3MX%B
    30 MI9S,NP:.B2<?EU4#R<1\$%.A:Y_IL*SK%B<3T*MTQ9#2FSQV>G2I7&TM"5_N
    31 MJ$*D"Y;.8&T+>=-`9?8E5D'=<M"A(2<?AB?D5T:^+?MVV&NK92GS.#`VAE09
    32 MV:1TYD6[B=%B)O*(6Y$Q@FJGMZJ,Y"RG&)2[L!>ATA01($#\N1TYG`>=1=*K
    33 M?)_9HPT+'ZC0:BI59L?XNPHKTQ/>F3/Z$*1^D:'W>0Z6_IWU(,Q'X%Z;/C-V
    34 M,PD+]C'"L"$^]`''7:+'R`5\O>'2BH/8W<:.I,YPB6$",)\4UUYV9OHBX-$Q
    35 MRQ,$#X_-KQ[\WC(F>>+DD8G(%^%>*]QXPIWY(,S)N',.;7RAOUI8&S%C)*R]
    36 M=#)MHPO6:Z*JK8EVZD(()FUQ)!]%4QY5ZJ)AXIZ)HR8LR$M<=T(46UU`W8#4
    37 M+5O]9*+"PG108>%^/Q3AM*^JY`%YO^7NKJBT(_*NHB+)5$5%D*NB(N"HJ`AV
    38 M5U2$."LJ0@^IJ`BS*RJ2NBHJPO>IJ$AV2$5%D[&*2AZP=-<P55')LY.QBDH>
    39 MI$Q55)1.5U3R:&6RHJ+I=$5%^71%1;.WJJA8<EI%Q9"SHF)PKJB\<N>*ZEQ1
    40 MG2NJ$RHJAM^JHF+D7%&=*ZIS176NJ/Q6'%]1,?JV%15C$Q452P<5%>,]>I<O
    41 MZ-155#`/FM.I[N6EZ"[Z%'V.\JCH*JNN8=J_73SOB:)RNBCB_/+?65=)R)=Y
    42 M:AK_L_A>7O8<W')2R5EI'-)RF.2L-0YM.51R-AJ'M1PB.;<:)VTY6'+N-`YO
    43 M.2`YGS1.UG`D_7,/^WG2^TZ^`C1>^7`8KWPXGJY\.)FN?#C=H_+A;+KRX>ET
    44 MY<.YJ_+)XZ(3R/0"16/(%XWZRD-GH(G:0\HZEJ@D^_)T#C'D15@8T>>SOQ]+
    45 MRI>+<QSC'(H0YP7$!79TWL:(3WOKLAKYLG9.8I+C(F1"/XC+`H<%F3:@#:YW
    46 MQ]IC]>'#`CF-:4Z*$"7"2(C%%P@+:5Z0N*`'FQDT.>#VA:RVNO3ACIS%+*=B
    47 M$'(H8@;)L6!Y!V(8+"]H6+!3QZ)NV<U\\W6&9FGPH9D\C=.<%2$@,5Z(L1RP
    48 M0$U4#)C$@@ABK&E>L+A(7WC`ZC:]F:]?9?R60A\<RWG,\U2X@PNG0$SE+,!A
    49 MF@BO$'F'A3L$#X1#>%ZD8<&_KE?4+;^9K]["299^'X3,LSC+N8B%3'@.8DZ$
    50 MZ\1B`>D[$LMO(KS&9=!B,99A*PVSO.!QD;VJ\]1M=C-??@.^M,QI$R"XRF,]
    51 M0^*)*O:(#/G9'+>1,$_(D%:WGTQW.O+GRV7(<=5WYI/TIM.OEB$/,N_6G&B3
    52 MV?6U,N0I@]"7!]L_V;Y1AGS!D>J!(#TX]WX;&?+KN4./B_S85/Q-9LA7\]G2
    53 M3"TG9N9O,4,2?:,ESL.>0R>V0.0O.ZPMD*S_I37*^%7P_??!P^:/8%,N[K\4
    54 MF^#V\3_WP4^;1U$`K[__X>YA\]0)M_LEO\[K]W@OH^)+VRTDVJ9(1>(2QV54
    55 M9N*CRN*JE^I_2^/>-X!D?-\`DNE]`TBF]PT@V6/?`)+I?0-(IO<-(''N&V@[
    56 M_=XC`!@<DX:HY]H[_P838K4W275^;#5F/F;3.-7Y8*OF7FY<:=NOKM:5?AK4
    57 M"A@6J'U5-"90S>1/2/P"C1+#>Q`/E9`Q@;H/.B(25MUC-G9_U!H(*]*>4;,J
    58 M5B\30!57[5&U6"!M8V3L$/6-P=$8!HVG=I&LLP='H+..S'S(V=[D]QS'#*6\
    59 M)SSQ7AT.I;S'W+"?B0XQ_UE/:!O@/A!T"_KP9#^3)KMU"7H/:PQ!V.?`#$;.
    60 MHP=G/['/2J>@]Q`FWK=;IZ#WS&7X7*M])T"]UGTKR!:/]^VWB2&^!>68,LYS
    61 M2;=@%]_VZ'?$$T[1+C3N,7%#C\TNP2Z>[K,@O#:[1=N`Z-Q5L!.K)^E:&=>1
    62 MV8B77SO.FW2;R6OD74?2-O.N*R7Q$0GI8BOW#C/G6.XU5X(_<XYEWWB8>VW\
    63 M8&9>&YN82==JVS[FJ;VAX].5;[D>G:[\Z_3H=.7/@">EJP-6YR'IRIL%3P]4
    64 MODQX8FSU9<03PY\O(YX>_?Q9\<0D[LV*IV9Q?U8\+8OON]H.S>)[O5OI[-"4
    65 M\.=`TTW[HK<V(!I[!8K3O)=1=:]CZ"]CU.]@U`^C>0U#UAWJCA@\]19&[=W[
    66 M#]1@T?[M#68PF&*H%FEC3\U(#47<X/%&D;C,#$;6-I)#2@R6N-6L0_7@X^8:
    67 MNO4B;D%CU5Z`Q@JDO8^"<,-2-T1CD'ZLB&ITV@ZU?1`36S.`^I?[0?[D5_[3
    68 61OEO&7]_ND"7[_XT^Q_V$PH'ZE$`````
     2M'XL(""[;;%,``W!R:6UD96-?<RYR97,`[5S=;^.X$7_W7R$<^I!45DX<?HCJ
     3MP@&N5^!PP*$H;N^E7:0+.W:R7LGI-LGA)/_U)2F+(BE2\D<V611^V$2:&7*&
     4M0W+F-Z2R[W_[V\]_CZ((74>__/S7Z+OGI^>K<KWX[MWD_8X#UY$@?EP_K)\O
     5M+M]-Y._H^CKZ\KC>+%>W'Y^N'E9_7#T]SY]U"WP=Z6=RU?2[$W?ZIH8DNXH>
     6MUP_WT>,,0YKBZ<5\NIC>3I?3U?3N<GKQXW3YY;)KF5U'Z^5J7D;KF:;QJV@.
     7MM\L[F&I2?A4M;!)*I=3"(B$AA2T*""&;@@5E`1:)-/I6'84VZ@P*:[09E$PI
     8M,PA<Z3((>:.JHT#::.IT`VHT&11H-!D4K#09!*(T&03::#(HRMY;,(8)F5)E
     9MD92G%[<F27H:FQ0LC;8I2*FS2(W59N=8FDU,@C)[85*4W=BD2+M%([U`<-8M
     10M+2S,+==/SV+-HMEF_?##T]-/O_WK8MTM)YSKY81FC_/E^G9>FGR2:C[,5O_]
     11M??VK1T9LH9T6F+7;P]%#0,O@G24_?IH_7JRGR!#"6HC,=OV\_Z<C0ZZCS?SY
     12M<5U%F]FMZ.+CT^IQO7JRE%&Y2]&[R0=T\Y>)V`P?Q</LKGF"F]ER(GYVC(5F
     13MS'4/3`Q;=+!&2N!./DB^>L""LI0/1%"6NHG<F&(:UM`V@;8)M$W`:<*EG=#9
     14MV?[6)H-^4V9+$7!$;(F6[?:TL'J:@Z^KA24R$4;O8=1*OX@Q+KW]WH7E)\(A
     15M7B6W9IL%-AO-C;%(=T)G-Q6OV&>"W9W5VT2T\IJPM,9Y"V8K&8%,(T2T,8T0
     16M\4"_,O%*]%NF[.^$N7KOI'/YW@T7I7*`ABZ$U(@-@IK.1=<#PHK0F8NDDPS[
     17MD/*2T8#)]\XI2-I(?%Y<6@ZQ_&'-B%[?N5S?^(1]2%/9`PGOD&/6=6"+6*.[
     18M&U_)R^`.><W%&]@_J_Y@VD9';-+0#AG8(,8"(\X:I\Z*9?9ZS*P-P^T-D;N+
     19M.W46+WJIQ4M%5MN\FVP^H*EJ+1^D+\4#2,I</:@9:5M(P+AZ>OZ'R%SSQ_I"
     20MA/:IS$I("XC\5JS+,GK4J8J2+EM3JH%@.@P"*>N#0)KU0"#E/1!(\QX(9*D+
     21M`AER02"#'@ADV`6!C+@@D%$7!#+F@$"6.2"0<1<$LMP%@5GJ@L`,N2`P`P<$
     22M9M@!@1EQ06!&>R`P8ST0F&4]$)AQ%P1FN0L">=H#@1SU0"`'!P1R[()`3EP0
     23MR*D#`CGKEA7/QD`@Y\,@D.?C(#!/QT%@CO8`@3F,@\`<CX/`G)P*`G-Z,`C,
     24MV<$@,,_.(/`,`O]_06#.3P6!>7X&@6<0^!8@$*7I@2`0I6@8!*(47!"(TN[<
     25M$*4BN>MG:CSW3@FK:3W=NM`0I?WS090*=%+5L(4$R5]Q53>/VZF6R*4$EBSH
     26MJ/+$L*J):M41!6:IH.D!C"[DR:$@8$4VQ`5\J<A6DLD68JBP>)8_(:Y`D85=
     27MG311G9@V4-F^%I9A4YGP!@@RQ$S0Y4_12!B/8\M4@7PJ*II*S>*'TB[ME@-M
     28MW&%JDEYB=8PK*G^06JK4?D5Y-T?R5'(042%`@X@*`8PB*@1X%%$A(..("@$=
     29M150(V"BB0I#Y$-56!^S:CN0&(T&3=I]5,=(A4XG56DRQB,&JM&9N(C&Q<'=0
     30MK)*+>;N#8V+FDZK>03*Q'L12T.US$Y;I;G$Z`KTJ7PRI@LEC:T:7VM?6D0CE
     31MCCI&IF#E#=:N4#`-U'9?8A<T+7L=6G)R,@(AO[;R;=6UPT%;'4M9P(&)-:3:
     32MRB:5-R^Z3:P6$Y%'_(JL$=1;LU5M)6>YQ*#:QIT(E::(``'BG]^1_76@+9)>
     33MY?NL'F-8^$"%3E.I,C_&WW5<VYX(KIS!29#Z18;>9QX<_5MG(NPI\._-D!G;
     34MB80%^QAAV9`<.L&)3O08^8#O:X1+#".`^<"X=GP`"<2WK[G4`T'P\-C\ZL'O
     35M+6-2($X>F8A"$>ZUPDT@W-D38:^=K7=HPQO]U<+:@!D#8>VEDVD;7;!9$]5M
     36M3;15#T(P;8LC.16[\DAN5/F(&SG<L;%BJX==6Z*8Z@%:BF*U^LE(A85IK\+"
     37MW7DHPEE75<D+\N[(W5]1&5?DNJ(BZ5A%19"OHB+@J:@(]E=4A'@K*D(/J:@(
     38M<RLJDODJ*L+WJ:A(?DA%1=.ABDI>L.AG&*NHY-W)4$4E+U+&*BI*QRLJ>;4R
     39M6E'1;+RBHGR\HJ+Y6U54+#VMHF+(6U$Q.%=40;ES176NJ,X5U0D5%<-O55$Q
     40M<JZHSA75N:(Z5U1A*XZOJ!@]O*)*ZOCE2BK&1DHJEO5**L8[^"Z_T&G*J&@6
     41M[:ZG]-=+T_OII^GG:3$M=6FE&V;=Y\6SCBA*IXLR*2[_G>M20G[-T]#XG\7O
     42MQ67'P2TGDYQ;@T-:#I.<I<&A+8=*SLK@L)9#).?.X&0M!TO.O<'A+0<DYY/!
     43MR7<<2?_<X7Z>=KZ3WP`-ESX<ADL?CL=+'T[&2Q].]RA].!LO?7@V7OIP[BM]
     44MBJ34`KE9H1@,^:515WJ8##12?$A9SQZ5Y%"B+B"!HHQ+*_Q\#O?C2(72=8$3
     45M7$`9XZ*$I,2>SML@\6EO74ZC4-HN2$(*7,9,Z`?Q6.*X).,&M-'U_EA[G#Y"
     46M8*"@"2U(&:-4&`F)^`7"0EJ4)"GIP69&NR1P]T)6.UV&@$?!$E90,0@Y%+&"
     47MY%BP?`,Q#%:4-"[9J6-1K^QFMOHZ0W,TA.!,D259P<H8D!@O)%@.6,`F*@9,
     48M$D$$,=:L*%E29B\\8/6:W<R6KS)^1V$(CQ4\X44FW,&%4R"A<A7@.$N%5XA\
     49MP\(=@@?"(;PHL[CD7]<KZI7?S&[?PDF._A"&+/(D+[B(A4QX#A).A.O$9@'I
     50M.Y+(WT1XC<N@Q1(LPU86YT7)DS)_5>>IU_QFMO@&?.F8TR9`\-7'9H;$(V7L
     51M$1GRLSUN*V&>D"&=;C_9[O3DSY?+D,.J[^V9#*;3KY8A#S+OSEYHH]GUM3+D
     52M*8,PMP?;/]F^489\P9&:@2`[./=^&QGRZ[G#C(O\V%3\36;(5_/9PDXM)V;F
     53M;S%#$O.D)2GBCD-'CD#DGW8X1R!Y]Z?6*.=7T???1P^K/Z)5-=]\*5?1W>-_
     54M-M%/JT=1`"^__^'^8?6DA=OSDE]GS8>\E]/R2]LMI,:A2$V2"B?5M,K%CSI/
     55MZDZJ^V,:_[D!I,/G!I".GQM`.GYN`.D>YP:0CI\;0#I^;@"I]]S`.,.W[P`,
     56M!O0._F/4<=VC?XL)B3J<I"8_<1JS$'/7.#/YX*KF0:XZZ&LC@Z]U;5X'M0*6
     57M!>I@%0T)U!/Y-R1A@9T2RWN0])60(8&F#SH@$M=ZFJW3'[4'XIJTE]2L3M37
     58M!%`G=7M7+39(VQA9)T1=8_`TAE[CL5,DY_+!$^B<.[/@)9!SRA^X`NI+!2^Y
     59MD[TZ[$L%[[EA/Q,]8N'+GM@UP'\CZ!<,X<EN)8UVZQ,,WM98@K#/)1T,7$CW
     60M+G^2D)5>P>`M3+)OMU[!X*5+?U[K?1=`L]=#.\@53_;M=Q=#0AO*LV2\%Y-^
     61M01W?]NAWP!->41T:]UBX<<!FGZ".I_MLB*#-?M$V('I/%=S$:F4/-[M9><--
     62MG';.<)O:Z:*?UZRTZTE)V4#[9F;XD(;:3;V]A.6F7F_20R'OM#L00AYJ!7#8
     63M2];Z"B((._%V7#W-8V=#XWG/O98/;].3MG]XEYX4K4(;],3@&MJ?)Z:"`_+@
     64M@=L^F`M/C%2AG'ABT`[EQ)>(V<&\>!K8&,B+)V&C@;QX-(P+YL2CL68P$QX-
     65MAX,YT-XX^Z*W-B!:9P6*L_LPH_9]X;[[]$)3<??=.^FHZ@.,NNF+*G+2/(*>
     66MU<T'UC%8PT@:1K:SI-J]Z:6Z^<`M%E>?B,AMM_F06YQ\UTB.);4XXG77J'G=
     67M#3NIVE<]2@0VR_C$'V&;A4T;$;&9Q%9(VZ]44.,./1$C1S.`NJ_[0?[-K_Q?
     687&^7_R_C[TP6Z?/>GR?\`UY"`)NM1````
    6969`
    7070end

  • Tst/Short/primdec_s.stat

    r46c7c3 r984ff3  
    1 1 >> tst_memory_0 :: 1394792822:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:631020
    2 1 >> tst_memory_1 :: 1394792822:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2621440
    3 1 >> tst_memory_2 :: 1394792822:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:3117056
    4 1 >> tst_timer_1 :: 1394792822:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:464
     11 >> tst_memory_0 :: 1399642925:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:631708
     21 >> tst_memory_1 :: 1399642925:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2621440
     31 >> tst_memory_2 :: 1399642925:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:3133440
     41 >> tst_timer_1 :: 1399642925:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:436

  • Tst/regress.cmd

    r46c7c3 r984ff3  
    386386}
    387387
    388 sub Set_withMP
    389 {
    390   if (! $withMP)
    391   {
    392     $withMP = "no";
    393     open(MP_TEST, ">MPTest");
    394     print(MP_TEST "system(\"with\", \"MP\"); \$");
    395     close(MP_TEST);
    396     mysystem("$singular -qt MPTest > withMPtest");
    397     if (open(MP_TEST, "<withMPtest"))
    398     {
    399       $_ = <MP_TEST>;
    400       $withMP = "yes" if (/^1/);
    401       close(MP_TEST);
    402     }
    403     mysystem("$rm -f withMPtest MPTest");
    404   }
    405 }
    406 
    407 
    408 sub MPok
    409 {
    410   local($root) = $_[0];
    411 
    412   if (! open(TST_FILE, "<$root.tst"))
    413   {
    414     print (STDERR "Can not open $root.tst for reading\n");
    415     return (0);
    416   }
    417   while (<TST_FILE>)
    418   {
    419     if (/\"MP.+:.*\"/)
    420     {
    421       &Set_withMP;
    422       return (0) if ($withMP eq "no");
    423     }
    424   }
    425   return (1);
    426 }
    427 
    428388sub Diff
    429389{
    … …  
    636596    $test_files{$test_file} = 1;
    637597    return (1);
    638   }
    639 
    640   # ignore MP stuff, if this singular does not have MP
    641   if (! MPok($root))
    642   {
    643     print "--- $root " unless ($verbosity == 0);
    644     print "Warning: $root not tested: needs MP\n";
    645     testIgnored($test_file, "Warning: $root not tested: needs MP");
    646     $test_files{$test_file} = 0;
    647     return (0);
    648598  }
    649599

  • Tst/regress.lst

    r46c7c3 r984ff3  
    16011601Old/m23si.tst
    16021602Old/m24si.tst
    1603 Old/m25si.tst
    16041603Old/m27si.tst
    16051604Old/m28si.tst

  • dox/Doxyfile.in

    r46c7c3 r984ff3  
    633633@abs_top_srcdir@/resources/ \
    634634@abs_top_srcdir@/factory/ \
    635 @abs_top_srcdir@/factory/libfac/ \
    636 @abs_top_srcdir@/factory/libfac/charset/ \
    637 @abs_top_srcdir@/factory/libfac/factor/ \
    638635@abs_top_srcdir@/factory/templates/ \
    639636@abs_top_srcdir@/factory/include/factory/ \

  • factory/COPYING

    r46c7c3 r984ff3  
    1010                        Copyright (C) 1991-2013
    1111
    12   Characteristic sets by: Michael Messollen <mmessollen@web.de>
     12  Characteristic sets and factorization over algebraic function fields:
     13                   Michael Messollen <mmessollen@web.de>
    1314                        Copyright (C) 1996-2010
    1415
    … …  
    2728Their copyrights and licences can be found in the accompanying files
    2829which are distributed along with these packages.
     30
     31Files which contain code written by M. Messollen or contain code derived from
     32code written by M. Messollen contain respective details.
    2933
    3034This program is distributed in the hope that it will be useful, but

  • factory/Makefile.am

    r46c7c3 r984ff3  
    11ACLOCAL_AMFLAGS = -I ../m4
    22
    3 SUBDIRS=include/factory libfac
     3SUBDIRS=include/factory
    44
    55AM_CPPFLAGS = -I${builddir}/include -I${srcdir}/include -I${srcdir} \
    … …  
    99lib_LTLIBRARIES = libfactory.la
    1010
    11 libfactory_la_LIBADD     = ${builddir}/libfac/libfac.la \
    12 $(RESOURCES_LIBS) $(OMALLOC_LIBS) \
     11libfactory_la_LIBADD     =$(RESOURCES_LIBS) $(OMALLOC_LIBS) \
    1312$(FLINT_LIBS) $(NTL_LIBS) $(GMP_LIBS)
    1413
    … …  
    2120                cf_algorithm.cc \
    2221                cf_char.cc \
     22                cfCharSets.cc \
     23                cfCharSetsUtil.cc \
    2324                cf_chinese.cc \
    2425                cf_cyclo.cc \
    … …  
    5354                facAbsFact.cc \
    5455                facAlgExt.cc \
     56                facAlgFunc.cc \
     57                facAlgFuncUtil.cc \
    5558                facBivar.cc \
    5659                fac_ezgcd.cc \
    … …  
    97100                canonicalform.h \
    98101                cf_algorithm.h \
     102                cfCharSets.h \
     103                cfCharSetsUtil.h \
    99104                cf_cyclo.h \
    100105                cf_defs.h \
    … …  
    123128                facAbsFact.h \
    124129                facAlgExt.h \
     130                facAlgFunc.h \
     131                facAlgFuncUtil.h \
    125132                facBivar.h \
    126133                facFactorize.h \

  • factory/canonicalform.h

    r46c7c3 r984ff3  
    367367typedef Array<CanonicalForm> CFArray;
    368368typedef Matrix<CanonicalForm> CFMatrix;
     369typedef List<CFList> ListCFList;
     370typedef ListIterator<CFList> ListCFListIterator ;
     371typedef List<int> IntList;
     372typedef ListIterator<int> IntListIterator;
     373typedef List<Variable> Varlist;
     374typedef ListIterator<Variable> VarlistIterator;
     375typedef Array<int> Intarray;
    369376//}}}
    370377

  • factory/configure.ac

    r46c7c3 r984ff3  
    391391AC_DEFINE_UNQUOTED([FACTORYVERSION], "$factory_version")
    392392
    393 AH_TEMPLATE([HAVE_LIBFAC], [have libfac])
    394 AC_DEFINE_UNQUOTED([HAVE_LIBFAC], 1)
    395 
    396393AH_TEMPLATE([FACTORYCONFIGURATION], [factory configuration])
    397394AC_DEFINE_UNQUOTED([FACTORYCONFIGURATION], "$factory_configuration")
    … …  
    402399
    403400
    404 AC_CONFIG_FILES([Makefile include/factory/Makefile libfac/Makefile factory.pc]) #  ftest/GNUmakefile
     401AC_CONFIG_FILES([Makefile include/factory/Makefile factory.pc]) #  ftest/GNUmakefile
    405402AC_OUTPUT
    406403

  • factory/factory.template

    r46c7c3 r984ff3  
    113113#include "algext.h"
    114114
     115/*MAKEHEADER PUBLIC ONLY*/
     116#include "facAlgFunc.h"
     117
     118/*MAKEHEADER PUBLIC ONLY*/
     119#include "cfCharSetsUtil.h"
     120
     121/*MAKEHEADER PUBLIC ONLY*/
     122#include "cfCharSets.h"
     123
     124
    115125#endif /* ! INCL_FACTORY_H */

  • kernel/GBEngine/f5gb.cc

    r46c7c3 r984ff3  
    128128    //Print("%p\n",gPrev->getFirst());
    129129    //pWrite(gPrev->getFirst()->getPoly());
    130     poly tempNF =   kNF(gbPrev,currQuotient,f_i);
     130    poly tempNF =   kNF(gbPrev,currRing->qideal,f_i);
    131131    f_i         =   tempNF;
    132132    //gPrev->insert(ONE,i,f_i);
    … …  
    642642            testNode        =   testNode->getNext();
    643643        }
    644         poly temp   =   kNF(testId,currQuotient,u1);
     644        poly temp   =   kNF(testId,currRing->qideal,u1);
    645645        //pWrite(temp);
    646646        for(i=0;i<IDELEMS(testId);i++) {
    … …  
    10961096        //sPolyList->print();
    10971097        sPolyList->setFirst(temp->getNext());
    1098         poly tempNF = kNF(gbPrev,currQuotient,temp->getPoly());
     1098        poly tempNF = kNF(gbPrev,currRing->qideal,temp->getPoly());
    10991099        if(NULL != tempNF) {
    11001100            pNorm(tempNF);
    … …  
    11491149        //}
    11501150        //pWrite(temp->getPoly());
    1151         //poly tempNF = kNF(gbPrev,currQuotient,temp->getPoly());
     1151        //poly tempNF = kNF(gbPrev,currRing->qideal,temp->getPoly());
    11521152        //Print("!!!\n");
    11531153        //if(NULL != tempNF) {
    … …  
    17581758                    pNorm(temp);
    17591759