Changeset f9b0bd in git


Ignore:
Timestamp:
Jul 28, 2016, 11:55:04 AM (8 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
7b03761efc366bdaf44e4ac64daa8ae01254efc5e20ddd2f0d01da7ec5ab00e4404f601d29910ba5
Parents:
7b9b8e5baba86b2ea7dc3d91652cd2ae491db203
Message:
chg: Print -> PrintS, PrintLn if possible
Files:
37 edited

Legend:

Unmodified
Added
Removed

  • Singular/dyn_modules/syzextra/syzextra.cc

    r7b9b8e5 rf9b0bd  
    26842684        if( OPT__DEBUG )
    26852685        {
    2686           Print("_FindReducer::Test SYZTERM: q == syzterm !:((, syzterm is: ");
     2686          PrintS("_FindReducer::Test SYZTERM: q == syzterm !:((, syzterm is: ");
    26872687          dPrint(syzterm, r, r, 0);
    26882688        }
    … …  
    27872787        if( OPT__DEBUG )
    27882788        {
    2789           Print("_FindReducer::Test SYZTERM: q == syzterm !:((, syzterm is: ");
     2789          PrintS("_FindReducer::Test SYZTERM: q == syzterm !:((, syzterm is: ");
    27902790          dPrint(syzterm, r, r, 0);
    27912791        }
    … …  
    28972897        if( OPT__DEBUG )
    28982898        {
    2899           Print("_FindReducer::Test SYZTERM: q == syzterm !:((, syzterm is: ");
     2899          PrintS("_FindReducer::Test SYZTERM: q == syzterm !:((, syzterm is: ");
    29002900          dPrint(syzterm, r, r, 0);
    29012901        }
    … …  
    30003000        if( OPT__DEBUG )
    30013001        {
    3002           Print("_FindReducer::Test SYZTERM: q == syzterm !:((, syzterm is: ");
     3002          PrintS("_FindReducer::Test SYZTERM: q == syzterm !:((, syzterm is: ");
    30033003          dPrint(syzterm, r, r, 0);
    30043004        }

  • Singular/extra.cc

    r7b9b8e5 rf9b0bd  
    23162316           else if (strcmp(s,"posInT19")==0)
    23172317             test_PosInT=posInT19;
    2318            else Print("valid posInT:0,1,2,11,110,13,15,17,17_c,19,_EcartFDegpLength,_FDegpLength,_pLength,_EcartpLength\n");
     2318           else PrintS("valid posInT:0,1,2,11,110,13,15,17,17_c,19,_EcartFDegpLength,_FDegpLength,_pLength,_EcartpLength\n");
    23192319         }
    23202320         else
    … …  
    31053105          p=(poly)h->CopyD();
    31063106          h=h->next;
    3107           //        Print("poly is done\n");
     3107          //        PrintS("poly is done\n");
    31083108        }
    31093109        else return TRUE;
    … …  
    31133113          q = I->m;
    31143114          h=h->next;
    3115           //        Print("ideal is done\n");
     3115          //        PrintS("ideal is done\n");
    31163116        }
    31173117        else return TRUE;
    … …  
    31203120          is=(int)((long)(h->Data()));
    31213121          //        res->rtyp=INT_CMD;
    3122           //        Print("int is done\n");
     3122          //        PrintS("int is done\n");
    31233123          //        res->rtyp=IDEAL_CMD;
    31243124          if (rIsPluralRing(currRing))
    … …  
    31303130              pl[k] = pLength(I->m[k]);
    31313131            }
    3132             Print("starting redRat\n");
     3132            PrintS("starting redRat\n");
    31333133            //res->data = (char *)
    31343134            redRat(&p, q, pl, (int)IDELEMS(I),is,currRing);

  • Singular/fevoices.cc

    r7b9b8e5 rf9b0bd  
    106106  p->prev=currentVoice;
    107107  currentVoice=p;
    108   //Print("Next:");
     108  //PrintS("Next:");
    109109}
    110110
    … …  
    158158  yylineno=currentVoice->start_lineno;
    159159  //Voice *p=currentVoice;
    160   //Print("-----------------\ncurr:");
     160  //PrintS("-----------------\ncurr:");
    161161  //do
    162162  //{
    … …  
    165165  //}
    166166  //while (p!=NULL);
    167   //Print("----------------\n");
     167  //PrintS("----------------\n");
    168168  return FALSE;
    169169}
    … …  
    225225  //printf("start buffer typ %d\n",t);
    226226  //Voice *p=currentVoice;
    227   //Print("-----------------\ncurr:");
     227  //PrintS("-----------------\ncurr:");
    228228  //do
    229229  //{
    … …  
    232232  //}
    233233  //while (p!=NULL);
    234   //Print("----------------\n");
     234  //PrintS("----------------\n");
    235235}
    236236
    … …  
    244244  //  typ,BT_name[typ], currentVoice);
    245245  //Voice *p=currentVoice;
    246   //Print("-----------------\ncurr:");
     246  //PrintS("-----------------\ncurr:");
    247247  //do
    248248  //{
    … …  
    251251  //}
    252252  //while (p!=NULL);
    253   //Print("----------------\n");
     253  //PrintS("----------------\n");
    254254  if (typ == BT_break)  // valid inside for, while. may skip if, else
    255255  {
    … …  
    350350  //{
    351351  //Voice *p=currentVoice;
    352   //Print("-----------------\ncurr:");
     352  //PrintS("-----------------\ncurr:");
    353353  //do
    354354  //{
    … …  
    357357  //}
    358358  //while (p!=NULL);
    359   //Print("----------------\n");
     359  //PrintS("----------------\n");
    360360  //}
    361361  if (currentVoice!=NULL)

  • Singular/iparith.cc

    r7b9b8e5 rf9b0bd  
    24602460    if (hasFlag(u, FLAG_STD)) setFlag(&uuAsLeftv,FLAG_STD);
    24612461    assumeStdFlag(&uuAsLeftv);
    2462     Print("// NOTE: computation of Hilbert series etc. is being\n");
    2463     Print("//       performed for generic fibre, that is, over Q\n");
     2462    PrintS("// NOTE: computation of Hilbert series etc. is being\n");
     2463    PrintS("//       performed for generic fibre, that is, over Q\n");
    24642464    intvec *module_w=(intvec*)atGet(&uuAsLeftv,"isHomog",INTVEC_CMD);
    24652465    intvec *iv=hFirstSeries(uu,module_w,currRing->qideal);
    … …  
    39243924    if (hasFlag(v, FLAG_STD)) setFlag(&vvAsLeftv,FLAG_STD);
    39253925    assumeStdFlag(&vvAsLeftv);
    3926     Print("// NOTE: computation of degree is being performed for\n");
    3927     Print("//       generic fibre, that is, over Q\n");
     3926    PrintS("// NOTE: computation of degree is being performed for\n");
     3927    PrintS("//       generic fibre, that is, over Q\n");
    39283928    intvec *module_w=(intvec*)atGet(&vvAsLeftv,"isHomog",INTVEC_CMD);
    39293929    scDegree(vv,module_w,currRing->qideal);
    … …  
    42964296    if (hasFlag(v, FLAG_STD)) setFlag(&vvAsLeftv,FLAG_STD);
    42974297    assumeStdFlag(&vvAsLeftv);
    4298     Print("// NOTE: computation of Hilbert series etc. is being\n");
    4299     Print("//       performed for generic fibre, that is, over Q\n");
     4298    PrintS("// NOTE: computation of Hilbert series etc. is being\n");
     4299    PrintS("//       performed for generic fibre, that is, over Q\n");
    43004300    intvec *module_w=(intvec*)atGet(&vvAsLeftv,"isHomog",INTVEC_CMD);
    43014301    //scHilbertPoly(vv,currRing->qideal);
    … …  
    43164316  if (rField_is_Ring_Z(currRing))
    43174317  {
    4318     Print("// NOTE: computation of Hilbert series etc. is being\n");
    4319     Print("//       performed for generic fibre, that is, over Q\n");
     4318    PrintS("// NOTE: computation of Hilbert series etc. is being\n");
     4319    PrintS("//       performed for generic fibre, that is, over Q\n");
    43204320  }
    43214321  res->data=(void *)hSecondSeries((intvec *)v->Data());
    … …  
    59325932    if (hasFlag(u, FLAG_STD)) setFlag(&uuAsLeftv,FLAG_STD);
    59335933    assumeStdFlag(&uuAsLeftv);
    5934     Print("// NOTE: computation of Hilbert series etc. is being\n");
    5935     Print("//       performed for generic fibre, that is, over Q\n");
     5934    PrintS("// NOTE: computation of Hilbert series etc. is being\n");
     5935    PrintS("//       performed for generic fibre, that is, over Q\n");
    59365936    intvec *module_w=(intvec*)atGet(&uuAsLeftv,"isHomog",INTVEC_CMD);
    59375937    intvec *iv=hFirstSeries(uu,module_w,currRing->qideal,wdegree);
    … …  
    91199119  //if(i>=0 && i<sArithBase.nCmdUsed)
    91209120  //  return i;
    9121   //Print("RET-2\n");
     9121  //PrintS("RET-2\n");
    91229122  return -2;
    91239123}

  • Singular/iplib.cc

    r7b9b8e5 rf9b0bd  
    12301230              proc->data.s.example_lineno, proc->data.s.example_start);
    12311231      else if(proc->language==LANG_C)
    1232         Print("type: object\n");
     1232        PrintS("type: object\n");
    12331233    }
    12341234  }

  • Singular/links/sing_dbm.cc

    r7b9b8e5 rf9b0bd  
    123123      if (!SI_LINK_CLOSE_P(l))
    124124      {
    125         if (!dbClose(l)) {Print("cannot close link!\n");}
     125        if (!dbClose(l)) {PrintS("cannot close link!\n");}
    126126      }
    127127      //(SI_LINK_CLOSE_P(l)) automatically
    128128      if (dbOpen(l, SI_LINK_READ)) return NULL;
    129129    }
    130   if (SI_LINK_RW_OPEN_P(l)) {Print("I/O Error!\n");}
     130  if (SI_LINK_RW_OPEN_P(l)) {PrintS("I/O Error!\n");}
    131131
    132132  if(key!=NULL)
    … …  
    210210  if (strcmp(l->mode,"rw")!=0) // r-mode
    211211    {
    212       Print("Write error on readonly source\n");
     212      PrintS("Write error on readonly source\n");
    213213    }
    214214  else //rw-mode
    … …  
    218218        if (!SI_LINK_CLOSE_P(l))
    219219        {
    220           if (!dbClose(l)) {Print("close error\n");};
     220          if (!dbClose(l)) {PrintS("close error\n");};
    221221        }
    222         if (!dbOpen(l,SI_LINK_WRITE)) {Print("open_for_write error\n");}
     222        if (!dbOpen(l,SI_LINK_WRITE)) {PrintS("open_for_write error\n");}
    223223      }
    224224    }
    … …  
    238238        ret  = gdbm_store(db->db, d_key, d_value, GDBM_REPLACE);
    239239//         db->actual=d_key;
    240         if (ret==-1) {Print("reader calls gdbm_store!");}
     240        if (ret==-1) {PrintS("reader calls gdbm_store!");}
    241241        if (ret==0)
    242242          { b=FALSE; }

  • Singular/walk.cc

    r7b9b8e5 rf9b0bd  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id$ */
    54/*
    65* ABSTRACT: Implementation of the Groebner walk
    … …  
    20001999  {
    20012000#ifndef SING_NDEBUG
    2002     Print("\n//MwalkNextWeightCC: t_nenner=0\n");
     2001    PrintS("\n//MwalkNextWeightCC: t_nenner=0\n");
    20032002#endif
    20042003    delete diff_weight;
    … …  
    20952094    mpz_out_str( stdout, 10, t_nenner);
    20962095    Print(" * %d)", (*curr_weight)[j]);
    2097     Print(" + ("); mpz_out_str( stdout, 10, t_zaehler);
     2096    PrintS(" + ("); mpz_out_str( stdout, 10, t_zaehler);
    20982097    Print(" * %d) =  ",  (*diff_weight)[j]);
    20992098    mpz_out_str( stdout, 10, s_nenner);
    … …  
    23952394  {
    23962395#ifndef SING_NDEBUG
    2397     Print("\n//MwalkNextWeightCC: t_nenner=0\n");
     2396    PrintS("\n//MwalkNextWeightCC: t_nenner=0\n");
    23982397#endif
    23992398    delete diff_weight;
    … …  
    24792478    mpz_out_str( stdout, 10, t_nenner);
    24802479    Print(" * %d)", (*curr_weight)[j]);
    2481     Print(" + ("); mpz_out_str( stdout, 10, t_zaehler);
     2480    PrintS(" + ("); mpz_out_str( stdout, 10, t_zaehler);
    24822481    Print(" * %d) =  ",  (*diff_weight)[j]);
    24832482    mpz_out_str( stdout, 10, s_nenner);
    … …  
    66556654      if(printout > 1)
    66566655      {
    6657         Print("\n Mpwalk: there is a polynomial in Gomega with at least 3 monomials.\n");
     6656        PrintS("\n Mpwalk: there is a polynomial in Gomega with at least 3 monomials.\n");
    66586657      }
    66596658      // low-dimensional facet of the cone
    … …  
    71037102        if(printout > 0)
    71047103        {
    7105           Print("\n//** rec_fractal_call: Wrong cone. Tau doesn't stay in the correct cone.\n");
     7104          PrintS("\n//** rec_fractal_call: Wrong cone. Tau doesn't stay in the correct cone.\n");
    71067105        }
    71077106
    … …  
    71257124          if(printout > 0)
    71267125          {
    7127             Print("\n//** rec_fractal_call: Updated vectors are equal to the old vectors.\n");
     7126            PrintS("\n//** rec_fractal_call: Updated vectors are equal to the old vectors.\n");
    71287127          }
    71297128          delete Xtautmp;
    … …  
    72787277      if(printout > 1)
    72797278      {
    7280         Print("\n//** rec_fractal_call: Maximal recursion depth.\n");
     7279        PrintS("\n//** rec_fractal_call: Maximal recursion depth.\n");
    72817280      }
    72827281#ifdef TIME_TEST

  • kernel/GBEngine/f5gb.cc

    r7b9b8e5 rf9b0bd  
    278278    //Print("IN F5INC\n");
    279279    /*
    280     Print("\n\n\nRULES: \n");
     280    PrintS("\n\n\nRULES: \n");
    281281        RNode* tempR    =   rules->getFirst();
    282282        Print("%p\n",tempR);
    … …  
    330330      pSetCoeff(lcm,nOne);
    331331      pSetm(lcm);
    332       Print("LCM:   ");
     332      PrintS("LCM:   ");
    333333      pWrite(lcm);
    334334      if(pDeg(lcm) <= pDeg(gPrev->getLast()->getPoly())) {
    … …  
    372372    temp  = temp->getNext();
    373373  }
    374   Print("------------------\n");
     374  PrintS("------------------\n");
    375375  return isDGb;
    376376}
    … …  
    680680    //Print("------------------------------IN CRITERION 2/1-----------------------------------------\n");
    681681    /*
    682     Print("RULES: \n");
     682    PrintS("RULES: \n");
    683683        RNode* tempR    =   rules->getFirst();
    684684        Print("%p\n",tempR);
    … …  
    793793    //Print("LAST RuleOld TESTED: %p",testedRuleOld);
    794794    /*
    795     Print("RULES: \n");
     795    PrintS("RULES: \n");
    796796        RNode* tempR    =   rules->getFirst();
    797797        while(NULL != tempR) {
    … …  
    10401040             //numberRejectedF5CriticalPairs == 7) {
    10411041            /*
    1042             Print("--------------------------------- rejected F5-critical pair-------------------------------------\n");
     1042            PrintS("--------------------------------- rejected F5-critical pair-------------------------------------\n");
    10431043            pWrite(pHead(ppMult_qq(temp->getT1(),temp->getLp1Poly())));
    1044             Print("Label: ");
     1044            PrintS("Label: ");
    10451045            pWrite(ppMult_qq(temp->getT1(),temp->getLp1Term()));
    10461046            Print("%d\n",temp->getDel());
    1047             Print("Comes from:\n ");
     1047            PrintS("Comes from:\n ");
    10481048            pWrite(pHead(temp->getLp1Poly()));
    1049             Print("Label: ");
     1049            PrintS("Label: ");
    10501050            pWrite(temp->getLp1Term());
    10511051            Print("%d\n",temp->getLp1Index());
    10521052            pWrite(pHead(temp->getLp2Poly()));
    1053             Print("Label: ");
     1053            PrintS("Label: ");
    10541054            pWrite(temp->getLp2Term());
    10551055            Print("%d\n",temp->getLp2Index());
    10561056            //Print("--------------------------------------LIST OF GB PAIRS REJECTED-----------------------------------------\n");
    10571057            //rejectedGBList->print();
    1058             Print("--------------------------------------------------------------------------------------------------------\n");
     1058            PrintS("--------------------------------------------------------------------------------------------------------\n");
    10591059            //if(temp->getLp1Index() < 7) {
    10601060              sPolyList->insertByLabel(ppMult_qq(temp->getT1(),temp->getLp1Term()),temp->getLp1Index(),sp,tempRule->getRuleOld());
    … …  
    15311531            //pDelete(&redPoly);
    15321532        }
    1533         else {
    1534             Print("\nELEMENT ADDED TO GPREV: ");
     1533        else
     1534        {
     1535            PrintS("\nELEMENT ADDED TO GPREV: ");
    15351536            pNorm(redPoly);
    1536               if(highestDegree < pDeg(redPoly)) {
    1537                   highestDegree   = pDeg(redPoly);
    1538               }
     1537            if(highestDegree < pDeg(redPoly))
     1538            {
     1539              highestDegree   = pDeg(redPoly);
     1540            }
    15391541            pWrite(pHead(redPoly));
    15401542            //pWrite(l->getTerm());
    … …  
    18891891==========================================================================
    18901892*/
    1891 ideal F5main(ideal id, ring r, int opt, int plus, int termination) {
    1892   switch(opt) {
     1893ideal F5main(ideal id, ring r, int opt, int plus, int termination)
     1894{
     1895  switch(opt)
     1896  {
    18931897    case 0:
    1894       Print("\nComputations are done by the standard F5 Algorithm");
     1898      PrintS("\nComputations are done by the standard F5 Algorithm");
    18951899      break;
    18961900    case 1:
    1897       Print("\nComputations are done by the variant F5R of the F5 Algorithm");
     1901      PrintS("\nComputations are done by the variant F5R of the F5 Algorithm");
    18981902      break;
    18991903    case 2:
    1900       Print("\nComputations are done by the variant F5C of the F5 Algorithm");
     1904      PrintS("\nComputations are done by the variant F5C of the F5 Algorithm");
    19011905      break;
    19021906    default:
    … …  
    19441948        if(NULL != id->m[j]) {
    19451949            if(pComparePolys(id->m[j],ONE)) {
    1946                 Print("One Polynomial in Input => Computations stopped\n");
     1950                PrintS("One Polynomial in Input => Computations stopped\n");
    19471951                ideal idNew = idInit(1,1);
    19481952                idNew->m[0] = ONE;

  • kernel/GBEngine/f5lists.cc

    r7b9b8e5 rf9b0bd  
    392392
    393393// for debugging
    394 void LNode::print() {
     394void LNode::print()
     395{
    395396    LNode* temp = this;
    396     Print("___________________List of S-polynomials______________________:\n");
     397    PrintS("___________________List of S-polynomials______________________:\n");
    397398    while(NULL != temp && NULL != temp->data) {
    398399        Print("Index: %d\n",temp->getIndex());
    399         Print("Term: ");
     400        PrintS("Term: ");
    400401        pWrite(temp->getTerm());
    401         Print("Poly: ");
     402        PrintS("Poly: ");
    402403        pWrite(temp->getPoly());
    403404        temp = temp->next;
    404405    }
    405     Print("_______________________________________________________________\n");
     406    PrintS("_______________________________________________________________\n");
    406407}
    407408
    … …  
    883884
    884885// for debugging
    885 void CNode::print() {
     886void CNode::print()
     887{
    886888    CNode* temp = this;
    887     Print("___________________List of critical pairs______________________:\n");
    888     while(NULL != temp) {
     889    PrintS("___________________List of critical pairs______________________:\n");
     890    while(NULL != temp)
     891    {
    889892        pWrite(ppMult_qq(temp->getT1(),temp->getLp1Term()));
    890893        Print("LP1 Index: %d\n",temp->getLp1Index());
    891         Print("T1: ");
     894        PrintS("T1: ");
    892895        pWrite(temp->getT1());
    893896        Print("%p\n",temp->getT1());
    894         Print("LP1 Term: ");
     897        PrintS("LP1 Term: ");
    895898        pWrite(temp->getLp1Term());
    896         Print("LP1 Poly: ");
     899        PrintS("LP1 Poly: ");
    897900        pWrite(temp->getLp1Poly());
    898901        Print("LP2 Index: %d\n",temp->getLp2Index());
    899         Print("T2: ");
     902        PrintS("T2: ");
    900903        pWrite(temp->getT2());
    901904        Print("%p\n",temp->getT2());
    902         Print("LP2 Term: ");
     905        PrintS("LP2 Term: ");
    903906        pWrite(temp->getLp2Term());
    904         Print("LP2 Poly: ");
     907        PrintS("LP2 Poly: ");
    905908        pWrite(temp->getLp2Poly());
    906         Print("\n");
     909        PrintLn();
    907910        temp = temp->next;
    908911    }

  • kernel/GBEngine/gr_kstd2.cc

    r7b9b8e5 rf9b0bd  
    12041204          {
    12051205#ifdef PDEBUG
    1206              Print("unit element detected:");
     1206             PrintS("unit element detected:");
    12071207             p_wrp(strat->P.p,currRing);
    12081208#endif
    … …  
    12401240            PrintLn();
    12411241#if MYTEST
    1242             Print("s: "); pWrite(strat->P.p);
     1242            PrintS("s: "); pWrite(strat->P.p);
    12431243#endif
    12441244

  • kernel/GBEngine/kstd1.cc

    r7b9b8e5 rf9b0bd  
    26462646  {
    26472647    /* error: no local ord yet with shifts */
    2648     Print("No local ordering possible for shifts");
     2648    PrintS("No local ordering possible for shifts");
    26492649    return(NULL);
    26502650  }

  • kernel/GBEngine/kstd2.cc

    r7b9b8e5 rf9b0bd  
    712712//#if 1
    713713#ifdef DEBUGF5
    714   Print("------- IN REDSIG -------\n");
     714  PrintS("------- IN REDSIG -------\n");
    715715  Print("p: ");
    716716  pWrite(pHead(h->p));
    717   Print("p1: ");
     717  PrintS("p1: ");
    718718  pWrite(pHead(h->p1));
    719   Print("p2: ");
     719  PrintS("p2: ");
    720720  pWrite(pHead(h->p2));
    721   Print("---------------------------\n");
     721  PrintS("---------------------------\n");
    722722#endif
    723723  poly h_p;
    … …  
    790790#ifdef DEBUGF5
    791791    Print("BEFORE REDUCTION WITH %d:\n",ii);
    792     Print("--------------------------------\n");
     792    PrintS("--------------------------------\n");
    793793    pWrite(h->sig);
    794794    pWrite(strat->T[ii].sig);
    … …  
    797797    pWrite(pHead(h->p2));
    798798    pWrite(pHead(strat->T[ii].p));
    799     Print("--------------------------------\n");
     799    PrintS("--------------------------------\n");
    800800    printf("INDEX OF REDUCER T: %d\n",ii);
    801801#endif
    … …  
    19791979      //#if 1
    19801980#ifdef DEBUGF5
    1981       Print("SIG OF NEXT PAIR TO HANDLE IN SIG-BASED ALGORITHM\n");
    1982       Print("-------------------------------------------------\n");
     1981      PrintS("SIG OF NEXT PAIR TO HANDLE IN SIG-BASED ALGORITHM\n");
     1982      PrintS("-------------------------------------------------\n");
    19831983      pWrite(strat->P.sig);
    19841984      pWrite(pHead(strat->P.p));
    19851985      pWrite(pHead(strat->P.p1));
    19861986      pWrite(pHead(strat->P.p2));
    1987       Print("-------------------------------------------------\n");
     1987      PrintS("-------------------------------------------------\n");
    19881988#endif
    19891989      if (pNext(strat->P.p) == strat->tail)
    … …  
    20352035        //#if 1
    20362036#ifdef DEBUGF5
    2037         Print("Poly before red: ");
     2037        PrintS("Poly before red: ");
    20382038        pWrite(pHead(strat->P.p));
    20392039        pWrite(strat->P.sig);
    … …  
    20682068#ifdef DEBUGF5
    20692069    if (red_result != 0) {
    2070         Print("Poly after red: ");
     2070        PrintS("Poly after red: ");
    20712071        pWrite(pHead(strat->P.p));
    20722072        pWrite(strat->P.GetLmCurrRing());
    … …  
    23112311    printf("---------------------------\n");
    23122312    Print(" %d. ELEMENT ADDED TO GCURR:\n",strat->sl+1);
    2313     Print("LEAD POLY:  "); pWrite(pHead(strat->S[strat->sl]));
    2314     Print("SIGNATURE:  "); pWrite(strat->sig[strat->sl]);
     2313    PrintS("LEAD POLY:  "); pWrite(pHead(strat->S[strat->sl]));
     2314    PrintS("SIGNATURE:  "); pWrite(strat->sig[strat->sl]);
    23152315#endif
    23162316      /*
    … …  
    23582358//#if 1
    23592359#ifdef DEBUGF5
    2360         Print("ADDING STUFF TO SYZ :  ");
     2360        PrintS("ADDING STUFF TO SYZ :  ");
    23612361        //pWrite(strat->P.p);
    23622362        pWrite(strat->P.sig);
    … …  
    27302730//#if 1
    27312731#ifdef DEBUGF5
    2732     Print("NEXT PAIR TO HANDLE IN INTERRED ALGORITHM\n");
    2733     Print("-------------------------------------------------\n");
     2732    PrintS("NEXT PAIR TO HANDLE IN INTERRED ALGORITHM\n");
     2733    PrintS("-------------------------------------------------\n");
    27342734    pWrite(pHead(strat->P.p));
    27352735    pWrite(pHead(strat->P.p1));
    27362736    pWrite(pHead(strat->P.p2));
    27372737    printf("%d\n",strat->tl);
    2738     Print("-------------------------------------------------\n");
     2738    PrintS("-------------------------------------------------\n");
    27392739#endif
    27402740    if (pNext(strat->P.p) == strat->tail)
    … …  
    27882788
    27892789#ifdef DEBUGF5
    2790       Print("Poly before red: ");
     2790      PrintS("Poly before red: ");
    27912791      pWrite(strat->P.p);
    27922792#endif
    … …  
    28712871//#if 1
    28722872#ifdef DEBUGF5
    2873         Print("ELEMENT ADDED TO GCURR DURING INTERRED: ");
     2873        PrintS("ELEMENT ADDED TO GCURR DURING INTERRED: ");
    28742874        pWrite(pHead(strat->S[strat->sl]));
    28752875        pWrite(strat->sig[strat->sl]);
    … …  
    29282928//#if 1
    29292929#if DEBUGF5
    2930   Print("------------------- STRAT S ---------------------\n");
     2930  PrintS("------------------- STRAT S ---------------------\n");
    29312931  cc = 0;
    29322932  while (cc<strat->tl+1)
    … …  
    29372937    cc++;
    29382938  }
    2939   Print("-------------------------------------------------\n");
    2940   Print("------------------- STRAT T ---------------------\n");
     2939  PrintS("-------------------------------------------------\n");
     2940  PrintS("------------------- STRAT T ---------------------\n");
    29412941  cc = 0;
    29422942  while (cc<strat->tl+1)
    … …  
    29472947    cc++;
    29482948  }
    2949   Print("-------------------------------------------------\n");
    2950   Print("------------------- STRAT L ---------------------\n");
     2949  PrintS("-------------------------------------------------\n");
     2950  PrintS("------------------- STRAT L ---------------------\n");
    29512951  cc = 0;
    29522952  while (cc<strat->Ll+1)
    … …  
    29592959    cc++;
    29602960  }
    2961   Print("-------------------------------------------------\n");
     2961  PrintS("-------------------------------------------------\n");
    29622962  printf("F5C DONE\nSTRAT SL: %d -- %d\n",strat->sl, strat->currIdx);
    29632963#endif

  • kernel/GBEngine/kutil.cc

    r7b9b8e5 rf9b0bd  
    21032103//#if 1
    21042104#ifdef DEBUGF5
    2105   Print("P1  ");
     2105  PrintS("P1  ");
    21062106  pWrite(pHead(p));
    2107   Print("P2  ");
     2107  PrintS("P2  ");
    21082108  pWrite(pHead(strat->S[i]));
    2109   Print("M1  ");
     2109  PrintS("M1  ");
    21102110  pWrite(m1);
    2111   Print("M2  ");
     2111  PrintS("M2  ");
    21122112  pWrite(m2);
    21132113#endif
    … …  
    21202120//#if 1
    21212121#ifdef DEBUGF5
    2122   Print("----------------\n");
     2122  PrintS("----------------\n");
    21232123  pWrite(pSigMult);
    21242124  pWrite(sSigMult);
    2125   Print("----------------\n");
     2125  PrintS("----------------\n");
    21262126  Lp.checked  = 0;
    21272127#endif
    … …  
    36603660#ifdef OLI_DEBUG
    36613661    Print("%d, (%d, %d), ind = (%d, %d)\n", cabsind, cexp[1], cexp[2], cind[1], cind[2]);
    3662     Print("zPoly : ");
     3662    PrintS("zPoly : ");
    36633663    wrp(zeroPoly);
    3664     Print("\n");
     3664    PrintLn();
    36653665#endif
    36663666    enterOneZeroPairRing(zeroPoly, t_p, p, ecart, strat, atR);
    … …  
    37203720#ifdef OLI_DEBUG
    37213721    Print("%d, (%d, %d), ind = (%d, %d)\n", cabsind, cexp[1], cexp[2], cind[1], cind[2]);
    3722     Print("zPoly : ");
     3722    PrintS("zPoly : ");
    37233723    wrp(zeroPoly);
    3724     Print("\n");
     3724    PrintLn();
    37253725#endif
    37263726    // Add to ideal
    … …  
    58795879//#if 1
    58805880#ifdef DEBUGF5
    5881   Print("syzygy criterion checks:  ");
     5881  PrintS("syzygy criterion checks:  ");
    58825882  pWrite(sig);
    58835883#endif
    … …  
    59115911//#if 1
    59125912#ifdef DEBUGF5
    5913   Print("--- syzygy criterion checks:  ");
     5913  PrintS("--- syzygy criterion checks:  ");
    59145914  pWrite(sig);
    59155915#endif
    … …  
    59615961//#if 1
    59625962#ifdef DEBUGF5
    5963     Print("checking with:  ");
     5963    PrintS("checking with:  ");
    59645964    pWrite(strat->sig[k]);
    59655965    pWrite(pHead(strat->S[k]));
    … …  
    59765976  }
    59775977#ifdef DEBUGF5
    5978   Print("ALL ELEMENTS OF S\n----------------------------------------\n");
     5978  PrintS("ALL ELEMENTS OF S\n----------------------------------------\n");
    59795979  for(int kk = 0; kk<strat->sl+1; kk++)
    59805980  {
    59815981    pWrite(pHead(strat->S[kk]));
    59825982  }
    5983   Print("------------------------------\n");
     5983  PrintS("------------------------------\n");
    59845984#endif
    59855985  return FALSE;
    … …  
    80368036    pWrite(strat->sig[k]);
    80378037  }
    8038   Print("--- LIST S END ---\n");
     8038  PrintS("--- LIST S END ---\n");
    80398039#endif
    80408040}

  • kernel/GBEngine/nc.cc

    r7b9b8e5 rf9b0bd  
    3939      p_Test(p, currRing);
    4040#if 0
    41       Print("p: "); // !
     41      PrintS("p: "); // !
    4242      p_Write(p, currRing);
    4343#endif
    … …  
    5757        p_Test(q, currRing);
    5858#if 0
    59         Print("Reducing p: "); // !
     59        PrintS("Reducing p: "); // !
    6060        p_Write(p, currRing);
    61         Print("With q: "); // !
     61        PrintS("With q: "); // !
    6262        p_Write(q, currRing);
    6363#endif
    … …  
    7373          p_Write(q, currRing);
    7474
    75           Print("With p:");
     75          PrintS("With p:");
    7676          p_Write(p, currRing);
    7777
    … …  
    8787          p_Test(q, currRing);
    8888#if 0
    89           Print("reductum q/p: ");
     89          PrintS("reductum q/p: ");
    9090          p_Write(q, currRing);
    9191
    92           // Print("With J!\n");
     92          // PrintS("With J!\n");
    9393#endif
    9494#endif
    … …  
    100100          p_Test(q, currRing);
    101101#if 0
    102           Print("NF(J/currRing->qideal)=> q: "); // !
     102          PrintS("NF(J/currRing->qideal)=> q: "); // !
    103103          p_Write(q, currRing);
    104104#endif
    … …  
    151151    idTest(J); // in currRing!
    152152#if 0
    153     Print("J:");
     153    PrintS("J:");
    154154    idPrint(J);
    155155    PrintLn();
    … …  
    162162    idTest(K); // in currRing!
    163163#if 0
    164     Print("+K:");
     164    PrintS("+K:");
    165165    idPrint(K);
    166166    PrintLn();
    … …  
    191191    idTest(J); // in currRing!
    192192#if 0
    193     Print("J:");
     193    PrintS("J:");
    194194    idPrint(J);
    195195    PrintLn();
    … …  
    208208  if (IDELEMS(s)!=IDELEMS(T))
    209209  {
    210     Print("ideals of diff. size!!!");
     210    PrintS("ideals of diff. size!!!");
    211211  }
    212212#endif
    … …  
    344344      s_h2=idCopy(s_h3);
    345345      idDelete(&s_h3);
    346       Print("...computing Syz");
     346      PrintS("...computing Syz");
    347347      s_h3 = kStd(s_h2, currRing->qideal,(tHomog)FALSE,NULL,NULL,syzcomp,idI);
    348348      SI_RESTORE_OPT1(save1);
    … …  
    380380  if (flagcnt == N)
    381381  {
    382     Print("the input is a two--sided ideal");
     382    PrintS("the input is a two--sided ideal");
    383383    return(I);
    384384  }
    … …  
    407407      res->m[i-1]=p;
    408408    }
    409     Print("final std");
     409    PrintS("final std");
    410410    res = kStd(res, currRing->qideal,testHomog,NULL,NULL,0,0,NULL);
    411411    idSkipZeroes(res);
    … …  
    414414  else
    415415  {
    416     Print("No syzygies");
     416    PrintS("No syzygies");
    417417    return(I);
    418418  }

  • kernel/GBEngine/test.cc

    r7b9b8e5 rf9b0bd  
    440440  poly pp = pp_Mult_qq( p, p, R);
    441441
    442   Print("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
    443 
    444   Print("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
     442  PrintS("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
     443
     444  PrintS("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
    445445
    446446
    … …  
    467467
    468468  // print p1 + p2
    469   Print("p1: "); pWrite0(p1);
    470   Print(" + p2: "); pWrite0(p2);
    471   Print("  ---- >>>> ");
     469  PrintS("p1: "); pWrite0(p1);
     470  PrintS(" + p2: "); pWrite0(p2);
     471  PrintS("  ---- >>>> ");
    472472
    473473  // compute p1+p2

  • kernel/combinatorics/test.cc

    r7b9b8e5 rf9b0bd  
    306306  poly pp = pp_Mult_qq( p, p, R);
    307307
    308   Print("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
    309 
    310   Print("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
     308  PrintS("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
     309
     310  PrintS("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
    311311
    312312
    … …  
    333333
    334334  // print p1 + p2
    335   Print("p1: "); pWrite0(p1);
    336   Print(" + p2: "); pWrite0(p2);
    337   Print("  ---- >>>> ");
     335  PrintS("p1: "); pWrite0(p1);
     336  PrintS(" + p2: "); pWrite0(p2);
     337  PrintS("  ---- >>>> ");
    338338
    339339  // compute p1+p2

  • kernel/fglm/test.cc

    r7b9b8e5 rf9b0bd  
    304304  poly pp = pp_Mult_qq( p, p, R);
    305305
    306   Print("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
    307 
    308   Print("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
     306  PrintS("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
     307
     308  PrintS("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
    309309
    310310
    … …  
    331331
    332332  // print p1 + p2
    333   Print("p1: "); pWrite0(p1);
    334   Print(" + p2: "); pWrite0(p2);
    335   Print("  ---- >>>> ");
     333  PrintS("p1: "); pWrite0(p1);
     334  PrintS(" + p2: "); pWrite0(p2);
     335  PrintS("  ---- >>>> ");
    336336
    337337  // compute p1+p2

  • kernel/groebner_walk/test.cc

    r7b9b8e5 rf9b0bd  
    304304  poly pp = pp_Mult_qq( p, p, R);
    305305
    306   Print("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
    307 
    308   Print("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
     306  PrintS("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
     307
     308  PrintS("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
    309309
    310310
    … …  
    331331
    332332  // print p1 + p2
    333   Print("p1: "); pWrite0(p1);
    334   Print(" + p2: "); pWrite0(p2);
    335   Print("  ---- >>>> ");
     333  PrintS("p1: "); pWrite0(p1);
     334  PrintS(" + p2: "); pWrite0(p2);
     335  PrintS("  ---- >>>> ");
    336336
    337337  // compute p1+p2

  • kernel/linear_algebra/test.cc

    r7b9b8e5 rf9b0bd  
    304304  poly pp = pp_Mult_qq( p, p, R);
    305305
    306   Print("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
    307 
    308   Print("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
     306  PrintS("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
     307
     308  PrintS("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
    309309
    310310
    … …  
    331331
    332332  // print p1 + p2
    333   Print("p1: "); pWrite0(p1);
    334   Print(" + p2: "); pWrite0(p2);
    335   Print("  ---- >>>> ");
     333  PrintS("p1: "); pWrite0(p1);
     334  PrintS(" + p2: "); pWrite0(p2);
     335  PrintS("  ---- >>>> ");
    336336
    337337  // compute p1+p2

  • kernel/maps/fast_maps.cc

    r7b9b8e5 rf9b0bd  
    395395  // do the actual evaluation
    396396  maPoly_Eval(mp, src_r, dest_id, dest_r, length);
    397   if (TEST_OPT_PROT) Print(".");
     397  if (TEST_OPT_PROT) PrintS(".");
    398398
    399399  // collect the results back into an ideal
    400400  ideal res_dest_id = maIdeal_2_Ideal(mideal, dest_r);
    401   if (TEST_OPT_PROT) Print(".");
     401  if (TEST_OPT_PROT) PrintS(".");
    402402
    403403  // convert result back to image_r
    … …  
    415415    res_image_id = res_dest_id;
    416416
    417   if (TEST_OPT_PROT) Print(".");
     417  if (TEST_OPT_PROT) PrintS(".");
    418418
    419419  // clean-up the rings
    … …  
    421421
    422422  if (TEST_OPT_PROT)
    423     Print("\n");
     423    PrintLn();
    424424
    425425  idTest(res_image_id);
    … …  
    559559      if (cost > next_print_cost)
    560560      {
    561         Print("-");
     561        PrintS("-");
    562562        next_print_cost += total_cost;
    563563      }

  • kernel/maps/test.cc

    r7b9b8e5 rf9b0bd  
    304304  poly pp = pp_Mult_qq( p, p, R);
    305305
    306   Print("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
    307 
    308   Print("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
     306  PrintS("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
     307
     308  PrintS("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
    309309
    310310
    … …  
    331331
    332332  // print p1 + p2
    333   Print("p1: "); pWrite0(p1);
    334   Print(" + p2: "); pWrite0(p2);
    335   Print("  ---- >>>> ");
     333  PrintS("p1: "); pWrite0(p1);
     334  PrintS(" + p2: "); pWrite0(p2);
     335  PrintS("  ---- >>>> ");
    336336
    337337  // compute p1+p2

  • kernel/numeric/test.cc

    r7b9b8e5 rf9b0bd  
    304304  poly pp = pp_Mult_qq( p, p, R);
    305305
    306   Print("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
    307 
    308   Print("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
     306  PrintS("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
     307
     308  PrintS("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
    309309
    310310
    … …  
    331331
    332332  // print p1 + p2
    333   Print("p1: "); pWrite0(p1);
    334   Print(" + p2: "); pWrite0(p2);
    335   Print("  ---- >>>> ");
     333  PrintS("p1: "); pWrite0(p1);
     334  PrintS(" + p2: "); pWrite0(p2);
     335  PrintS("  ---- >>>> ");
    336336
    337337  // compute p1+p2

  • kernel/oswrapper/test.cc

    r7b9b8e5 rf9b0bd  
    304304  poly pp = pp_Mult_qq( p, p, R);
    305305
    306   Print("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
    307 
    308   Print("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
     306  PrintS("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
     307
     308  PrintS("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
    309309
    310310
    … …  
    331331
    332332  // print p1 + p2
    333   Print("p1: "); pWrite0(p1);
    334   Print(" + p2: "); pWrite0(p2);
    335   Print("  ---- >>>> ");
     333  PrintS("p1: "); pWrite0(p1);
     334  PrintS(" + p2: "); pWrite0(p2);
     335  PrintS("  ---- >>>> ");
    336336
    337337  // compute p1+p2

  • kernel/spectrum/test.cc

    r7b9b8e5 rf9b0bd  
    304304  poly pp = pp_Mult_qq( p, p, R);
    305305
    306   Print("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
    307 
    308   Print("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
     306  PrintS("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
     307
     308  PrintS("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
    309309
    310310
    … …  
    331331
    332332  // print p1 + p2
    333   Print("p1: "); pWrite0(p1);
    334   Print(" + p2: "); pWrite0(p2);
    335   Print("  ---- >>>> ");
     333  PrintS("p1: "); pWrite0(p1);
     334  PrintS(" + p2: "); pWrite0(p2);
     335  PrintS("  ---- >>>> ");
    336336
    337337  // compute p1+p2

  • kernel/test.cc

    r7b9b8e5 rf9b0bd  
    550550  poly pp = pp_Mult_qq( p, p, R);
    551551
    552   Print("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
    553 
    554   Print("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
     552  PrintS("p: "); p_Write0(p, R); Print(", deg(p): %ld", p_Totaldegree(p, R)); assume( 1 == p_Totaldegree(p, R) );
     553
     554  PrintS("; p*p : "); p_Write0(pp, R); Print("deg(pp): %ld\n", p_Totaldegree(pp, R)); assume( 2 == p_Totaldegree(pp, R) );
    555555
    556556
    … …  
    577577
    578578  // print p1 + p2
    579   Print("p1: "); pWrite0(p1);
    580   Print(" + p2: "); pWrite0(p2);
    581   Print("  ---- >>>> ");
     579  PrintS("p1: "); pWrite0(p1);
     580  PrintS(" + p2: "); pWrite0(p2);
     581  PrintS("  ---- >>>> ");
    582582
    583583  // compute p1+p2

  • libpolys/coeffs/bigintmat.cc

    r7b9b8e5 rf9b0bd  
    16771677#if 0
    16781678    char * s;
    1679     ::Print("mat over Z is \n");
     1679    ::PrintS("mat over Z is \n");
    16801680    ::Print("%s\n", s = nCoeffString(basecoeffs()));
    16811681    omFree(s);
    … …  
    17441744              // get the gcd in position and the 0 in the other:
    17451745#ifdef CF_DEB
    1746               ::Print("applying trafo\n");
     1746              ::PrintS("applying trafo\n");
    17471747              StringSetS("");
    17481748              n_Write(co1, basecoeffs()); StringAppendS("\t");
    … …  
    18061806
    18071807#if 0
    1808     ::Print("hnf over Z is \n");
     1808    ::PrintS("hnf over Z is \n");
    18091809    Print();
    18101810    ::Print("\n(%d x %d)\n", rows(), cols());
    … …  
    19651965  //b can have multiple columns.
    19661966#if 0
    1967   Print("reduce_mod_howell: A:\n");
     1967  PrintS("reduce_mod_howell: A:\n");
    19681968  A->Print();
    1969   Print("\nb:\n");
     1969  PrintS("\nb:\n");
    19701970  b->Print();
    19711971#endif
    … …  
    19811981
    19821982#if 0
    1983     Print("\nx:\n");
     1983    PrintS("\nx:\n");
    19841984    x->Print();
    1985     Print("\neps:\n");
     1985    PrintS("\neps:\n");
    19861986    eps->Print();
    1987     Print("\n****************************************\n");
     1987    PrintS("\n****************************************\n");
    19881988#endif
    19891989    return;
    … …  
    20362036  delete B;
    20372037#if 0
    2038   Print("\nx:\n");
     2038  PrintS("\nx:\n");
    20392039  x->Print();
    2040   Print("\neps:\n");
     2040  PrintS("\neps:\n");
    20412041  eps->Print();
    2042   Print("\n****************************************\n");
     2042  PrintS("\n****************************************\n");
    20432043#endif
    20442044}
    … …  
    20942094        n_InpMult(den, dz, Z);
    20952095#if 0
    2096         Print("den increasing to ");
     2096        PrintS("den increasing to ");
    20972097        n_Print(den, Z);
    2098         Print("\n");
     2098        PrintLn();
    20992099#endif
    21002100      }
    … …  
    21082108#if 0
    21092109  L->Print();
    2110   Print("\n * 1/");
     2110  PrintS("\n * 1/");
    21112111  n_Print(den, Z);
    2112   Print("\n");
     2112  PrintLn();
    21132113#endif
    21142114  return den;
    … …  
    24292429  x->simplifyContentDen(&den);
    24302430#if 0
    2431   Print("sol = 1/");
     2431  PrintS("sol = 1/");
    24322432  n_Print(den, R);
    2433   Print(" *\n");
     2433  PrintS(" *\n");
    24342434  x->Print();
    2435   Print("\n");
     2435  PrintLn();
    24362436#endif
    24372437  return den;
    … …  
    24412441{
    24422442#if 0
    2443   Print("Solve Ax=b for A=\n");
     2443  PrintS("Solve Ax=b for A=\n");
    24442444  A->Print();
    2445   Print("\nb = \n");
     2445  PrintS("\nb = \n");
    24462446  b->Print();
    2447   Print("\nx = \n");
     2447  PrintS("\nx = \n");
    24482448  x->Print();
    2449   Print("\n");
     2449  PrintLn();
    24502450#endif
    24512451
    … …  
    25652565      Print("\n2:x: %ld\n", x);
    25662566      x->Print();
    2567       Print("\n");
     2567      PrintLn();
    25682568#endif
    25692569    }
    … …  
    25862586    }
    25872587#if 0
    2588     Print("Diag ? %d\n", diag);
     2588    PrintS("Diag ? %d\n", diag);
    25892589    a->Print();
    2590     Print("\n");
     2590    PrintLn();
    25912591#endif
    25922592    if (diag) break;
    … …  
    26112611{
    26122612#if 0
    2613   Print("Kernel of ");
     2613  PrintS("Kernel of ");
    26142614  a->Print();
    2615   Print(" modulo ");
     2615  PrintS(" modulo ");
    26162616  n_Print(p, q);
    2617   Print("\n");
     2617  PrintLn();
    26182618#endif
    26192619
    … …  
    26222622  diagonalForm(m, &U, &V);
    26232623#if 0
    2624   Print("\ndiag form: ");
     2624  PrintS("\ndiag form: ");
    26252625  m->Print();
    2626   Print("\nU:\n");
     2626  PrintS("\nU:\n");
    26272627  U->Print();
    2628   Print("\nV:\n");
     2628  PrintS("\nV:\n");
    26292629  V->Print();
    2630   Print("\n");
     2630  PrintLn();
    26312631#endif
    26322632

  • libpolys/coeffs/flintcf_Q.cc

    r7b9b8e5 rf9b0bd  
    7171static void CoeffWrite(const coeffs r, BOOLEAN details)
    7272{
    73   Print("// coefficients: flint fmpq_poly\n");
     73  PrintS("// coefficients: flint fmpq_poly\n");
    7474}
    7575static BOOLEAN CoeffIsEqual(const coeffs r, n_coeffType n, void * parameter)

  • libpolys/coeffs/rintegers.cc

    r7b9b8e5 rf9b0bd  
    14121412  number two = nrzInit(2, R);
    14131413#if 0
    1414   Print("Farey start with ");
     1414  PrintS("Farey start with ");
    14151415  n_Print(r, R);
    1416   Print(" mod ");
     1416  PrintS(" mod ");
    14171417  n_Print(N, R);
    1418   Print("\n");
     1418  PrintLn();
    14191419#endif
    14201420  while (1)

  • libpolys/coeffs/rmodulon.cc

    r7b9b8e5 rf9b0bd  
    446446#endif
    447447  nrnDelete(&xx, r);
    448   if (!nrnIsOne(ui, r)) {
     448  if (!nrnIsOne(ui, r))
     449  {
    449450#ifdef CF_DEB
    450     Print("Scaling\n");
     451    PrintS("Scaling\n");
    451452#endif
    452453    number uii = nrnInvers(ui, r);

  • libpolys/polys/ext_fields/algext.cc

    r7b9b8e5 rf9b0bd  
    14971497
    14981498  assume( A != NULL );
    1499   Print("// polynomial ring as coefficient ring :\n");
     1499  PrintS("// polynomial ring as coefficient ring :\n");
    15001500  rWrite(A);
    15011501  PrintLn();

  • libpolys/polys/ext_fields/transext.cc

    r7b9b8e5 rf9b0bd  
    216216      {
    217217        Print("ERROR in %s:%d: constant den. poly / Zp\n",f,l);
    218         Print("NUM: ");  p_Write(num, ntRing);
    219         Print("DEN: ");  p_Write(den, ntRing);
     218        PrintS("NUM: ");  p_Write(num, ntRing);
     219        PrintS("DEN: ");  p_Write(den, ntRing);
    220220        return FALSE;
    221221      }
    … …  
    224224      {
    225225        Print("ERROR in %s:%d: non-monic den. poly / Zp\n",f,l);
    226         Print("NUM: ");  p_Write(num, ntRing);
    227         Print("DEN: ");  p_Write(den, ntRing);
     226        PrintS("NUM: ");  p_Write(num, ntRing);
     227        PrintS("DEN: ");  p_Write(den, ntRing);
    228228        return FALSE;
    229229      }
    … …  
    238238        {
    239239          Print("ERROR in %s:%d: 1 != GCD between num. & den. poly\n",f,l);
    240           Print("GCD: ");  p_Write(gcd, ntRing);
    241           Print("NUM: ");  p_Write(num, ntRing);
    242           Print("DEN: ");  p_Write(den, ntRing);
     240          PrintS("GCD: ");  p_Write(gcd, ntRing);
     241          PrintS("NUM: ");  p_Write(num, ntRing);
     242          PrintS("DEN: ");  p_Write(den, ntRing);
    243243          return FALSE;
    244244        }

  • libpolys/polys/matpol.cc

    r7b9b8e5 rf9b0bd  
    699699*    for(i=1;i<=c;i++)
    700700*    {
    701 *      if(MATELEM(a,j,i)!=NULL) Print("X");
    702 *      else Print("0");
     701*      if(MATELEM(a,j,i)!=NULL) PrintS("X");
     702*      else PrintS("0");
    703703*    }
    704 *    Print("\n");
     704*    PrintLn();
    705705*  }
    706706*}

  • libpolys/polys/monomials/p_polys.cc

    r7b9b8e5 rf9b0bd  
    291291          p->exp[o->data.wp64.place]=a_1;
    292292          p->exp[o->data.wp64.place+1]=a_0;
    293 //            if(p_Setm_error) Print("***************************\n
    294 //                                    ***************************\n
    295 //                                    **WARNING: overflow error**\n
    296 //                                    ***************************\n
    297 //                                    ***************************\n");
     293//            if(p_Setm_error) PrintS("***************************\n"
     294//                                    "***************************\n"
     295//                                    "**WARNING: overflow error**\n"
     296//                                    "***************************\n"
     297//                                    "***************************\n");
    298298          break;
    299299        }

  • libpolys/polys/monomials/ring.cc

    r7b9b8e5 rf9b0bd  
    40864086      else
    40874087      {
    4088         Print("{");
     4088        PrintS("{");
    40894089        for( i=0; i <= limit; i++ )
    40904090          Print("%d ", syz_index[i]);
    4091         Print("}");
     4091        PrintS("}");
    40924092      }
    40934093
    … …  
    42114211  {
    42124212      PrintLn();
    4213       Print("pFDeg   : ");
     4213      PrintS("pFDeg   : ");
    42144214#define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
    42154215      pFDeg_CASE(p_Totaldegree); else
    … …  
    42244224    PrintLn();
    42254225  }
    4226   Print("pSetm:");
     4226  PrintS("pSetm:");
    42274227  void p_Setm_Dummy(poly p, const ring r);
    42284228  void p_Setm_TotalDegree(poly p, const ring r);

  • libpolys/polys/nc/ncSAFormula.cc

    r7b9b8e5 rf9b0bd  
    5252{
    5353#if OUTPUT
    54   Print("ncInitSpecialPowersMultiplication(ring), ring: \n");
     54  PrintS("ncInitSpecialPowersMultiplication(ring), ring: \n");
    5555  rWrite(r, TRUE);
    5656  PrintLn();
    … …  
    8484{
    8585#if OUTPUT
    86   Print("AreCommutingVariables(ring, k: %d, i: %d)!", j, i);
    87   PrintLn();
     86  Print("AreCommutingVariables(ring, k: %d, i: %d)!\n", j, i);
    8887#endif
    8988
    … …  
    136135{
    137136#if OUTPUT
    138   Print("AnalyzePair(ring, i: %d, j: %d):", i, j);
    139   PrintLn();
     137  Print("AnalyzePair(ring, i: %d, j: %d):\n", i, j);
    140138#endif
    141139
    … …  
    220218{
    221219#if OUTPUT
    222   Print("CFormulaPowerMultiplier::CFormulaPowerMultiplier(ring)!");
     220  PrintS("CFormulaPowerMultiplier::CFormulaPowerMultiplier(ring)!");
    223221  PrintLn();
    224222#endif
    … …  
    237235{
    238236#if OUTPUT
    239   Print("CFormulaPowerMultiplier::~CFormulaPowerMultiplier()!");
     237  PrintS("CFormulaPowerMultiplier::~CFormulaPowerMultiplier()!");
    240238  PrintLn();
    241239#endif
    … …  
    263261{
    264262#if OUTPUT
    265   Print("ncSA_1xy0x0y0(var(%d)^{%d}, var(%d)^{%d}, r)!", j, m, i, n);
    266   PrintLn();
     263  Print("ncSA_1xy0x0y0(var(%d)^{%d}, var(%d)^{%d}, r)!\n", j, m, i, n);
    267264#endif
    268265
    … …  
    281278{
    282279#if OUTPUT
    283   Print("ncSA_{M = -1}xy0x0y0(var(%d)^{%d}, var(%d)^{%d}, r)!", j, m, i, n);
    284   PrintLn();
     280  Print("ncSA_{M = -1}xy0x0y0(var(%d)^{%d}, var(%d)^{%d}, r)!\n", j, m, i, n);
    285281#endif
    286282
    … …  
    301297{
    302298#if OUTPUT
    303   Print("ncSA_Qxy0x0y0(var(%d)^{%d}, var(%d)^{%d}, Q, r)!", j, m, i, n);
    304   PrintLn();
     299  Print("ncSA_Qxy0x0y0(var(%d)^{%d}, var(%d)^{%d}, Q, r)!\n", j, m, i, n);
    305300#endif
    306301
    … …  
    350345{
    351346#if OUTPUT
    352   Print("ncSA_1xy0x0yG(var(%d)^{%d}, var(%d)^{%d}, G, r)!", j, m, i, n);
    353   PrintLn();
     347  Print("ncSA_1xy0x0yG(var(%d)^{%d}, var(%d)^{%d}, G, r)!\n", j, m, i, n);
    354348  number t = n_Copy(m_g, r);
    355349  PrintS("Parameter G: "); n_Write(t, r);
    … …  
    450444{
    451445#if OUTPUT
    452   Print("ncSA_1xy0x0yT2(var(%d)^{%d}, var(%d)^{%d}, t: var(%d), r)!", j, m, i, n, m_k);
    453   PrintLn();
     446  Print("ncSA_1xy0x0yT2(var(%d)^{%d}, var(%d)^{%d}, t: var(%d), r)!\n", j, m, i, n, m_k);
    454447#endif
    455448
    … …  
    633626{
    634627#if OUTPUT
    635   Print("ncSA_1xyAx0y0(var(%d)^{%d}, var(%d)^{%d}, A, r)!", j, m, i, n);
    636   PrintLn();
     628  Print("ncSA_1xyAx0y0(var(%d)^{%d}, var(%d)^{%d}, A, r)!\n", j, m, i, n);
    637629  number t = n_Copy(m_shiftCoef, r);
    638630  PrintS("Parameter A: "); n_Write(t, r);
    … …  
    646638{
    647639#if OUTPUT
    648   Print("ncSA_1xy0xBy0(var(%d)^{%d}, var(%d)^{%d}, B, r)!", j, m, i, n);
    649   PrintLn();
     640  Print("ncSA_1xy0xBy0(var(%d)^{%d}, var(%d)^{%d}, B, r)!\n", j, m, i, n);
    650641  number t = n_Copy(m_shiftCoef, r);
    651642  PrintS("Parameter B: "); n_Write(t, r);
    … …  
    664655{
    665656#if OUTPUT
    666   Print("ncSA_Multiply(type: %d, ring, (var(%d)^{%d} * var(%d)^{%d}, r)!", (int)type, j, m, i, n);
    667   PrintLn();
     657  Print("ncSA_Multiply(type: %d, ring, (var(%d)^{%d} * var(%d)^{%d}, r)!\n", (int)type, j, m, i, n);
    668658#endif
    669659

  • libpolys/polys/nc/old.gring.cc

    r7b9b8e5 rf9b0bd  
    407407        if (side)
    408408        {
    409           Print("gnc_p_Mult_mm: Multiplication in the left module from the right");
     409          PrintS("gnc_p_Mult_mm: Multiplication in the left module from the right");
    410410        }
    411411#endif
    … …  
    16221622  p_Test(p2, r);
    16231623#if MYTEST
    1624   Print("p1: "); p_Write(p1, r);
    1625   Print("p2: "); p_Write(p2, r);
     1624  PrintS("p1: "); p_Write(p1, r);
     1625  PrintS("p2: "); p_Write(p2, r);
    16261626#endif
    16271627#endif
    … …  
    16751675#ifdef PDEBUG
    16761676#if MYTEST
    1677   Print("m1: "); pWrite(m1);
    1678   Print("m2: "); pWrite(m2);
     1677  PrintS("m1: "); pWrite(m1);
     1678  PrintS("m2: "); pWrite(m2);
    16791679#endif
    16801680#endif
    … …  
    17231723
    17241724#if MYTEST
    1725   Print("M1: "); pWrite(M1);
    1726   Print("M2: "); pWrite(M2);
     1725  PrintS("M1: "); pWrite(M1);
     1726  PrintS("M2: "); pWrite(M2);
    17271727#endif
    17281728#endif
    … …  
    17311731  {
    17321732#ifdef PDEBUG
    1733        Print("\np1 = ");
     1733       PrintS("\np1 = ");
    17341734       p_Write(p1, r);
    17351735
    1736        Print("m1 = ");
     1736       PrintS("m1 = ");
    17371737       p_Write(m1, r);
    17381738
    1739        Print("p2 = ");
     1739       PrintS("p2 = ");
    17401740       p_Write(p2, r);
    17411741
    1742        Print("m2 = ");
     1742       PrintS("m2 = ");
    17431743       p_Write(m2, r);
    17441744
    … …  
    17901790
    17911791#if MYTEST
    1792   Print("M1: "); pWrite(M1);
    1793   Print("M2: "); pWrite(M2);
     1792  PrintS("M1: "); pWrite(M1);
     1793  PrintS("M2: "); pWrite(M2);
    17941794#endif
    17951795#endif
    … …  
    18021802
    18031803#if MYTEST
    1804   Print("M2: "); pWrite(M2);
     1804  PrintS("M2: "); pWrite(M2);
    18051805#endif
    18061806
    … …  
    18311831
    18321832#if MYTEST
    1833   Print("M1: "); pWrite(M1);
     1833  PrintS("M1: "); pWrite(M1);
    18341834#endif
    18351835
    … …  
    18421842
    18431843#if MYTEST
    1844   Print("M2: "); pWrite(M2);
     1844  PrintS("M2: "); pWrite(M2);
    18451845#endif
    18461846
    … …  
    18601860
    18611861#if MYTEST
    1862   Print("M1: "); pWrite(M1);
     1862  PrintS("M1: "); pWrite(M1);
    18631863#endif
    18641864
    … …  
    18721872
    18731873#if MYTEST
    1874   Print("M2: "); pWrite(M2);
     1874  PrintS("M2: "); pWrite(M2);
    18751875#endif
    18761876
    … …  
    20152015  const ring r = b->bucket_ring;
    20162016#ifdef PDEBUG
    2017 //   Print(">*");
     2017//   PrintS(">*");
    20182018#endif
    20192019
    … …  
    20252025  p_Test(p, r);
    20262026#if MYTEST
    2027   Print("p: "); p_Write(p, r);
     2027  PrintS("p: "); p_Write(p, r);
    20282028#endif
    20292029#endif
    … …  
    20412041
    20422042#if MYTEST
    2043   Print("pLmB: "); p_Write(pLmB, r);
     2043  PrintS("pLmB: "); p_Write(pLmB, r);
    20442044#endif
    20452045#endif
    … …  
    20512051  p_Test(m, r);
    20522052#if MYTEST
    2053   Print("m: "); p_Write(m, r);
     2053  PrintS("m: "); p_Write(m, r);
    20542054#endif
    20552055#endif
    … …  
    20792079#ifdef PDEBUG
    20802080  p_Test(pp, r);
    2081 //   Print("PP: "); pWrite(pp);
     2081//   PrintS("PP: "); pWrite(pp);
    20822082#endif
    20832083
    … …  
    20862086
    20872087#ifdef PDEBUG
    2088 //   Print("*>");
     2088//   PrintS("*>");
    20892089#endif
    20902090}

  • libpolys/polys/nc/sca.cc

    r7b9b8e5 rf9b0bd  
    385385
    386386#ifdef PDEBUG
    387 //  Print("sca_p_Mult_mm\n"); // !
     387//  PrintS("sca_p_Mult_mm\n"); // !
    388388
    389389  p_Test(pPoly, rRing);
    … …  
    471471
    472472#ifdef PDEBUG
    473 //  Print("sca_pp_Mult_mm\n"); // !
     473//  PrintS("sca_pp_Mult_mm\n"); // !
    474474
    475475  p_Test(pPoly, rRing);
    … …  
    581581
    582582#ifdef PDEBUG
    583 //  Print("sca_mm_Mult_pp\n"); // !
     583//  PrintS("sca_mm_Mult_pp\n"); // !
    584584
    585585  p_Test(pPoly, rRing);
    … …  
    14601460
    14611461#if 0
    1462   Print("m_KillSquares, m = "); // !
     1462  PrintS("m_KillSquares, m = "); // !
    14631463  p_Write(m, r);
    14641464#endif
    … …  
    14871487
    14881488#if 0
    1489   Print("p_KillSquares, p = "); // !
     1489  PrintS("p_KillSquares, p = "); // !
    14901490  p_Write(p, r);
    14911491#endif
    … …  
    15191519  p_Test(pResult, r);
    15201520#if 0
    1521   Print("p_KillSquares => "); // !
     1521  PrintS("p_KillSquares => "); // !
    15221522  p_Write(pResult, r);
    15231523#endif
Note: See TracChangeset for help on using the changeset viewer.