Changeset e2ca88 in git for libfac

Timestamp:

May 16, 2006, 4:46:50 PM (18 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

55abfc3008e047e8f26beaeb76b5bab66cfe8288

Parents:

dbcf42a937f51948f4de74902429b68c1b54592b

Message:

*hannes: gcc 4.1 fixes


git-svn-id: file:///usr/local/Singular/svn/trunk@9142 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

libfac

Files:

• charset/alg_factor.cc (modified) (29 diffs)
• charset/algfactor.cc (modified) (23 diffs)
• charset/charset.cc (modified) (20 diffs)
• charset/csutil.cc (modified) (12 diffs)
• charset/reorder.cc (modified) (10 diffs)
• factor/Factor.cc (modified) (40 diffs)
• factor/MVMultiHensel.cc (modified) (17 diffs)
• factor/SqrFree.cc (modified) (19 diffs)
• factor/Truefactor.cc (modified) (12 diffs)
• factor/class.h (modified) (4 diffs)
• factor/debug.h (modified) (4 diffs)
• factor/homogfactor.cc (modified) (5 diffs)
• factor/timing.h (modified) (4 diffs)
• test.cc (modified) (4 diffs)
• testcs.cc (modified) (3 diffs)

libfac/charset/alg_factor.cc

@@ -3 +3 @@
 // emacs edit mode for this file is -*- C++ -*-
 ////////////////////////////////////////////////////////////
-static char * rcsid = "$Id: alg_factor.cc,v 1.15 2005-10-17 13:16:18 Singular Exp $";
+static char * rcsid = "$Id: alg_factor.cc,v 1.16 2006-05-16 14:46:48 Singular Exp $";
 ////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -122 +122 @@
   int delta;
 
-  DEBOUTLN( cout, "resultante: called  f= ", f);
-  DEBOUTLN( cout, "resultante: called  g= ", g);
-  DEBOUTLN( cout, "resultante: called  v= ", v);
+  DEBOUTLN( CERR, "resultante: called  f= ", f);
+  DEBOUTLN( CERR, "resultante: called  g= ", g);
+  DEBOUTLN( CERR, "resultante: called  v= ", v);
   if ( f.mvar() < v || g.mvar() < v ){
-    DEBOUTMSG(cout, "resultante: f.mvar() < v || g.mvar() < v");
+    DEBOUTMSG(CERR, "resultante: f.mvar() < v || g.mvar() < v");
     return 1;
   }
 
   if ( f.degree( v ) < 1 || g.degree( v ) < 1 ){
-    DEBOUTMSG(cout, "resultante: f.degree( v ) < 1 || g.degree( v ) < 1");
+    DEBOUTMSG(CERR, "resultante: f.degree( v ) < 1 || g.degree( v ) < 1");
     // If deg(F,v) == 0 , then resultante(F,G,v) = F^n, where n=deg(G,v)
     if ( f.degree( v ) < 1 ) return power(f,degree(g,v));
@@ -178 +178 @@
   CFFListIterator i;
 
-  DEBOUTLN(cout, "sqrf_norm_sub:      f= ", f);
-  DEBOUTLN(cout, "sqrf_norm_sub: Palpha= ", Palpha);
+  DEBOUTLN(CERR, "sqrf_norm_sub:      f= ", f);
+  DEBOUTLN(CERR, "sqrf_norm_sub: Palpha= ", Palpha);
   myrandom.reset();   s=f.mvar()-myrandom.item()*Palpha.mvar();   g=f;
   R= CanonicalForm(0);
-  DEBOUTLN(cout, "sqrf_norm_sub: myrandom s= ", s);
+  DEBOUTLN(CERR, "sqrf_norm_sub: myrandom s= ", s);
 
   // Norm, resultante taken with respect to y
   while ( !sqfreetest ){
-    DEBOUTLN(cout, "sqrf_norm_sub: Palpha= ", Palpha);
+    DEBOUTLN(CERR, "sqrf_norm_sub: Palpha= ", Palpha);
     R = resultante(Palpha, g, y); R= R* bCommonDen(R);
-    DEBOUTLN(cout, "sqrf_norm_sub: R= ", R);
+    DEBOUTLN(CERR, "sqrf_norm_sub: R= ", R);
     // sqfree check ; R is a polynomial in K[x]
     if ( getCharacteristic() == 0 )
     {
       temp= gcd(R, R.deriv(vf));
-      DEBOUTLN(cout, "sqrf_norm_sub: temp= ", temp);
+      DEBOUTLN(CERR, "sqrf_norm_sub: temp= ", temp);
       if (degree(temp,vf) != 0 || temp == temp.genZero() ){ sqfreetest= 0; }
       else { sqfreetest= 1; }
-      DEBOUTLN(cout, "sqrf_norm_sub: sqfreetest= ", sqfreetest);
+      DEBOUTLN(CERR, "sqrf_norm_sub: sqfreetest= ", sqfreetest);
     }
     else{
-      DEBOUTMSG(cout, "Starting SqrFreeTest(R)!");
+      DEBOUTMSG(CERR, "Starting SqrFreeTest(R)!");
       // Look at SqrFreeTest!
       // (z+a^5+w)^4 with z<w<a should not give sqfreetest=1 !
@@ -214 +214 @@
       else
         testlist= Factorize(R);
-      DEBOUTLN(cout, "testlist= ", testlist);
+      DEBOUTLN(CERR, "testlist= ", testlist);
       testlist.removeFirst();
       sqfreetest=1;
       for ( i=testlist; i.hasItem(); i++)
         if ( i.getItem().exp() > 1 && degree(i.getItem().factor(), R.mvar()) > 0) { sqfreetest=0; break; }
-      DEBOUTLN(cout, "SqrFreeTest(R)= ", sqfreetest);
+      DEBOUTLN(CERR, "SqrFreeTest(R)= ", sqfreetest);
     }
     if ( ! sqfreetest ){
       myrandom.next();
-      DEBOUTLN(cout, "sqrf_norm_sub generated new myrandom item: ", myrandom.item());
+      DEBOUTLN(CERR, "sqrf_norm_sub generated new myrandom item: ", myrandom.item());
       if ( getCharacteristic() == 0 ) t= CanonicalForm(mapinto(myrandom.item()));
       else t= CanonicalForm(myrandom.item());
       s= f.mvar()+t*Palpha.mvar(); // s defines backsubstitution
-      DEBOUTLN(cout, "sqrf_norm_sub: testing s= ", s);
+      DEBOUTLN(CERR, "sqrf_norm_sub: testing s= ", s);
       g= f(f.mvar()-t*Palpha.mvar(), f.mvar());
-      DEBOUTLN(cout, "             gives g= ", g);
+      DEBOUTLN(CERR, "             gives g= ", g);
     }
   }
@@ -243 +243 @@
   CFFListIterator i;
 
-  DEBOUTLN(cout, "sqrf_norm_sub:      f= ", f);
-  DEBOUTLN(cout, "sqrf_norm_sub: Palpha= ", Palpha);
+  DEBOUTLN(CERR, "sqrf_norm_sub:      f= ", f);
+  DEBOUTLN(CERR, "sqrf_norm_sub: Palpha= ", Palpha);
   myrandom.reset();   s=f.mvar()-myrandom.item()*Palpha.mvar();   g=f;
   R= CanonicalForm(0);
-  DEBOUTLN(cout, "sqrf_norm_sub: myrandom s= ", s);
+  DEBOUTLN(CERR, "sqrf_norm_sub: myrandom s= ", s);
 
   // Norm, resultante taken with respect to y
   while ( !sqfreetest ){
-    DEBOUTLN(cout, "sqrf_norm_sub: Palpha= ", Palpha);
+    DEBOUTLN(CERR, "sqrf_norm_sub: Palpha= ", Palpha);
     R = resultante(Palpha, g, y); R= R* bCommonDen(R);
-    DEBOUTLN(cout, "sqrf_norm_sub: R= ", R);
+    DEBOUTLN(CERR, "sqrf_norm_sub: R= ", R);
     // sqfree check ; R is a polynomial in K[x]
     if ( getCharacteristic() == 0 )
     {
       temp= gcd(R, R.deriv(vf));
-      DEBOUTLN(cout, "sqrf_norm_sub: temp= ", temp);
+      DEBOUTLN(CERR, "sqrf_norm_sub: temp= ", temp);
       if (degree(temp,vf) != 0 || temp == temp.genZero() ){ sqfreetest= 0; }
       else { sqfreetest= 1; }
-      DEBOUTLN(cout, "sqrf_norm_sub: sqfreetest= ", sqfreetest);
+      DEBOUTLN(CERR, "sqrf_norm_sub: sqfreetest= ", sqfreetest);
     }
     else{
-      DEBOUTMSG(cout, "Starting SqrFreeTest(R)!");
+      DEBOUTMSG(CERR, "Starting SqrFreeTest(R)!");
       // Look at SqrFreeTest!
       // (z+a^5+w)^4 with z<w<a should not give sqfreetest=1 !
@@ -279 +279 @@
       else
         testlist= Factorize(R);
-      DEBOUTLN(cout, "testlist= ", testlist);
+      DEBOUTLN(CERR, "testlist= ", testlist);
       testlist.removeFirst();
       sqfreetest=1;
       for ( i=testlist; i.hasItem(); i++)
         if ( i.getItem().exp() > 1 && degree(i.getItem().factor(), R.mvar()) > 0) { sqfreetest=0; break; }
-      DEBOUTLN(cout, "SqrFreeTest(R)= ", sqfreetest);
+      DEBOUTLN(CERR, "SqrFreeTest(R)= ", sqfreetest);
     }
     if ( ! sqfreetest ){
       myrandom.next();
-      DEBOUTLN(cout, "sqrf_norm_sub generated new myrandom item: ", myrandom.item());
+      DEBOUTLN(CERR, "sqrf_norm_sub generated new myrandom item: ", myrandom.item());
       if ( getCharacteristic() == 0 ) t= CanonicalForm(mapinto(myrandom.item()));
       else t= CanonicalForm(myrandom.item());
       s= f.mvar()+t*Palpha.mvar(); // s defines backsubstitution
-      DEBOUTLN(cout, "sqrf_norm_sub: testing s= ", s);
+      DEBOUTLN(CERR, "sqrf_norm_sub: testing s= ", s);
       g= f(f.mvar()-t*Palpha.mvar(), f.mvar());
-      DEBOUTLN(cout, "             gives g= ", g);
+      DEBOUTLN(CERR, "             gives g= ", g);
     }
   }
@@ -304 +304 @@
            CanonicalForm & R){
 
-  DEBOUTLN(cout, "sqrf_norm:      f= ", f);
-  DEBOUTLN(cout, "sqrf_norm: Palpha= ", PPalpha);
+  DEBOUTLN(CERR, "sqrf_norm:      f= ", f);
+  DEBOUTLN(CERR, "sqrf_norm: Palpha= ", PPalpha);
   if ( getCharacteristic() == 0 ) {
     IntGenerator myrandom;
-    DEBOUTMSG(cout, "sqrf_norm: no extension, char=0");
+    DEBOUTMSG(CERR, "sqrf_norm: no extension, char=0");
     sqrf_norm_sub(f,PPalpha, myrandom, s,g,R);
-    DEBOUTLN(cout, "sqrf_norm:      f= ", f);
-    DEBOUTLN(cout, "sqrf_norm: Palpha= ", PPalpha);
-    DEBOUTLN(cout, "sqrf_norm:      s= ", s);
-    DEBOUTLN(cout, "sqrf_norm:      g= ", g);
-    DEBOUTLN(cout, "sqrf_norm:      R= ", R);
+    DEBOUTLN(CERR, "sqrf_norm:      f= ", f);
+    DEBOUTLN(CERR, "sqrf_norm: Palpha= ", PPalpha);
+    DEBOUTLN(CERR, "sqrf_norm:      s= ", s);
+    DEBOUTLN(CERR, "sqrf_norm:      g= ", g);
+    DEBOUTLN(CERR, "sqrf_norm:      R= ", R);
   }
   else if ( degree(Extension) > 0 ){ // working over Extensions
-    DEBOUTLN(cout, "sqrf_norm: degree of extension is ", degree(Extension));
+    DEBOUTLN(CERR, "sqrf_norm: degree of extension is ", degree(Extension));
     AlgExtGenerator myrandom(Extension);
     sqrf_agnorm_sub(f,PPalpha, myrandom, s,g,R);
@@ -323 +323 @@
   else{
     FFGenerator myrandom;
-    DEBOUTMSG(cout, "sqrf_norm: degree of extension is 0");
+    DEBOUTMSG(CERR, "sqrf_norm: degree of extension is 0");
     sqrf_norm_sub(f,PPalpha, myrandom, s,g,R);
   }
@@ -396 +396 @@
       l= l+1;
       if ( gcd0(k,i.getItem()) == 1){
-        DEBOUTLN(cout, "getextension: gcd == 1, l=",l);
+        DEBOUTLN(CERR, "getextension: gcd == 1, l=",l);
         if ( l==length ){ setCharacteristic(charac);  return k; }
       }
-      else { DEBOUTMSG(cout, "getextension: Next iteration"); break; }
+      else { DEBOUTMSG(CERR, "getextension: Next iteration"); break; }
     }
     k= k+1; l=0;
@@ -414 +414 @@
   CanonicalForm s, g;
 
-  DEBOUTLN(cout, "simpleextension: Astar= ", Astar);
-  DEBOUTLN(cout, "simpleextension:     R= ", R);
-  DEBOUTLN(cout, "simpleextension: Extension= ", Extension);
+  DEBOUTLN(CERR, "simpleextension: Astar= ", Astar);
+  DEBOUTLN(CERR, "simpleextension:     R= ", R);
+  DEBOUTLN(CERR, "simpleextension: Extension= ", Extension);
   if ( Astar.length() == 1 ){ R= Astar.getFirst();}
   else{
     R=Bstar.getFirst(); Bstar.removeFirst();
     for ( CFListIterator i=Bstar; i.hasItem(); i++){
-      DEBOUTLN(cout, "simpleextension: f(x)= ", i.getItem());
-      DEBOUTLN(cout, "simpleextension: P(x)= ", R);
+      DEBOUTLN(CERR, "simpleextension: f(x)= ", i.getItem());
+      DEBOUTLN(CERR, "simpleextension: P(x)= ", R);
       sqrf_norm(i.getItem(), R, Extension, s, g, R);
       // spielt die Repraesentation eine Rolle?
       // muessen wir die Nachfolger aendern, wenn s != 0 ?
-      DEBOUTLN(cout, "simpleextension: g= ", g);
-      if ( s != 0 ) DEBOUTLN(cout, "simpleextension: s= ", s);
-      else DEBOUTLN(cout, "simpleextension: s= ", s);
-      DEBOUTLN(cout, "simpleextension: R= ", R);
+      DEBOUTLN(CERR, "simpleextension: g= ", g);
+      if ( s != 0 ) DEBOUTLN(CERR, "simpleextension: s= ", s);
+      else DEBOUTLN(CERR, "simpleextension: s= ", s);
+      DEBOUTLN(CERR, "simpleextension: R= ", R);
       Returnlist.insert(s);
     }
@@ -453 +453 @@
   CFList substlist;
 
-  DEBINCLEVEL(cout,"alg_factor");
-  DEBOUTLN(cout, "alg_factor: f= ", f);
+  DEBINCLEVEL(CERR,"alg_factor");
+  DEBOUTLN(CERR, "alg_factor: f= ", f);
   //out_cf("start alg_factor:",f,"\n");
   substlist= simpleextension(Astar, vminpoly, Rstar);
-  DEBOUTLN(cout, "alg_factor: substlist= ", substlist);
-  DEBOUTLN(cout, "alg_factor: minpoly Rstar= ", Rstar);
-  DEBOUTLN(cout, "alg_factor: vminpoly= ", vminpoly);
+  DEBOUTLN(CERR, "alg_factor: substlist= ", substlist);
+  DEBOUTLN(CERR, "alg_factor: minpoly Rstar= ", Rstar);
+  DEBOUTLN(CERR, "alg_factor: vminpoly= ", vminpoly);
 
   sqrf_norm(f, Rstar, vminpoly, s, g, R );
@@ -465 +465 @@
   //out_cf("sqrf_norm s:",s,"\n");
   //out_cf("sqrf_norm g:",g,"\n");
-  DEBOUTLN(cout, "alg_factor: g= ", g);
-  DEBOUTLN(cout, "alg_factor: s= ", s);
-  DEBOUTLN(cout, "alg_factor: R= ", R);
+  DEBOUTLN(CERR, "alg_factor: g= ", g);
+  DEBOUTLN(CERR, "alg_factor: s= ", s);
+  DEBOUTLN(CERR, "alg_factor: R= ", R);
   Off(SW_RATIONAL);
   Variable X;
@@ -473 +473 @@
   {
     // factorize R over alg.extension with X
-//cout << "alg: "<< X << " mipo=" << getMipo(X,Variable('X')) <<endl;
+//CERR << "alg: "<< X << " mipo=" << getMipo(X,Variable('X')) <<"\n";
     if (R.isUnivariate())
     {
-      DEBOUTLN(cout, "alg_factor: factorize( ", R);
+      DEBOUTLN(CERR, "alg_factor: factorize( ", R);
       Factorlist =  factorize( R, X );
     }
@@ -485 +485 @@
       CanonicalForm mipo=getMipo(X,XX);
       CFList as(mipo);
-      DEBOUTLN(cout, "alg_factor: newfactoras( ", R);
+      DEBOUTLN(CERR, "alg_factor: newfactoras( ", R);
       Factorlist = newfactoras(R, as , 1);
       #else
       // factor R over k
-      DEBOUTLN(cout, "alg_factor: Factorize( ", R);
+      DEBOUTLN(CERR, "alg_factor: Factorize( ", R);
       Factorlist = Factorize(R);
       #endif
@@ -497 +497 @@
   {
     // factor R over k
-    DEBOUTLN(cout, "alg_factor: Factorize( ", R);
+    DEBOUTLN(CERR, "alg_factor: Factorize( ", R);
     Factorlist = Factorize(R);
   }
   On(SW_RATIONAL);
-  DEBOUTLN(cout, "alg_factor: Factorize(R)= ", Factorlist);
+  DEBOUTLN(CERR, "alg_factor: Factorize(R)= ", Factorlist);
   if ( !Factorlist.getFirst().factor().inCoeffDomain() )
     Factorlist.insert(CFFactor(1,1));
@@ -508 +508 @@
   }
   else{
-    DEBOUTLN(cout, "alg_factor: g= ", g);
+    DEBOUTLN(CERR, "alg_factor: g= ", g);
     CanonicalForm gnew= g(s,s.mvar());
-    DEBOUTLN(cout, "alg_factor: gnew= ", gnew);
+    DEBOUTLN(CERR, "alg_factor: gnew= ", gnew);
     g=gnew;
     for ( CFFListIterator i=Factorlist; i.hasItem(); i++){
       CanonicalForm fnew=i.getItem().factor();
       fnew= fnew(s,s.mvar());
-      DEBOUTLN(cout, "alg_factor: fnew= ", fnew);
-      DEBOUTLN(cout, "alg_factor: substlist= ", substlist);
+      DEBOUTLN(CERR, "alg_factor: fnew= ", fnew);
+      DEBOUTLN(CERR, "alg_factor: substlist= ", substlist);
       for ( CFListIterator ii=substlist; ii.hasItem(); ii++){
-        DEBOUTLN(cout, "alg_factor: item= ", ii.getItem());
+        DEBOUTLN(CERR, "alg_factor: item= ", ii.getItem());
         fnew= fnew(ii.getItem(), ii.getItem().mvar());
-        DEBOUTLN(cout, "alg_factor: fnew= ", fnew);
+        DEBOUTLN(CERR, "alg_factor: fnew= ", fnew);
       }
       if (degree(i.getItem().factor()) > 0 ){
         // undo linear transformation!!!! and then gcd!
-        //cout << "algcd(" << g << "," << fnew << ",as" << as << ")" << endl;
+        //CERR << "algcd(" << g << "," << fnew << ",as" << as << ")" << "\n";
         //out_cf("algcd g=",g,"\n");
         //out_cf("algcd fnew=",fnew,"\n");
@@ -534 +534 @@
         //out_cf(" -> algcd=",algcd(g,fnew, as, oldord),"\n");
         //out_cf(" -> alg_gcd=",alg_gcd(g,fnew,as),"\n");
-        //cout << "algcd result:" << h << endl;
-        DEBOUTLN(cout, "  alg_factor: h= ", h);
-        DEBOUTLN(cout, "  alg_factor: oldord= ", oldord);
+        //CERR << "algcd result:" << h << "\n";
+        DEBOUTLN(CERR, "  alg_factor: h= ", h);
+        DEBOUTLN(CERR, "  alg_factor: oldord= ", oldord);
         if ( degree(h) > 0 ){ //otherwise it's a constant
           g= divide(g, h,as);
-          DEBOUTLN(cout, "alg_factor: g/h= ", g);
-          DEBOUTLN(cout, "alg_factor: s= ", s);
-          DEBOUTLN(cout, "alg_factor: substlist= ", substlist);
+          DEBOUTLN(CERR, "alg_factor: g/h= ", g);
+          DEBOUTLN(CERR, "alg_factor: s= ", s);
+          DEBOUTLN(CERR, "alg_factor: substlist= ", substlist);
           L.append(CFFactor(h,1));
         }
@@ -575 +575 @@
   //  out_cf("end alg_f:",i.getItem().factor(),"\n");
   //printf("end alg_factor\n");
-  DEBOUTLN(cout, "alg_factor: L= ", LL);
-  DEBDECLEVEL(cout,"alg_factor");
+  DEBOUTLN(CERR, "alg_factor: L= ", LL);
+  DEBDECLEVEL(CERR,"alg_factor");
   return LL;
 }
@@ -592 +592 @@
     g= i.getItem();
     if (g.deriv() == 0 ){
-      DEBOUTLN(cout, "Inseperable extension detected: ", g);
+      DEBOUTLN(CERR, "Inseperable extension detected: ", g);
       for (j=uord; j.hasItem(); j++){
         if ( degree(g,j.getItem()) > 0 ) vg= j.getItem();
       }
       // Now we have the highest transzendental in vg;
-      DEBOUTLN(cout, "Transzendental is ", vg);
+      DEBOUTLN(CERR, "Transzendental is ", vg);
       CanonicalForm gg=-1*g[0];
       divrem(gg,vg,q,r); r= gg-q*vg;   gg= gg-r;
-      //DEBOUTLN(cout, "q= ", q); DEBOUTLN(cout, "r= ", r);
-      DEBOUTLN(cout, "  that is ", gg);
-      DEBOUTLN(cout, "  maps to ", g+gg);
+      //DEBOUTLN(CERR, "q= ", q); DEBOUTLN(CERR, "r= ", r);
+      DEBOUTLN(CERR, "  that is ", gg);
+      DEBOUTLN(CERR, "  maps to ", g+gg);
       One.insert(gg); Two.insert(g+gg);
       // Now transform all remaining polys in as:
@@ -609 +609 @@
         if ( x != 0 ){
           divrem(ii.getItem(), gg, q,r);
-//          cout << ii.getItem() << " divided by " << gg << endl;
-          DEBOUTLN(cout, "q= ", q); DEBOUTLN(cout, "r= ", r);
+//          CERR << ii.getItem() << " divided by " << gg << "\n";
+          DEBOUTLN(CERR, "q= ", q); DEBOUTLN(CERR, "r= ", r);
           ii.append(ii.getItem()+q*g); ii.remove(1);
-          DEBOUTLN(cout, "as= ", as);
+          DEBOUTLN(CERR, "as= ", as);
         }
         x+= 1;
@@ -619 +619 @@
       divrem(F, gg, q,r);
       F= F+q*g;
-      DEBOUTLN(cout, "new F= ", F);
+      DEBOUTLN(CERR, "new F= ", F);
     }
     else{ asnew.append(i.getItem());  }// just the identity
   }
   // factor F with minimal polys given in asnew:
-  DEBOUTLN(cout, "Factor F=  ", F);
-  DEBOUTLN(cout, "  with as= ", asnew);
+  DEBOUTLN(CERR, "Factor F=  ", F);
+  DEBOUTLN(CERR, "  with as= ", asnew);
   int success=0;
   CFFList factorlist= newcfactor(F,asnew, success);
-  DEBOUTLN(cout, "  gives =  ", factorlist);
-  DEBOUTLN(cout, "One= ", One);
-  DEBOUTLN(cout, "Two= ", Two);
+  DEBOUTLN(CERR, "  gives =  ", factorlist);
+  DEBOUTLN(CERR, "One= ", One);
+  DEBOUTLN(CERR, "Two= ", Two);
 
   // Transform back:
@@ -637 +637 @@
     ii=One;
     for (i=Two; i.hasItem(); i++){
-      DEBOUTLN(cout, "Mapping ", i.getItem());
-      DEBOUTLN(cout, "     to ", ii.getItem());
-      DEBOUTLN(cout, "     in ", factor);
+      DEBOUTLN(CERR, "Mapping ", i.getItem());
+      DEBOUTLN(CERR, "     to ", ii.getItem());
+      DEBOUTLN(CERR, "     in ", factor);
       divrem(factor,i.getItem(),q,r); r=factor -q*i.getItem();
-      DEBOUTLN(cout, "q= ", q); DEBOUTLN(cout, "r= ", r);
+      DEBOUTLN(CERR, "q= ", q); DEBOUTLN(CERR, "r= ", r);
       factor= ii.getItem()*q +r; //
       ii++;
@@ -664 +664 @@
 
   success=1;
-  DEBINCLEVEL(cout, "newfactoras");
-  DEBOUTMSG(cerr, rcsid);
-  DEBOUTLN(cout, "newfactoras called with f= ", f);
-  DEBOUTLN(cout, "               content(f)= ", content(f));
-  DEBOUTLN(cout, "                       as= ", as);
-  DEBOUTLN(cout, "newfactoras: cls(vf)= ", cls(vf));
-  DEBOUTLN(cout, "newfactoras: cls(as.getLast())= ", cls(as.getLast()));
-  DEBOUTLN(cout, "newfactoras: degree(f,vf)= ", degree(f,vf));
+  DEBINCLEVEL(CERR, "newfactoras");
+  DEBOUTMSG(CERR, rcsid);
+  DEBOUTLN(CERR, "newfactoras called with f= ", f);
+  DEBOUTLN(CERR, "               content(f)= ", content(f));
+  DEBOUTLN(CERR, "                       as= ", as);
+  DEBOUTLN(CERR, "newfactoras: cls(vf)= ", cls(vf));
+  DEBOUTLN(CERR, "newfactoras: cls(as.getLast())= ", cls(as.getLast()));
+  DEBOUTLN(CERR, "newfactoras: degree(f,vf)= ", degree(f,vf));
 
 // F1: [Test trivial cases]
@@ -677 +677 @@
   if ( (cls(vf) <= cls(as.getLast())) ||  degree(f,vf)<=1 ){
 // ||( (as.length()==1) && (degree(f,vf)==3) && (degree(as.getFirst()==2)) )
-    DEBDECLEVEL(cout,"newfactoras");
+    DEBDECLEVEL(CERR,"newfactoras");
     return CFFList(CFFactor(f,1));
   }
@@ -700 +700 @@
   }
   uord= Difference(uord,ord);
-  DEBOUTLN(cout, "Astar is: ", Astar);
-  DEBOUTLN(cout, "ord is: ", ord);
-  DEBOUTLN(cout, "uord is: ", uord);
+  DEBOUTLN(CERR, "Astar is: ", Astar);
+  DEBOUTLN(CERR, "ord is: ", ord);
+  DEBOUTLN(CERR, "uord is: ", uord);
 
 // 3) second trivial cases: we already prooved irr. of f over no extensions
   if ( Astar.length() == 0 ){
-    DEBDECLEVEL(cout,"newfactoras");
+    DEBDECLEVEL(CERR,"newfactoras");
     return CFFList(CFFactor(f,1));
   }
@@ -718 +718 @@
 //   polynomials, we don't have transzendentals.
   Varlist newuord=Var_is_in_AS(uord,Astar);
-  DEBOUTLN(cout, "newuord is: ", newuord);
+  DEBOUTLN(CERR, "newuord is: ", newuord);
 
   CFFList Factorlist;
   Varlist gcdord= Union(ord,newuord); gcdord.append(f.mvar());
   // This is for now. we need alg_sqrfree implemented!
-  //cout << "algcd(" << f << "," << f.deriv() << " as:" << Astar <<endl;
+  //CERR << "algcd(" << f << "," << f.deriv() << " as:" << Astar <<"\n";
   //CanonicalForm Fgcd= algcd(f,f.deriv(),Astar,gcdord);
   CanonicalForm Fgcd;
@@ -732 +732 @@
         //out_cf("algcd:",algcd(f,f.deriv(),Astar,gcdord),"\n");
         //out_cf("alg_gcd:",alg_gcd(f,f.deriv(),Astar),"\n");
- // cout << "algcd result:"  << Fgcd << endl;
-  if ( Fgcd == 0 ) DEBOUTMSG(cerr, "WARNING: p'th root ?");
+ // CERR << "algcd result:"  << Fgcd << "\n";
+  if ( Fgcd == 0 ) DEBOUTMSG(CERR, "WARNING: p'th root ?");
   if (( degree(Fgcd, f.mvar()) > 0) && (!(f.deriv().isZero())) ){
-    DEBOUTLN(cout, "Nontrivial GCD found of ", f);
+    DEBOUTLN(CERR, "Nontrivial GCD found of ", f);
     CanonicalForm Ggcd= divide(f, Fgcd,Astar);
-    DEBOUTLN(cout, "  split into ", Fgcd);
-    DEBOUTLN(cout, "         and ", Ggcd);
+    DEBOUTLN(CERR, "  split into ", Fgcd);
+    DEBOUTLN(CERR, "         and ", Ggcd);
     Fgcd= pp(Fgcd); Ggcd= pp(Ggcd);
-    DEBDECLEVEL(cout,"newfactoras");
+    DEBDECLEVEL(CERR,"newfactoras");
     return myUnion(newfactoras(Fgcd,as,success) , newfactoras(Ggcd,as,success));
   }
@@ -750 +750 @@
     for (i=Astar; i.hasItem(); i++){degreelist.append(degree(i.getItem()));}
     int extdeg= getextension(degreelist, degree(f));
-    DEBOUTLN(cout, "Extension needed of degree ", extdeg);
+    DEBOUTLN(CERR, "Extension needed of degree ", extdeg);
 
     // Now the real stuff!
     if ( newuord.length() == 0 ){ // no transzendentals
-      DEBOUTMSG(cout, "No transzendentals!");
+      DEBOUTMSG(CERR, "No transzendentals!");
       if ( extdeg > 1 ){
         CanonicalForm MIPO= generate_mipo( extdeg, vminpoly);
-        DEBOUTLN(cout, "Minpoly produced ", MIPO);
+        DEBOUTLN(CERR, "Minpoly produced ", MIPO);
         vminpoly= rootOf(MIPO);
       }
       Factorlist= alg_factor(f, Astar, vminpoly, oldord, as);
-      DEBDECLEVEL(cout,"newfactoras");
+      DEBDECLEVEL(CERR,"newfactoras");
       return Factorlist;
     }
     else if ( inseperable(Astar) > 0 ){ // Look if extensions are seperable
       // a) Use Endler
-      DEBOUTMSG(cout, "Inseperable extensions! Using Endler!");
+      DEBOUTMSG(CERR, "Inseperable extensions! Using Endler!");
       CFFList templist= endler(f,Astar, newuord);
-      DEBOUTLN(cout, "Endler gives: ", templist);
+      DEBOUTLN(CERR, "Endler gives: ", templist);
       return templist;
     }
     else{ // we are on the save side: Use trager
-      DEBOUTMSG(cout, "Only seperable extensions!");
+      DEBOUTMSG(CERR, "Only seperable extensions!");
       if (extdeg > 1 ){
         CanonicalForm MIPO=generate_mipo(extdeg, vminpoly );
         vminpoly= rootOf(MIPO);
-        DEBOUTLN(cout, "Minpoly generated: ", MIPO);
-        DEBOUTLN(cout, "vminpoly= ", vminpoly);
-        DEBOUTLN(cout, "degree(vminpoly)= ", degree(vminpoly));
+        DEBOUTLN(CERR, "Minpoly generated: ", MIPO);
+        DEBOUTLN(CERR, "vminpoly= ", vminpoly);
+        DEBOUTLN(CERR, "degree(vminpoly)= ", degree(vminpoly));
       }
       Factorlist= alg_factor(f, Astar, vminpoly, oldord, as);
-      DEBDECLEVEL(cout,"newfactoras");
+      DEBDECLEVEL(CERR,"newfactoras");
       return Factorlist;
     }
   }
   else{ // char=0 apply trager directly
-    DEBOUTMSG(cout, "Char=0! Apply Trager!");
+    DEBOUTMSG(CERR, "Char=0! Apply Trager!");
     Variable vminpoly;
     Factorlist= alg_factor(f, Astar, vminpoly, oldord, as);
-      DEBDECLEVEL(cout,"newfactoras");
+      DEBDECLEVEL(CERR,"newfactoras");
       return Factorlist;
   }
 
-  DEBDECLEVEL(cout,"newfactoras");
+  DEBDECLEVEL(CERR,"newfactoras");
   return CFFList(CFFactor(f,1));
 }
@@ -817 +817 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.15  2005/10/17 13:16:18  Singular
+*hannes: code cleanup
+
 Revision 1.14  2005/07/08 09:18:15  Singular
 *hannes: fixed call of resultant

libfac/charset/algfactor.cc

@@ -3 +3 @@
 // emacs edit mode for this file is -*- C++ -*-
 ////////////////////////////////////////////////////////////
-static char * rcsid = "$Id: algfactor.cc,v 1.6 2002-08-19 11:11:30 Singular Exp $";
+static char * rcsid = "$Id: algfactor.cc,v 1.7 2006-05-16 14:46:48 Singular Exp $";
 ////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -80 +80 @@
   int nas= AS.length() +1;
 
-  DEBOUTLN(cout, "charsetnA: called with ps= ", PS);
+  DEBOUTLN(CERR, "charsetnA: called with ps= ", PS);
   while ( ! RS.isEmpty() ) {
     CS = BasicSet( QS );
-    DEBOUTLN(cout, "charsetnA: CS= ", CS);
+    DEBOUTLN(CERR, "charsetnA: CS= ", CS);
     CS=Union(CS,AS);
-    DEBOUTLN(cout, "charsetnA: CS= ", CS);
+    DEBOUTLN(CERR, "charsetnA: CS= ", CS);
     Remembern.FS1 = Union(Remembern.FS1, initalset1(CS));
-    DEBOUTLN(cout, "charsetnA: Remembern.FS1= ", Remembern.FS1);
-    DEBOUTLN(cout, "charsetnA: Remembern.FS2= ", Remembern.FS2);
+    DEBOUTLN(CERR, "charsetnA: Remembern.FS1= ", Remembern.FS1);
+    DEBOUTLN(CERR, "charsetnA: Remembern.FS2= ", Remembern.FS2);
     RS = CFList();
     if ( CS.length() == nas && degree(CS.getLast(),vf) > 0 ) {
       CFList D = Difference( QS, CS );
-      DEBOUT(cout, "charsetnA: Difference( ", QS);
-      DEBOUT(cout, " , ", CS);
-      DEBOUTLN(cout, " ) = ", D);
+      DEBOUT(CERR, "charsetnA: Difference( ", QS);
+      DEBOUT(CERR, " , ", CS);
+      DEBOUTLN(CERR, " ) = ", D);
       for ( CFListIterator i = D; i.hasItem(); ++i ) {
         CanonicalForm r = Prem( i.getItem(), CS );
-        DEBOUT(cout,"charsetnA: Prem(", i.getItem()  );
-        DEBOUT(cout, ",", CS);
-        DEBOUTLN(cout,") = ", r);
+        DEBOUT(CERR,"charsetnA: Prem(", i.getItem()  );
+        DEBOUT(CERR, ",", CS);
+        DEBOUTLN(CERR,") = ", r);
         if ( r != 0 ){
           //removefactor( r, Remembern );
@@ -106 +106 @@
       }
       if ( ! checkok(RS,Remembern.FS2)) return CFList(CanonicalForm(1));
-      DEBOUTLN(cout, "charsetnA: RS= ", RS);
+      DEBOUTLN(CERR, "charsetnA: RS= ", RS);
       //QS = Union( QS, RS );
       QS=Union(AS,RS); QS.append(CS.getLast());
-      DEBOUTLN(cout, "charsetnA: QS= Union(QS,RS)= ", QS);
+      DEBOUTLN(CERR, "charsetnA: QS= Union(QS,RS)= ", QS);
     }
     else{ return CFList(CanonicalForm(1)); }
   }
-  DEBOUTLN(cout, "charsetnA: Removed factors: ", Remembern.FS2);
-  DEBOUTLN(cout, "charsetnA: Remembern.FS1: ", Remembern.FS1);
+  DEBOUTLN(CERR, "charsetnA: Removed factors: ", Remembern.FS2);
+  DEBOUTLN(CERR, "charsetnA: Remembern.FS1: ", Remembern.FS1);
 
   return CS;
@@ -140 +140 @@
 //   nas= as.length()+1;
 
-  DEBOUTLN(cout, "algcd called with f= ", f);
-  DEBOUTLN(cout, "                  g= ", g);
-  DEBOUTLN(cout, "                 as= ", as);
-  DEBOUTLN(cout, "              order= ", order);
-  DEBOUTLN(cout, "         choosen vf= ", vf);
+  DEBOUTLN(CERR, "algcd called with f= ", f);
+  DEBOUTLN(CERR, "                  g= ", g);
+  DEBOUTLN(CERR, "                 as= ", as);
+  DEBOUTLN(CERR, "              order= ", order);
+  DEBOUTLN(CERR, "         choosen vf= ", vf);
 
   // check trivial case:
   if ( degree(f, order.getLast())==0 || degree(g, order.getLast())==0)
   {
-    DEBOUTLN(cout, "algcd Result= ", 1);
+    DEBOUTLN(CERR, "algcd Result= ", 1);
     return CanonicalForm(1);
   }
@@ -156 +156 @@
   PremForm Remembern;
   CFList cs=charsetnA(as,bs,Remembern,vf);
-  DEBOUTLN(cout, "CharSetA((as,bs))= ", cs);
+  DEBOUTLN(CERR, "CharSetA((as,bs))= ", cs);
 
 //    for ( VarlistIterator i=order; i.hasItem() ; i++ ){
-//      DEBOUTLN(cout, "vf= ", i.getItem());
-//      DEBOUTLN(cout, "CharSetA((as,bs))= " , charsetnA(as,bs,Remembern,i.getItem()));
+//      DEBOUTLN(CERR, "vf= ", i.getItem());
+//      DEBOUTLN(CERR, "CharSetA((as,bs))= " , charsetnA(as,bs,Remembern,i.getItem()));
 //    }
 
@@ -180 +180 @@
   }
   else result= CanonicalForm(1);
-  DEBOUTLN(cout, "algcd Result= ", result);
+  DEBOUTLN(CERR, "algcd Result= ", result);
   return result;
 }
@@ -192 +192 @@
   CFFList result;
 
-  DEBINCLEVEL(cout, "factoras");
-  DEBOUTMSG(cerr, rcsid);
-  DEBOUTLN(cout, "factoras called with f= ", f);
-  DEBOUTLN(cout, "               content(f)= ", content(f));
-  DEBOUTLN(cout, "                       as= ", as);
-  DEBOUTLN(cout, "factoras: cls(vf)= ", cls(vf));
-  DEBOUTLN(cout, "factoras: cls(as.getLast())= ", cls(as.getLast()));
-  DEBOUTLN(cout, "factoras: degree(f,vf)= ", degree(f,vf));
+  DEBINCLEVEL(CERR, "factoras");
+  DEBOUTMSG(CERR, rcsid);
+  DEBOUTLN(CERR, "factoras called with f= ", f);
+  DEBOUTLN(CERR, "               content(f)= ", content(f));
+  DEBOUTLN(CERR, "                       as= ", as);
+  DEBOUTLN(CERR, "factoras: cls(vf)= ", cls(vf));
+  DEBOUTLN(CERR, "factoras: cls(as.getLast())= ", cls(as.getLast()));
+  DEBOUTLN(CERR, "factoras: degree(f,vf)= ", degree(f,vf));
 
 // F1: [Test trivial cases]
@@ -208 +208 @@
        ){
     success=1;
-    DEBDECLEVEL(cout,"factoras");
+    DEBDECLEVEL(CERR,"factoras");
     return CFFList(CFFactor(f,1));
   }
@@ -234 +234 @@
   }
   uord= Difference(uord,ord);
-  DEBOUTLN(cout, "Astar is: ", Astar);
-  DEBOUTLN(cout, "ord is: ", ord);
-  DEBOUTLN(cout, "uord is: ", uord);
+  DEBOUTLN(CERR, "Astar is: ", Astar);
+  DEBOUTLN(CERR, "ord is: ", ord);
+  DEBOUTLN(CERR, "uord is: ", uord);
 
 // 3) second trivial cases
   if ( Astar.length() == 0 ){
     success=1;
-    DEBDECLEVEL(cout,"factoras");
+    DEBDECLEVEL(CERR,"factoras");
     return CFFList(CFFactor(f,1));
   }
@@ -258 +258 @@
   CanonicalForm substhin=CanonicalForm(vf), substback=CanonicalForm(vf);
   CanonicalForm monom;
-  DEBOUTLN(cout, "substhin= ", substhin);
-  DEBOUTLN(cout, "substback= ", substback);
+  DEBOUTLN(CERR, "substhin= ", substhin);
+  DEBOUTLN(CERR, "substback= ", substback);
   int j=1;
   for ( VarlistIterator jjj=ord; jjj.hasItem(); jjj++){
@@ -267 +267 @@
     substhin-= monom; substback+= monom;
   }
-  DEBOUTLN(cout, "substhin= ", substhin);
-  DEBOUTLN(cout, "substback= ", substback);
+  DEBOUTLN(CERR, "substhin= ", substhin);
+  DEBOUTLN(CERR, "substback= ", substback);
   CanonicalForm fstar=f(substhin,vf);
-  DEBOUTLN(cout, "fstar= ", fstar);
+  DEBOUTLN(CERR, "fstar= ", fstar);
 
 // 7) Set up Variable ordering from ord,vf to vf,ord ! i.e. vf is the variable
@@ -276 +276 @@
   Varlist nord=uord;
   nord.append(vf); nord= Union(ord,nord);
-  DEBOUTLN(cout, "          nord= ", nord);
+  DEBOUTLN(CERR, "          nord= ", nord);
   CFList Astarnord= Astar; Astarnord.insert(fstar);
-  DEBOUTLN(cout, "     Astarnord= ", Astarnord);
+  DEBOUTLN(CERR, "     Astarnord= ", Astarnord);
   Astarnord= reorder(nord,Astarnord);
-  DEBOUTLN(cout, "original Astar= ", Astar);
-  DEBOUTLN(cout, "reorderd Astar= ", Astarnord);
-  DEBOUTLN(cout, "             f= ", f);
-  DEBOUTLN(cout, "         fstar= ", fstar);
+  DEBOUTLN(CERR, "original Astar= ", Astar);
+  DEBOUTLN(CERR, "reorderd Astar= ", Astarnord);
+  DEBOUTLN(CERR, "             f= ", f);
+  DEBOUTLN(CERR, "         fstar= ", fstar);
 
 // 8) Compute Charset Cstar of Astar \cup { fstar } wrt. ordering {vf, ord}
   PremForm Remembern;
   CFList Cstar= MCharSetN(Astarnord, Remembern);
-  DEBOUTLN(cout, " Cstar= ", Cstar );
-  DEBOUTLN(cout, " Factors removed= ", Remembern.FS2 );
-  DEBOUTLN(cout, " Possible Factors considered:= ", Remembern.FS1 );
-  DEBOUTLN(cout, " Reorderd Cstar= ", reorder(nord,Cstar));
+  DEBOUTLN(CERR, " Cstar= ", Cstar );
+  DEBOUTLN(CERR, " Factors removed= ", Remembern.FS2 );
+  DEBOUTLN(CERR, " Possible Factors considered:= ", Remembern.FS1 );
+  DEBOUTLN(CERR, " Reorderd Cstar= ", reorder(nord,Cstar));
 
 // 9) Compute Delta: the set of all irr. factors (over K_0) of initials of
 //    Cstar
   CFList iniset= initalset1(Cstar);
-  DEBOUTLN(cout, "Set of initials: ", iniset);
+  DEBOUTLN(CERR, "Set of initials: ", iniset);
   CFFList Delta;
   CFFList temp;
@@ -306 +306 @@
     Delta= Union(temp,Delta);
   }
-  DEBOUTLN(cout, "Delta= ", Delta);
+  DEBOUTLN(CERR, "Delta= ", Delta);
 
 // 10) Compute Psi: the irreduzible factors (over K_0) of the first polynomial
@@ -315 +315 @@
   Psi.removeFirst();
   Psi= myDifference(Psi,Delta);
-  DEBOUTLN(cout, "Psi= ", Psi);
+  DEBOUTLN(CERR, "Psi= ", Psi);
 
 // F3: [Test quasilinearity]
@@ -322 +322 @@
 // else D.nextpoint() -> F2
   if ( isquasilinear(Cstar) ) {
-    DEBOUTLN(cout, "Cstar is quasilinear; going to F4, Cstar= ", Cstar);
+    DEBOUTLN(CERR, "Cstar is quasilinear; going to F4, Cstar= ", Cstar);
     goto F4;
   }
@@ -328 +328 @@
     Delta= Union(Psi,Delta);
     Psi= CFFList();
-    DEBOUTMSG(cout, "Psi.length() == 1; going to F4");
+    DEBOUTMSG(CERR, "Psi.length() == 1; going to F4");
     goto F4;
   }
   else{
     D.nextpoint();
-    DEBOUTMSG(cout, "Choosing next evaluation point. going to F2");
+    DEBOUTMSG(CERR, "Choosing next evaluation point. going to F2");
     goto F2;
   }
@@ -341 +341 @@
   Delta= reorder(nord,Delta);
   Psi= reorder(nord,Psi);
-  DEBOUTLN(cout, "Reordered: Delta= ", Delta);
-  DEBOUTLN(cout, "             Psi= ", Psi);
+  DEBOUTLN(CERR, "Reordered: Delta= ", Delta);
+  DEBOUTLN(CERR, "             Psi= ", Psi);
   CanonicalForm fp;
 
-  DEBOUTMSG(cout, "Testing Psi: this gives irreducible Factors!");
+  DEBOUTMSG(CERR, "Testing Psi: this gives irreducible Factors!");
   for (jj=Psi; jj.hasItem(); jj++){
     if ( degree(g,vf) == 1 ) { // g is linear
@@ -351 +351 @@
     }
     fp= jj.getItem().factor();
-    DEBOUT(cout, "Calculating fp= gcd(", g);
-    DEBOUT(cout, ",", fp(substback,vf));
-    DEBOUT(cout, ") over K_r wrt ", vf);
+    DEBOUT(CERR, "Calculating fp= gcd(", g);
+    DEBOUT(CERR, ",", fp(substback,vf));
+    DEBOUT(CERR, ") over K_r wrt ", vf);
     fp=alg_gcd(g,fp(substback,vf), as);
     //fp= algcd(g,fp(substback,vf), as, oldord);
-    DEBOUTLN(cout, " = ", fp);
+    DEBOUTLN(CERR, " = ", fp);
     if ( degree(fp,vf) > 0 ){ //otherwise it's a constant
       g= divide(g, fp,as);
-      DEBOUTLN(cout, "f/fp= ", g);
+      DEBOUTLN(CERR, "f/fp= ", g);
       result.append(CFFactor(fp,1));
     }
   }
 
-  DEBOUTMSG(cout, "Testing Delta: this gives Factors (not nec. irreduzible!)");
+  DEBOUTMSG(CERR, "Testing Delta: this gives Factors (not nec. irreduzible!)");
   for (jj=Delta; jj.hasItem(); jj++){
     if ( degree(g,vf) <= 1 ) { // g is linear (or a constant..)
@@ -370 +370 @@
     }
     fp= jj.getItem().factor();
-    DEBOUT(cout, "Calculating fp= gcd(", g);
-    DEBOUT(cout, ",", fp(substback,vf));
-    DEBOUT(cout, ") over K_r wrt ", vf);
+    DEBOUT(CERR, "Calculating fp= gcd(", g);
+    DEBOUT(CERR, ",", fp(substback,vf));
+    DEBOUT(CERR, ") over K_r wrt ", vf);
     fp= alg_gcd(g,fp(substback,vf), as);
     //fp= algcd(g,fp(substback,vf), as, oldord);
-    DEBOUTLN(cout, " = ", fp);
+    DEBOUTLN(CERR, " = ", fp);
     if ( degree(fp,vf) > 0 ){ //otherwise it's a constant
       g= divide(g, fp,as);
-      DEBOUTLN(cout, "f/fp= ", g);
+      DEBOUTLN(CERR, "f/fp= ", g);
 //      reduceresult.append(fp); // a facctor but not nec. irreduzible
       result.append(CFFactor(fp,1));
@@ -396 +396 @@
     if ( isquasilinear(Cstar) ){ // Cstar quasilinear => f is irreduzible
       success=1;
-      DEBDECLEVEL(cout,"factoras");
+      DEBDECLEVEL(CERR,"factoras");
       return CFFList(CFFactor(f,1));
     }
     else {
-      DEBOUTMSG(cout, "Going to F2!");
+      DEBOUTMSG(CERR, "Going to F2!");
       D.nextpoint(); // choose a new set of int's.
       goto F2;
@@ -408 +408 @@
   success=1;
   result.append(CFFactor(g,1)); //append the rest
-  DEBDECLEVEL(cout,"factoras");
+  DEBDECLEVEL(CERR,"factoras");
   return result;
 }
@@ -426 +426 @@
   success=1;
   for ( CFFListIterator i=Factors; i.hasItem(); i++ ){
-    CFFList coutput=factoras(i.getItem().factor(),as,csuccess);
+    CFFList CERR=factoras(i.getItem().factor(),as,csuccess);
     success= min(success,csuccess);
-    for ( CFFListIterator j=coutput; j.hasItem(); j++)
+    for ( CFFListIterator j=CERR; j.hasItem(); j++)
       Output = myappend(Output,CFFactor(j.getItem().factor(),j.getItem().exp()*i.getItem().exp()));
   }
@@ -450 +450 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.6  2002/08/19 11:11:30  Singular
+* hannes/pfister: alg_gcd etc.
+
 Revision 1.5  2001/06/27 13:58:05  Singular
 *hannes/GP: debug newfactoras, char_series, ...

libfac/charset/charset.cc

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-static char * rcsid = "$Id: charset.cc,v 1.10 2002-08-19 11:11:31 Singular Exp $";
+static char * rcsid = "$Id: charset.cc,v 1.11 2006-05-16 14:46:49 Singular Exp $";
 /////////////////////////////////////////////////////////////
 // FACTORY - Includes
 #include <factory.h>
+#ifdef HAVE_IOSTREAM
+#define CIN std::cin
+#else
+#define CIN cin
+#endif
 // Factor - Includes
 #include <SqrFree.h>
@@ -55 +60 @@
     int cb;
 
-    DEBOUTLN(cout, "BasicSet: called with ps= ", PS);
+    DEBOUTLN(CERR, "BasicSet: called with ps= ", PS);
     if ( PS.length() < 2 ) return PS;
     while ( ! QS.isEmpty() ) {
         b = lowestRank( QS );
         cb = rank( b );
-        DEBOUTLN(cout, "BasicSet: choose b  = ", b);
-        DEBOUTLN(cout, "BasicSet: it's rank = ", cb);
+        DEBOUTLN(CERR, "BasicSet: choose b  = ", b);
+        DEBOUTLN(CERR, "BasicSet: it's rank = ", cb);
         BS=Union(CFList(b),BS);//BS.append( b );
         if ( rank( b ) == 0 )
@@ -76 +81 @@
         }
     }
-    DEBOUTLN(cout, "BasicSet: returning bs= ", BS);
+    DEBOUTLN(CERR, "BasicSet: returning bs= ", BS);
     return BS;
 }
@@ -109 +114 @@
   CFList QS = PS, RS = PS, CS, OLDCS;
 
-  DEBOUTLN(cout, "MCharSetN: called with ps= ", PS);
+  DEBOUTLN(CERR, "MCharSetN: called with ps= ", PS);
   while ( ! RS.isEmpty() ) {
     CS = BasicSet( QS );
     OLDCS=CS;
-    DEBOUTLN(cout, "MCharSetN: CS= ", CS);
+    DEBOUTLN(CERR, "MCharSetN: CS= ", CS);
 //     if ( getNumVars(CS.getFirst()) > 1 ){
 //       //CS = removecontent(CS, Remembern);
 // #ifdef MCHARSETNDEBUG
-//       cout << "MCharSetN: CS= " << CS << endl;
+//       CERR << "MCharSetN: CS= " << CS << "\n";
 // #endif
 //     }
     Remembern.FS1 = Union(Remembern.FS1, initalset1(CS));
-    DEBOUTLN(cout, "MCharSetN: Remembern.FS1= ", Remembern.FS1);
-    DEBOUTLN(cout, "MCharSetN: Remembern.FS2= ", Remembern.FS2);
+    DEBOUTLN(CERR, "MCharSetN: Remembern.FS1= ", Remembern.FS1);
+    DEBOUTLN(CERR, "MCharSetN: Remembern.FS2= ", Remembern.FS2);
     RS = CFList();
     if ( rank( CS.getFirst() ) != 0 ) {
       CFList D = Difference( QS, CS );
-      DEBOUT(cout, "MCharSetN: Difference( ", QS);
-      DEBOUT(cout, " , ", CS);
-      DEBOUTLN(cout, " ) = ", D);
-//cout << "MCharSetN: Difference( " << QS << " , " << CS << " ) = " << D << endl;
+      DEBOUT(CERR, "MCharSetN: Difference( ", QS);
+      DEBOUT(CERR, " , ", CS);
+      DEBOUTLN(CERR, " ) = ", D);
+//CERR << "MCharSetN: Difference( " << QS << " , " << CS << " ) = " << D << "\n";
       //PremForm Oldremember=Remembern;
       //PremForm Newremember=Remembern;
       for ( CFListIterator i = D; i.hasItem(); ++i ) {
         CanonicalForm r = Prem( i.getItem(), CS );
-        DEBOUT(cout,"MCharSetN: Prem(", i.getItem()  );
-        DEBOUT(cout, ",", CS);
-        DEBOUTLN(cout,") = ", r);
-//cout << "MCharSetN: Prem("<< i.getItem() << "," << CS << ") = " << r << endl;
+        DEBOUT(CERR,"MCharSetN: Prem(", i.getItem()  );
+        DEBOUT(CERR, ",", CS);
+        DEBOUTLN(CERR,") = ", r);
+//CERR << "MCharSetN: Prem("<< i.getItem() << "," << CS << ") = " << r << "\n";
         if ( r != 0 ){
           //removefactor( r, Newremember );
@@ -149 +154 @@
       }
       if ( ! checkok(RS,Remembern.FS2)) return CFList(CanonicalForm(1));
-      DEBOUTLN(cout, "MCharSetN: RS= ", RS);
+      DEBOUTLN(CERR, "MCharSetN: RS= ", RS);
       //QS = Union( QS, RS );
       QS = Union(OLDCS,RS);
-      DEBOUTLN(cout, "MCharSetN: QS= Union(QS,RS)= ", QS);
+      DEBOUTLN(CERR, "MCharSetN: QS= Union(QS,RS)= ", QS);
     }
     else{ return CFList(CanonicalForm(1)); }
   }
-  DEBOUTLN(cout, "MCharSetN: Removed factors: ", Remembern.FS2);
-  DEBOUTLN(cout, "MCharSetN: Remembern.FS1: ", Remembern.FS1);
+  DEBOUTLN(CERR, "MCharSetN: Removed factors: ", Remembern.FS2);
+  DEBOUTLN(CERR, "MCharSetN: Remembern.FS1: ", Remembern.FS1);
 
   return CS;
@@ -168 +173 @@
   CFList rs= remsetb(Difference(PS,cs),cs);
 
-  DEBOUTLN(cout, "mcharset: cs= ", cs);
-  DEBOUTLN(cout, "mcharset: rs= ", rs);
+  DEBOUTLN(CERR, "mcharset: cs= ", cs);
+  DEBOUTLN(CERR, "mcharset: rs= ", rs);
   if ( rs.length() > 0 )
     cs= mcharset(Union(PS,Union(cs,rs)), Remembern);
@@ -182 +187 @@
   while ( ! RS.isEmpty() ) {
     CS = BasicSet( QS );
-    DEBOUTLN(cout, "CharSet: CS= ", CS);
+    DEBOUTLN(CERR, "CharSet: CS= ", CS);
     RS = CFList();
     if ( rank( CS.getFirst() ) != 0 ) {
@@ -343 +348 @@
 choosefrom(){
 int choice;
-    cout << "choose from qhi! ->";
-    cin >> choice;
+    CERR << "choose from qhi! ->";
+    CIN >> choice;
 return choice;
 }
@@ -353 +358 @@
   ListCFList output;
 
-  cout << "Sort: list to sort is: " <<  list_to_sort << endl;
+  CERR << "Sort: list to sort is: " <<  list_to_sort << "\n";
   for (int i=1; i<= number; i++){
-    cout << " Next elem = "; cin >> nr;
+    CERR << " Next elem = "; CIN >> nr;
     output.append(getItemNr(nr,list_to_sort));
   }
@@ -379 +384 @@
 #endif
 
-  DEBOUTMSG(cout, rcsid);
-//  cout << getCharacteristic() << endl;
+  DEBOUTMSG(CERR, rcsid);
+//  CERR << getCharacteristic() << "\n";
   for ( CFListIterator Ps=PS; Ps.hasItem(); Ps++ )
     if ( level(Ps.getItem() ) > highestlevel ) highestlevel = level(Ps.getItem()) ;
 //  for ( int xx=1; xx <= highestlevel; xx++)
-//   cout << Variable(xx) ;
-//  cout << endl;
+//   CERR << Variable(xx) ;
+//  CERR << "\n";
 //  for ( CFListIterator Ps=PS; Ps.hasItem(); Ps++ )
-//    cout << Ps.getItem() << ", " ;//<< endl;
-//  cout <<  endl;
+//    CERR << Ps.getItem() << ", " ;//<< "\n";
+//  CERR <<  "\n";
   while ( ! qhi.isEmpty() ) {
     qhi=sort(qhi);
-    DEBOUTLN(cout, "qhi is: ", qhi);
+    DEBOUTLN(CERR, "qhi is: ", qhi);
 #ifdef EXPERIMENTAL
     choice=choosefrom();
-    cout <<"/n Choose " << choice << endl;
+    CERR <<"/n Choose " << choice << "\n";
     qs= getItemNr(choice, qhi);
 #else
     qs=qhi.getFirst();
 #endif
-    DEBOUTLN(cout, "qs  is: ", qs);
-    DEBOUTLN(cout, "ppi is: ", ppi);
+    DEBOUTLN(CERR, "qs  is: ", qs);
+    DEBOUTLN(CERR, "ppi is: ", ppi);
     ListCFList ppi1,ppi2;
     select(ppi,qs.length(),ppi1,ppi2);
-    DEBOUTLN(cout, "ppi1 is: ", ppi1);
-    DEBOUTLN(cout, "ppi2 is: ", ppi2);
+    DEBOUTLN(CERR, "ppi1 is: ", ppi1);
+    DEBOUTLN(CERR, "ppi2 is: ", ppi2);
     qqi = MyUnion(ppi2,qqi);
-    DEBOUTLN(cout, "qqi is: ", qqi);
+    DEBOUTLN(CERR, "qqi is: ", qqi);
     if ( nr_of_iteration == 0 ){ nr_of_iteration += 1; ppi = ListCFList(); }
     else{ nr_of_iteration += 1; ppi = MyUnion(ListCFList(qs),ppi1); }
-    DEBOUTLN(cout,"ppi is: ", ppi);
+    DEBOUTLN(CERR,"ppi is: ", ppi);
     PremForm Remembern;
     cs = MCharSetN(qs,Remembern);
-    DEBOUTLN(cout, "cs is: ", cs);
-    DEBOUTLN(cout, "factorset is: ", Remembern.FS2);
+    DEBOUTLN(CERR, "cs is: ", cs);
+    DEBOUTLN(CERR, "factorset is: ", Remembern.FS2);
     cs = removecontent(cs,Remembern);
     factorset=Remembern.FS2;
-    DEBOUTLN(cout, "cs (after removecontent) is: ", cs);
-    DEBOUTLN(cout, "factorset is: ", factorset);
+    DEBOUTLN(CERR, "cs (after removecontent) is: ", cs);
+    DEBOUTLN(CERR, "factorset is: ", factorset);
     // Hier: removecontent einfuegen!!!!
     if ( cls(cs.getFirst()) > 0 ){
@@ -426 +431 @@
       // INTERRUPTHANDLER
 
-      DEBOUTLN(cout, "ts is: ", ts);
-      DEBOUTLN(cout, "ts2 is: ", ts2);
+      DEBOUTLN(CERR, "ts is: ", ts);
+      DEBOUTLN(CERR, "ts2 is: ", ts2);
       // next is preliminary: should be ==0
       if ( ts2 <= 0 ){ //irreducible
         if ( ! subset(cs,qs) ){
-          DEBOUTMSG(cout, "cs is not a subset of qs");
+          DEBOUTMSG(CERR, "cs is not a subset of qs");
           cs = charseta(Union(qs,cs));
-          DEBOUTLN(cout, "new cs is: ", cs);
+          DEBOUTLN(CERR, "new cs is: ", cs);
         }
         if ( ! member(cs,pi) ){
           pi = MyUnion(pi, ListCFList(cs));
-          DEBOUTMSG(cout, "cs is not a member of pi");
-          DEBOUTLN(cout, "pi is: ", pi);
+          DEBOUTMSG(CERR, "cs is not a member of pi");
+          DEBOUTLN(CERR, "pi is: ", pi);
           if ( cls(cs.getFirst()) > 0 ){
             ts = irras(cs,ts2,reducible);
@@ -446 +451 @@
             // INTERRUPTHANDLER
 
-            DEBOUTLN(cout, "ts is: ", ts);
-            DEBOUTLN(cout, "ts2 is: ", ts2);
+            DEBOUTLN(CERR, "ts is: ", ts);
+            DEBOUTLN(CERR, "ts2 is: ", ts2);
             // next is preliminary: should be ==0
             if ( ts2 <= 0 ){ //irreducible
               qsi = MyUnion(qsi,ListCFList(cs));
-              DEBOUTLN(cout, "qsi is: ", qsi);
+              DEBOUTLN(CERR, "qsi is: ", qsi);
               if ( cs.length() == highestlevel ){
-                DEBOUTLN(cout, "cs.length() == nops(ord) :", cs.length());
+                DEBOUTLN(CERR, "cs.length() == nops(ord) :", cs.length());
                 is = factorps(factorset);
               }
               else{
-                DEBOUT(cout,"cs.length() != nops(ord) :", cs.length());
-                DEBOUTLN(cout, "  nops(ord)= ", highestlevel);
+                DEBOUT(CERR,"cs.length() != nops(ord) :", cs.length());
+                DEBOUTLN(CERR, "  nops(ord)= ", highestlevel);
                 is = Union(initalset1(cs),factorps(factorset));
               }
-              DEBOUTLN(cout, "is is: ", is);
+              DEBOUTLN(CERR, "is is: ", is);
               iss = adjoin(is,qs,qqi);
-              DEBOUTLN(cout, "iss is: ", iss);
+              DEBOUTLN(CERR, "iss is: ", iss);
             }
           }
@@ -469 +474 @@
         }
         else{
-          DEBOUTMSG(cout, "cs is a member of pi");
+          DEBOUTMSG(CERR, "cs is a member of pi");
           iss = adjoin(factorps(factorset),qs,qqi); }
-        DEBOUTLN(cout, "iss is: ", iss);
-        DEBOUTLN(cout, "   factorps(factorset)= ", factorps(factorset));
-        DEBOUTLN(cout, "   qs= ", qs);
-        DEBOUTLN(cout, "   qqi= ", qqi);
+        DEBOUTLN(CERR, "iss is: ", iss);
+        DEBOUTLN(CERR, "   factorps(factorset)= ", factorps(factorset));
+        DEBOUTLN(CERR, "   qs= ", qs);
+        DEBOUTLN(CERR, "   qqi= ", qqi);
       }
       // next is preliminary: should be !=0
       if ( ts2 > 0 ){
         is = factorps(factorset);
-        DEBOUTLN(cout, "is is: ", is);
+        DEBOUTLN(CERR, "is is: ", is);
         if ( ts2 > 1 ){
           // setup cst: need it later for adjoinb
@@ -491 +496 @@
         }
         else{ iss = adjoin(Union(is,ts),qs,qqi); }
-        DEBOUTLN(cout, "iss is: ", iss);
+        DEBOUTLN(CERR, "iss is: ", iss);
       }
     }
     else{
       iss = adjoin(factorps(factorset),qs,qqi);
-      DEBOUTMSG(cout, "case: cs is a constant.");
-      DEBOUTLN(cout, "  qs = ", qs);
-      DEBOUTLN(cout, "  qqi = ", qqi);
-      DEBOUTLN(cout, "  iss = adjoin(factorps(factorset),qs,qqi) = ",iss);
+      DEBOUTMSG(CERR, "case: cs is a constant.");
+      DEBOUTLN(CERR, "  qs = ", qs);
+      DEBOUTLN(CERR, "  qqi = ", qqi);
+      DEBOUTLN(CERR, "  iss = adjoin(factorps(factorset),qs,qqi) = ",iss);
     }
     if ( qhi.length() > 1 ){ qhi.removeFirst(); qhi = MyUnion(qhi,iss); }
     else{ qhi = iss; }
-    DEBOUTLN(cout, "iss is: ", iss);
+    DEBOUTLN(CERR, "iss is: ", iss);
   }
   if ( ! qsi.isEmpty() ){
-    DEBOUTLN(cout, "qsi before contract= ", qsi);
+    DEBOUTLN(CERR, "qsi before contract= ", qsi);
     if ( opt == 0 ){
        return contract( qsi );
@@ -534 +539 @@
 
   ja = 0;
-  DEBOUTLN(cout, "irras: called with: AS= ", AS);
+  DEBOUTLN(CERR, "irras: called with: AS= ", AS);
   for ( i=AS; i.hasItem(); i++ ){
     elem = i.getItem();
     nr += 1;
-    DEBOUT(cout, "irras: factoring: ", elem);
+    DEBOUT(CERR, "irras: factoring: ", elem);
     if ( degree(elem) > 1 ) // linear poly's are irreduzible
     {
@@ -547 +552 @@
       qs.insert(CFFactor(CanonicalForm(1),1));
     }
-    DEBOUTLN(cout, "  = ", qs);
+    DEBOUTLN(CERR, "  = ", qs);
     // INTERRUPTHANDLER
     if ( interrupt_handle() ) return CFList() ;
@@ -553 +558 @@
     qs.removeFirst();
     if ( (qs.length() >= 2 ) || (qs.getFirst().exp() > 1)){
-      DEBOUTLN(cout, "irras: Setting ind=0, ja= ", nr);
+      DEBOUTLN(CERR, "irras: Setting ind=0, ja= ", nr);
       ja=nr; ind=0; reducible= elem;
       break;
@@ -559 +564 @@
     //    else{ as.append(elem) ; }
   }
-  //  cout << "ind= " << ind << endl;
+  //  CERR << "ind= " << ind << "\n";
   if ( (ind == 1) ){ //&& ( as.length() > 1) ){
     if ( irreducible(AS) ){ // as quasilinear? => irreducible!
       ja = 0;
-      DEBOUTLN(cout, "as is irreducible. as= ", AS);
+      DEBOUTLN(CERR, "as is irreducible. as= ", AS);
     }
     else {
@@ -572 +577 @@
         if ( degree(i.getItem()) > 1 ){// search for a non linear elem
           elem=i.getItem();
-//          cout << "f=  " << elem << endl;
-//        cout << "as= " << as << endl;
+//          CERR << "f=  " << elem << "\n";
+//        CERR << "as= " << as << "\n";
           qs= newfactoras(elem,as,success);
-//          cout << "irras:newfactoras    qs= " << qs << endl;
+//          CERR << "irras:newfactoras    qs= " << qs << "\n";
 //          qs= factoras(elem,as,success);
-//          cout << "irras:factoras qs= " << qs << endl;
+//          CERR << "irras:factoras qs= " << qs << "\n";
           if ( qs.length() > 1 || qs.getFirst().exp() > 1 ){ //found elem is reducible
             reducible=elem;
@@ -594 +599 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.10  2002/08/19 11:11:31  Singular
+* hannes/pfister: alg_gcd etc.
+
 Revision 1.9  2001/08/08 14:26:54  Singular
 *hannes: Dan's HAVE_SINGULAR_ERROR

libfac/charset/csutil.cc

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-static char * rcsid = "$Id: csutil.cc,v 1.11 2006-05-16 13:48:13 Singular Exp $";
+static char * rcsid = "$Id: csutil.cc,v 1.12 2006-05-16 14:46:49 Singular Exp $";
 /////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -48 +48 @@
   f = i.getItem(); ++i;
   while ( i.hasItem() ) {
-    //cout << "comparing " << f << "  and " << i.getItem()
-    // << " == " << lowerRank( i.getItem(), f, ind ) << endl;
+    //CERR << "comparing " << f << "  and " << i.getItem()
+    // << " == " << lowerRank( i.getItem(), f, ind ) << "\n";
     if ( lowerRank( i.getItem(), f, ind ) ) {
       if ( ind ){
@@ -56 +56 @@
 
         // Have to further compare number of terms!
-        //cout << "compare terms! f= " << Flist.length() << "  item= "
-        //     << Itemlist.length() <<endl;
+        //CERR << "compare terms! f= " << Flist.length() << "  item= "
+        //     << Itemlist.length() <<"\n";
         if ( Itemlist.length() < Flist.length()) f = i.getItem();
         ind=0;
@@ -129 +129 @@
     else { l = 1; }
     while ( ( dg <= df  ) && ( ff != ff.genZero()) ){
-      // cout << "Start gcd..." << endl;
+      // CERR << "Start gcd..." << "\n";
       test = gcd(l,LC(ff));
-      //cout << "gcd(" << l << "," << LC(ff) << ")= " << test << endl;
+      //CERR << "gcd(" << l << "," << LC(ff) << ")= " << test << "\n";
       lu = l/test; lv = LC(ff)/test;
       t = power(v,df-dg) * gg * lv;
@@ -216 +216 @@
   else
     r= Sprem(ff,f,m,q); //result in q, ignore r,m
-  //cout << "r= " << r << "  , m= " << m << "  , q= " << q << endl;
+  //CERR << "r= " << r << "  , m= " << m << "  , q= " << q << "\n";
   r= Prem(q,as);
-  //cout << "r= " << r << endl;
+  //CERR << "r= " << r << "\n";
   //out_cf(" ->",r,"\n");
   return r;
@@ -233 +233 @@
      On(SW_RATIONAL);
      CanonicalForm temp= mapinto(rem);
-//      cout << "temp= " << temp << endl;
-//      cout << "lc(temp)= " << lc(temp) << endl;
-//      cout << "temp/lc(temp)= " << temp/lc(temp) << endl;
-//      cout << "num(rem/lc(rem))= " << num(rem/lc(rem)) << endl;
+//      CERR << "temp= " << temp << "\n";
+//      CERR << "lc(temp)= " << lc(temp) << "\n";
+//      CERR << "temp/lc(temp)= " << temp/lc(temp) << "\n";
+//      CERR << "num(rem/lc(rem))= " << num(rem/lc(rem)) << "\n";
      temp= bCommonDen(temp/lc(temp))*(temp/lc(temp));
      Off(SW_RATIONAL);
@@ -252 +252 @@
   CFListIterator i = L;
   for ( i.lastItem(); i.hasItem(); i-- ){
-//cout << "   PREM: Prem(" << rem << "," ;
+//CERR << "   PREM: Prem(" << rem << "," ;
     rem = Prem( rem, i.getItem() );
-//cout << "   PREM: Prem(" << rem << "," << i.getItem() << ")  = " << rem << endl;
+//CERR << "   PREM: Prem(" << rem << "," << i.getItem() << ")  = " << rem << "\n";
   }
   return myfitting(rem);
@@ -314 +314 @@
     if (!(j.coeff().isOne()) ) count += 1;
   //  if ( init != 1 ){
-  //  cout << "nopower: f is " << init << endl;
-  //  cout << "nopower: count is " << count << endl;}
+  //  CERR << "nopower: f is " << init << "\n";
+  //  CERR << "nopower: count is " << count << "\n";}
   if ( count > 1 ) sqrfreelist = CFFList( CFFactor(init,1));
   else {
@@ -395 +395 @@
     }
   }
-  //  cout << "Remembern.FS1 = " << Remembern.FS1 << endl;
-  //  cout << "Remembern.FS2 = " << Remembern.FS2 << endl;
+  //  CERR << "Remembern.FS1 = " << Remembern.FS1 << "\n";
+  //  CERR << "Remembern.FS2 = " << Remembern.FS2 << "\n";
   //  Remembern.FS1 = Difference(Remembern.FS1, Remembern.FS2);
-  //  cout << "  New Remembern.FS1 = " << Remembern.FS1 << endl;
+  //  CERR << "  New Remembern.FS1 = " << Remembern.FS1 << "\n";
 }
 
@@ -529 +529 @@
 // AS is given by AS = { A1, A2, .. Ar }, d_i = degree(Ai)
 
-  DEBOUTMSG(cout, rcsid);
+  DEBOUTMSG(CERR, rcsid);
 // 1) we test: if d_i > 1, d_j =1 for all j<>i, then AS is irreducible.
   bool deg1=1;
@@ -604 +604 @@
 subset( const CFList &PS, const CFList &CS ){
 
-  //  cout << "subset: called with: " << PS << "   " << CS << endl;
+  //  CERR << "subset: called with: " << PS << "   " << CS << "\n";
   for ( CFListIterator i=PS; i.hasItem(); i++ )
     if ( ! member(i.getItem(), CS) ) {
-      //      cout << "subset: " << i.getItem() << "  is not a member of " << CS << endl;
+      //      CERR << "subset: " << i.getItem() << "  is not a member of " << CS << "\n";
       return 0;
     }
@@ -873 +873 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.11  2006/05/16 13:48:13  Singular
+*hannes: gcc 4.1 fix: factory changes
+
 Revision 1.10  2006/04/28 13:45:29  Singular
 *hannes: better tests for 0, 1

libfac/charset/reorder.cc

@@ -12 +12 @@
 /////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-static char * rcsid = "$Id: reorder.cc,v 1.3 1997-09-12 07:19:44 Singular Exp $";
+static char * rcsid = "$Id: reorder.cc,v 1.4 2006-05-16 14:46:49 Singular Exp $";
 ////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -241 +241 @@
   while ( gap <= n) gap = __INIT_GAP__ * gap+1;
   gap /= __INIT_GAP__;
-  DEBOUTLN(cout, "gap is ", gap);
+  DEBOUTLN(CERR, "gap is ", gap);
   
   while ( gap > 0 ){
@@ -249 +249 @@
         if (degord(v[j],temp, PS, A,B,C,D,E,F,G))  break;
         v[j+gap] = v[j];
-        //cout << "v[" << j+gap << "]= " << v[j+gap] << endl;
+        //CERR << "v[" << j+gap << "]= " << v[j+gap] << "\n";
       }
       v[j+gap] = temp;
-      //cout << "v[" << j+gap << "]= " << v[j+gap] << endl;
+      //CERR << "v[" << j+gap << "]= " << v[j+gap] << "\n";
     }
     gap /= __INIT_GAP__;
@@ -259 +259 @@
   for (i=0; i<= n-1; i++)
     output.append(v[i]);
-  DEBOUTLN(cout, "A= ", A);  DEBOUTLN(cout, "B= ", B);  
-  DEBOUTLN(cout, "C= ", C);  DEBOUTLN(cout, "D= ", D);
-  DEBOUTLN(cout, "E= ", E);  DEBOUTLN(cout, "F= ", F);
-  DEBOUTLN(cout, "G= ", G);
+  DEBOUTLN(CERR, "A= ", A);  DEBOUTLN(CERR, "B= ", B);  
+  DEBOUTLN(CERR, "C= ", C);  DEBOUTLN(CERR, "D= ", D);
+  DEBOUTLN(CERR, "E= ", E);  DEBOUTLN(CERR, "F= ", F);
+  DEBOUTLN(CERR, "G= ", G);
   return output;
 }
@@ -273 +273 @@
   Varlist oldorder, reorder, difference;
 
-  DEBINCLEVEL(cout, "neworder");
-  DEBOUTMSG(cout, rcsid);
+  DEBINCLEVEL(CERR, "neworder");
+  DEBOUTMSG(CERR, rcsid);
   TIMING_START(neworder_time);
 
   int highest_level= level(get_max_var(PS));
-  DEBOUTLN(cout, "neworder: highest_level=   ", highest_level);
-  DEBOUTLN(cout, "neworder: that is variable ", Variable(highest_level));
+  DEBOUTLN(CERR, "neworder: highest_level=   ", highest_level);
+  DEBOUTLN(CERR, "neworder: that is variable ", Variable(highest_level));
 
   // set up oldorder and first criterion: only_in_one
@@ -286 +286 @@
     CFList is_one= only_in_one(PS1, Variable(i)); 
     if ( is_one.length() == 1 ){
-      DEBOUTLN(cout, "Found a variable which is in only one Polynomial: ", 
+      DEBOUTLN(CERR, "Found a variable which is in only one Polynomial: ", 
                Variable(i));
-      DEBOUTLN(cout, ".... in the Polynomial: ", is_one.getFirst());
+      DEBOUTLN(CERR, ".... in the Polynomial: ", is_one.getFirst());
       reorder.insert(Variable(i));
       PS1 = Difference(PS1, is_one);
-      DEBOUTLN(cout, "New cutted list is: ", PS1);
+      DEBOUTLN(CERR, "New cutted list is: ", PS1);
     }
     else if ( is_one.length() == 0 ){
-      DEBOUTLN(cout, "Found a variable which is in no polynomial: ", 
+      DEBOUTLN(CERR, "Found a variable which is in no polynomial: ", 
                Variable(i));
-      DEBOUTMSG(cout, "... assigning it the highest level.");
+      DEBOUTMSG(CERR, "... assigning it the highest level.");
       reorder.append(Variable(i)); // assigne it the highest level
       PS1 = Difference(PS1, is_one); 
@@ -302 +302 @@
   }
   difference = Difference(oldorder,reorder);
-  DEBOUTLN(cout, "Missing variables are: ", difference);
+  DEBOUTLN(CERR, "Missing variables are: ", difference);
   // rearrange the ordering of the variables!
   difference = reorderb(difference, PS, highest_level);
-  DEBOUTLN(cout, "second criterion gives: ", difference);
+  DEBOUTLN(CERR, "second criterion gives: ", difference);
   reorder = Union(reorder, difference);
-  DEBOUTLN(cout, "old order was:     ", oldorder);
-  DEBOUTLN(cout, "New order will be: ", Union(reorder, Difference(oldorder,reorder)));
-  DEBDECLEVEL(cout, "neworder");
+  DEBOUTLN(CERR, "old order was:     ", oldorder);
+  DEBOUTLN(CERR, "New order will be: ", Union(reorder, Difference(oldorder,reorder)));
+  DEBDECLEVEL(CERR, "neworder");
   TIMING_END(neworder_time);
 
@@ -372 +372 @@
     v[i]= level(j.getItem()); i++;
   }
-  DEBOUTLN(cout, "reorder: Original ps=  ", ps);
+  DEBOUTLN(CERR, "reorder: Original ps=  ", ps);
   // reorder:
   for (i=1; i <= n; i++)
     ps=swapvar(ps,Variable(v[i]),Variable(n+i));
-  DEBOUTLN(cout, "reorder: Reorganized ps= ", ps); 
+  DEBOUTLN(CERR, "reorder: Reorganized ps= ", ps); 
   return ps;
 }
@@ -390 +390 @@
     v[i]= level(j.getItem()); i++;
   }
-  DEBOUTLN(cout, "reorder: Original ps=  ", ps);
+  DEBOUTLN(CERR, "reorder: Original ps=  ", ps);
   // reorder:
   for (i=1; i <= n; i++)
     ps=swapvar(ps,Variable(v[i]),Variable(n+i));
-  DEBOUTLN(cout, "reorder: Reorganized ps= ", ps); 
+  DEBOUTLN(CERR, "reorder: Reorganized ps= ", ps); 
   return ps;
 }
@@ -408 +408 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.3  1997/09/12 07:19:44  Singular
+* hannes/michael: libfac-0.3.0
+
 Revision 1.2  1997/04/25 22:53:25  michael
 changed cerr and cout messages for use with Singular

libfac/factor/Factor.cc

@@ -1 +1 @@
 /* Copyright 1996 Michael Messollen. All rights reserved. */
 ///////////////////////////////////////////////////////////////////////////////
-static char * rcsid = "$Id: Factor.cc,v 1.22 2006-04-28 13:46:29 Singular Exp $ ";
+static char * rcsid = "$Id: Factor.cc,v 1.23 2006-05-16 14:46:49 Singular Exp $ ";
 static char * errmsg = "\nYou found a bug!\nPlease inform (Michael Messollen) michael@math.uni-sb.de \nPlease include above information and your input (the ideal/polynomial and characteristic) in your bug-report.\nThank you.";
 ///////////////////////////////////////////////////////////////////////////////
@@ -7 +7 @@
 #include <factory.h>
 #ifndef NOSTREAMIO
+#ifdef HAVE_IOSTREAM
+#include <iostream>
+#define CERR std::cerr
+#define CIN std::cin
+#elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define CERR cerr
+#define CIN cin
+#endif
 #endif
 // Factor - Includes
@@ -106 +114 @@
   remlc= LC(f,n); mainvar = n;
   if ( totaldegree(remlc)==0 ){ remlc=f.genOne() ; }
-  DEBOUTLN(cout, "remlc= " , remlc);
+  DEBOUTLN(CERR, "remlc= " , remlc);
   for ( int i=n-1; i>=1; i-- ){
     newlc= LC(f,i);
     if ( totaldegree(newlc)==0 ){ newlc=f.genOne() ; }
-    DEBOUTLN(cout, "newlc= " , newlc);
+    DEBOUTLN(CERR, "newlc= " , newlc);
     if ( (remlc.isOne()) && (newlc.isOne()) ){ // take care of the degrees
       if ( degree(f,i) < degree(f,mainvar) ){
@@ -227 +235 @@
     else{ // lt is a) a product or b) a sum of terms
       if ( lt_is_product(lt) ){ // case a)
-        DEBOUTLN(cout, "lt_is_product: ", lt);
+        DEBOUTLN(CERR, "lt_is_product: ", lt);
         savelc= content(lt) ; // can we simplify to savelc= lc(lt); ?
         while ( getNumVars(savelc) != 0 )
@@ -255 +263 @@
       }
       else{ // case b)
-        DEBOUTLN(cout, "lt_is_sum: ", lt);
+        DEBOUTLN(CERR, "lt_is_sum: ", lt);
         CanonicalForm save_denumerator= 1;
         for ( i=TheList; i.hasItem(); i++ ){
@@ -272 +280 @@
 #else
 #ifndef NOSTREAMIO
-            cerr << "libfac: ERROR: not_monic1: case lt is a sum.\n"
-                 << rcsid << errmsg << endl;
+            CERR << "libfac: ERROR: not_monic1: case lt is a sum.\n"
+                 << rcsid << errmsg << "\n";
 #endif
 #endif
@@ -291 +299 @@
 #else
 #ifndef NOSTREAMIO
-          cerr << "libfac: ERROR: not_monic2: case lt is a sum.\n"
-               << rcsid << errmsg << endl;
+          CERR << "libfac: ERROR: not_monic2: case lt is a sum.\n"
+               << rcsid << errmsg << "\n";
 #endif
 #endif
@@ -299 +307 @@
     }
   }
-  DEBOUTLN(cout,"Returnlist: ", Returnlist);
+  DEBOUTLN(CERR,"Returnlist: ", Returnlist);
   return Returnlist;
 }
@@ -354 +362 @@
   Variable x(nr_of_variable);
 
-  DEBOUTLN(cout, "specialize_variable: called with: ", f);
+  DEBOUTLN(CERR, "specialize_variable: called with: ", f);
   for ( Extgenerator.reset(); Extgenerator.hasItems(); Extgenerator.next() ){
-    DEBOUTLN(cout, "  specialize_variable: trying:  ", Extgenerator.item());
+    DEBOUTLN(CERR, "  specialize_variable: trying:  ", Extgenerator.item());
     g= f( Extgenerator.item(), x );
-    DEBOUTLN(cout, "  specialize_variable: resulting g= ", g);
+    DEBOUTLN(CERR, "  specialize_variable: resulting g= ", g);
     if ( various_tests(g,deg,former_nr_of_variables - nr_of_variable ) ){
       Substitutionlist.insert(SForm(x,Extgenerator.item())); // append (Var,value) pair
@@ -373 +381 @@
   Variable x(nr_of_variable);
 
-  DEBOUTLN(cout, "specialize_variable: called with: ", f);
+  DEBOUTLN(CERR, "specialize_variable: called with: ", f);
   for ( Extgenerator.reset(); Extgenerator.hasItems(); Extgenerator.next() ){
-    DEBOUTLN(cout, "  specialize_variable: trying:  ", Extgenerator.item());
+    DEBOUTLN(CERR, "  specialize_variable: trying:  ", Extgenerator.item());
     g= f( Extgenerator.item(), x );
-    DEBOUTLN(cout, "  specialize_variable: resulting g= ", g);
+    DEBOUTLN(CERR, "  specialize_variable: resulting g= ", g);
     if ( various_tests(g,deg,former_nr_of_variables - nr_of_variable ) ){
       Substitutionlist.insert(SForm(x,Extgenerator.item())); // append (Var,value) pair
@@ -402 +410 @@
 #else
 #ifndef NOSTREAMIO
-    cerr << "libfac: evaluate: " << Extension << " not inFF() or inGF() !"
-         << endl;
+    CERR << "libfac: evaluate: " << Extension << " not inFF() or inGF() !"
+         << "\n";
 #endif
 #endif
@@ -433 +441 @@
 
   if ( degree(Extension) > 0 ){ // working over Extensions
-    DEBOUTLN(cout, "try_specializePoly: working over Extensions: ", Extension);
+    DEBOUTLN(CERR, "try_specializePoly: working over Extensions: ", Extension);
     AlgExtGenerator g(Extension);
     for ( int k=i ; k<j ; k++ ){ // try to find specialization for all
@@ -444 +452 @@
   else{ // working over the ground-field
     FFGenerator g;
-    DEBOUTMSG(cout, "try_specializePoly: working over the ground-field.");
+    DEBOUTMSG(CERR, "try_specializePoly: working over the ground-field.");
     for ( int k=i ; k<j ; k++ ){
       ok= specialize_variable( ff, deg, Substitutionlist, k, j, g );
@@ -475 +483 @@
 #else
 #ifndef NOSTREAMIO
-      cerr << "libfac: spezializePoly ERROR: Working over given extension-field not yet implemented!\n"
-           << rcsid << errmsg << endl;
+      CERR << "libfac: spezializePoly ERROR: Working over given extension-field not yet implemented!\n"
+           << rcsid << errmsg << "\n";
 #endif
 #endif
@@ -511 +519 @@
 #else
 #ifndef NOSTREAMIO
-    cerr << "libfac: evaluate: " << Extension << " not inFF() or inGF() !"
-         << endl;
+    CERR << "libfac: evaluate: " << Extension << " not inFF() or inGF() !"
+         << "\n";
 #endif
 #endif
@@ -610 +618 @@
     else{
       if (Extension.level()<0)
-      DEBOUTLN(cout, "Univ. Factorization over extension of degree ",
+      DEBOUTLN(CERR, "Univ. Factorization over extension of degree ",
                degree(getMipo(Extension,'x')) );
       else
-      DEBOUTLN(cout, "Univ. Factorization over extension of level ??",
+      DEBOUTLN(CERR, "Univ. Factorization over extension of level ??",
                 Extension.level());
       TIMING_START(evaluate_time);
@@ -643 +651 @@
 
   if ( oldmainvar != mainvar ){
-    DEBOUTSL(cout); DEBOUT(cout,"Swapped poly ", F);
-    DEBOUT(cout, " in ", f); DEBOUTNL(cout);
-    DEBOUTSL(cout); DEBOUT(cout,"Swapped  ", oldmainvar );
-    DEBOUT(cout, " <-- ", mainvar ); DEBOUT(cout, "  Mainvar= ", f.mvar());
-    DEBOUTNL(cout);
+    DEBOUTSL(CERR); DEBOUT(CERR,"Swapped poly ", F);
+    DEBOUT(CERR, " in ", f); DEBOUTNL(CERR);
+    DEBOUTSL(CERR); DEBOUT(CERR,"Swapped  ", oldmainvar );
+    DEBOUT(CERR, " <-- ", mainvar ); DEBOUT(CERR, "  Mainvar= ", f.mvar());
+    DEBOUTNL(CERR);
     ff = f.deriv();
     TIMING_START(discr_time);
@@ -653 +661 @@
     TIMING_END(discr_time);
     if ( !(ffuni.isOne()) ){ //discriminante nonzero: split poly
-      DEBOUTLN(cout,"Nontrivial GCD of f= ", f);
-      DEBOUTLN(cout,"             and @f= ", ff);
-      DEBOUTLN(cout,"          GCD(f,@f)= ", ffuni);
+      DEBOUTLN(CERR,"Nontrivial GCD of f= ", f);
+      DEBOUTLN(CERR,"             and @f= ", ff);
+      DEBOUTLN(CERR,"          GCD(f,@f)= ", ffuni);
       ff=f/ffuni;
       CFFList Outputlist_a, Outputlist_b;
       Outputlist_a = Factorized(ff,alpha);
-      DEBOUTLN(cout, "Outputlist_a = ", Outputlist_a);
+      DEBOUTLN(CERR, "Outputlist_a = ", Outputlist_a);
       Outputlist_b = Factorized(ffuni,alpha);
-      DEBOUTLN(cout, "Outputlist_b = ", Outputlist_b);
+      DEBOUTLN(CERR, "Outputlist_b = ", Outputlist_b);
       Outputlist = myUnion(Outputlist_a, Outputlist_b);
       // have to back-swapvar the factors....
@@ -668 +676 @@
         Outputlist2.append(CFFactor(swapvar(copy.factor(),oldmainvar,mainvar),copy.exp()));
       }
-      DEBOUTLN(cout, "Outputlist2 (a+b swapped) (to return) = ", Outputlist2);
+      DEBOUTLN(CERR, "Outputlist2 (a+b swapped) (to return) = ", Outputlist2);
       return Outputlist2;
     }
@@ -676 +684 @@
   for ( int i=1; i<=level(F); i++)
     if ( degree(f,Variable(i) ) == 1 ) { //test trivial case; only true iff F is primitiv w.r.t every variable; else check (if F=ax+b) gcd(a,b)=1 ?
-      DEBOUTLN(cout, "Trivial case: ", F);
+      DEBOUTLN(CERR, "Trivial case: ", F);
       Outputlist.append(CFFactor(F,1));
       return Outputlist;
@@ -683 +691 @@
   // Look at the leading term:
   lt = LC(f);
-  DEBOUTLN(cout, "Leading term: ", lt);
+  DEBOUTLN(CERR, "Leading term: ", lt);
   if ( lt != f.genOne() ){
     // make the polynomial monic in the main variable
     ff = make_monic(f,lt); ffuni = ff;
-    DEBOUTLN(cout, "make_monic returned: ", ff);
+    DEBOUTLN(CERR, "make_monic returned: ", ff);
   }
   else{ ff= f; ffuni= ff; }
@@ -693 +701 @@
   TIMING_START(evaluate_time);
   success=evaluate(min(10,max(degree(ff), 5)), min(degree(ff),3), min(degree(ff),3), ff, Extension, alpha, Substitutionlist,UnivariateFactorlist);
-  DEBOUTLN(cout,  "Returned from evaluate: success: ", success);
+  DEBOUTLN(CERR,  "Returned from evaluate: success: ", success);
   for ( SFormListIterator ii=Substitutionlist; ii.hasItem(); ii++ ){
-    DEBOUTLN(cout, "Substituting ", ii.getItem().factor());
-    DEBOUTLN(cout, "       with value: ", ii.getItem().exp());
+    DEBOUTLN(CERR, "Substituting ", ii.getItem().factor());
+    DEBOUTLN(CERR, "       with value: ", ii.getItem().exp());
   }
 
   if ( success==0 ){ // evalute wasn't successfull
     success= specializePoly(ffuni,Extension,degree(ff),Substitutionlist,1,getNumVars(compress(ff,m)));
-    DEBOUTLN(cout,  "Returned from specializePoly: success: ", success);
+    DEBOUTLN(CERR,  "Returned from specializePoly: success: ", success);
     if (success == 0 ){ // No spezialisation could be found
 #ifdef HAVE_SINGULAR_ERROR
@@ -707 +715 @@
 #else
 #ifndef NOSTREAMIO
-      cerr << "libfac: Factorize: ERROR: Not able to find a valid specialization!\n"
-           << rcsid << errmsg << endl;
+      CERR << "libfac: Factorize: ERROR: Not able to find a valid specialization!\n"
+           << rcsid << errmsg << "\n";
 #else
        ;
@@ -724 +732 @@
     // We now have an univariat poly; factorize that
     if ( degree(Extension) == 0   ){
-      DEBOUTMSG(cout, "Univ. Factorization over the ground field");
+      DEBOUTMSG(CERR, "Univ. Factorization over the ground field");
       UnivariateFactorlist = factorize(ffuni,1); // univ. poly is sqr-free!
     }
     else{
-      DEBOUTLN(cout, "Univ. Factorization over extension of degree ",
+      DEBOUTLN(CERR, "Univ. Factorization over extension of degree ",
                degree(getMipo(Extension,'x')) );
      #if 1
@@ -745 +753 @@
     TIMING_END(evaluate_time);
   if (UnivariateFactorlist.length() == 1){ // poly is irreduzibel
-    DEBOUTLN(cout, "Univ. poly is irreduzible: ", UnivariateFactorlist);
+    DEBOUTLN(CERR, "Univ. poly is irreduzible: ", UnivariateFactorlist);
     Outputlist.append(CFFactor(F,1));
     return Outputlist;
   }
   else{ // we have factors
-    DEBOUTSL(cout);
-    DEBOUT(cout, "Univariate poly has " , UnivariateFactorlist.length());
-    DEBOUT(cout, " factors:  ", ffuni);
-    DEBOUT(cout, " = ", UnivariateFactorlist); DEBOUTNL(cout);
+    DEBOUTSL(CERR);
+    DEBOUT(CERR, "Univariate poly has " , UnivariateFactorlist.length());
+    DEBOUT(CERR, " factors:  ", ffuni);
+    DEBOUT(CERR, " = ", UnivariateFactorlist); DEBOUTNL(CERR);
 
     // INTERRUPTHANDLER
@@ -761 +769 @@
     TIMING_START(hensel_time);
     Outputlist = MultiHensel(ff,UnivariateFactorlist,Substitutionlist);
-    DEBOUTLN(cout, "Outputlist after MultiHensel: ", Outputlist);
+    DEBOUTLN(CERR, "Outputlist after MultiHensel: ", Outputlist);
     TIMING_END(hensel_time);
 
@@ -770 +778 @@
     TIMING_START(truefactor_time);
     Outputlist = Truefactors(ff, level(ff), Substitutionlist, Outputlist);
-    DEBOUTLN(cout, "Outputlist after Truefactors: ", Outputlist);
+    DEBOUTLN(CERR, "Outputlist after Truefactors: ", Outputlist);
     TIMING_END(truefactor_time);
 
@@ -779 +787 @@
     if ( lt != f.genOne() ){
       Outputlist = not_monic(Outputlist,lt,ff,level(ff));
-      DEBOUTLN(cout, "not_monic returned: ", Outputlist);
+      DEBOUTLN(CERR, "not_monic returned: ", Outputlist);
     }
 
@@ -817 +825 @@
   // INTERRUPTHANDLER
 
-  DEBINCLEVEL(cout, "Factorize");
-  DEBOUTMSG(cout, rcsid);
-  DEBOUTLN(cout, "Called with F= ", F);
+  DEBINCLEVEL(CERR, "Factorize");
+  DEBOUTMSG(CERR, rcsid);
+  DEBOUTLN(CERR, "Called with F= ", F);
   if ( getCharacteristic() == 0 ) { // char == 0
     TIMING_START(factorize_time);
-    //cout << "Factoring in char=0 of " << F << " = " << Outputlist << endl;
+    //CERR << "Factoring in char=0 of " << F << " = " << Outputlist << "\n";
     Outputlist= factorize(F);
     // Factorization in char=0 doesn't sometimes return at least two elements!!!
     if ( getNumVars(Outputlist.getFirst().factor()) != 0 )
       Outputlist.insert(CFFactor(1,1));
-    //cout << "  Factorize in char=0: returning with: " << Outputlist << endl;
+    //CERR << "  Factorize in char=0: returning with: " << Outputlist << "\n";
     TIMING_END(factorize_time);
-    DEBDECLEVEL(cout, "Factorize");
+    DEBDECLEVEL(CERR, "Factorize");
     TIMING_PRINT(factorize_time, "\ntime used for factorization   : ");
     return Outputlist;
@@ -865 +873 @@
   else
     SqrFreeList.append(CFFactor(F,1));
-  DEBOUTLN(cout, "InternalSqrFreeList= ", SqrFreeList);
+  DEBOUTLN(CERR, "InternalSqrFreeList= ", SqrFreeList);
   for ( i=SqrFreeList; i.hasItem(); i++ ){
-    DEBOUTLN(cout, "Factor under consideration: ", i.getItem().factor());
+    DEBOUTLN(CERR, "Factor under consideration: ", i.getItem().factor());
     // We need a compress on each list item ! Maybe we have less variables!
     g =compress(i.getItem().factor(),m);
@@ -882 +890 @@
       else{ // multivariate polynomial
         if ( g.isHomogeneous() ){
-          DEBOUTLN(cout, "Poly is homogeneous! : ", g);
+          DEBOUTLN(CERR, "Poly is homogeneous! : ", g);
           // Now we can substitute one variable to 1, factorize and then
           // look on the resulting factors and their monomials for
@@ -901 +909 @@
   }
   g=1; unit=1;
-  DEBOUTLN(cout, "Outputlist is ", Outputlist);
+  DEBOUTLN(CERR, "Outputlist is ", Outputlist);
   for ( i=Outputlist; i.hasItem(); i++ )
     if ( level(i.getItem().factor()) > 0 ){
@@ -928 +936 @@
   }
 
-  DEBDECLEVEL(cout, "Factorize");
+  DEBDECLEVEL(CERR, "Factorize");
   TIMING_END(factorize_time);
 
@@ -963 +971 @@
   // INTERRUPTHANDLER
 
-  DEBINCLEVEL(cout, "Factorize");
-  DEBOUTMSG(cout, rcsid);
-  DEBOUTLN(cout, "Called with F= ", F);
+  DEBINCLEVEL(CERR, "Factorize");
+  DEBOUTMSG(CERR, rcsid);
+  DEBOUTLN(CERR, "Called with F= ", F);
   if ( getCharacteristic() == 0 )
   { // char == 0
     TIMING_START(factorize_time);
-    //cout << "Factoring in char=0 of " << F << " = " << Outputlist << endl;
+    //CERR << "Factoring in char=0 of " << F << " = " << Outputlist << "\n";
     #if 0
     // SHOULD: Outputlist= factorize(F,minpoly);
@@ -1003 +1011 @@
     if ( getNumVars(Outputlist.getFirst().factor()) != 0 )
       Outputlist.insert(CFFactor(1,1));
-    //cout << "  Factorize in char=0: returning with: " << Outputlist << endl;
+    //CERR << "  Factorize in char=0: returning with: " << Outputlist << "\n";
     TIMING_END(factorize_time);
-    DEBDECLEVEL(cout, "Factorize");
+    DEBDECLEVEL(CERR, "Factorize");
     TIMING_PRINT(factorize_time, "\ntime used for factorization   : ");
     return Outputlist;
@@ -1041 +1049 @@
   else
     SqrFreeList.append(CFFactor(F,1));
-  DEBOUTLN(cout, "InternalSqrFreeList= ", SqrFreeList);
+  DEBOUTLN(CERR, "InternalSqrFreeList= ", SqrFreeList);
   for ( i=SqrFreeList; i.hasItem(); i++ ){
-    DEBOUTLN(cout, "Factor under consideration: ", i.getItem().factor());
+    DEBOUTLN(CERR, "Factor under consideration: ", i.getItem().factor());
     // We need a compress on each list item ! Maybe we have less variables!
     g =compress(i.getItem().factor(),m);
@@ -1061 +1069 @@
       else{ // multivariate polynomial
         if ( g.isHomogeneous() ){
-          DEBOUTLN(cout, "Poly is homogeneous! : ", g);
+          DEBOUTLN(CERR, "Poly is homogeneous! : ", g);
           // Now we can substitute one variable to 1, factorize and then
           // look on the resulting factors and their monomials for
@@ -1080 +1088 @@
   }
   g=1; unit=1;
-  DEBOUTLN(cout, "Outputlist is ", Outputlist);
+  DEBOUTLN(CERR, "Outputlist is ", Outputlist);
   for ( i=Outputlist; i.hasItem(); i++ )
     if ( level(i.getItem().factor()) > 0 ){
@@ -1107 +1115 @@
   }
 
-  DEBDECLEVEL(cout, "Factorize");
+  DEBDECLEVEL(CERR, "Factorize");
   TIMING_END(factorize_time);
 
@@ -1124 +1132 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.22  2006/04/28 13:46:29  Singular
+*hannes: better tests for 0, 1
+
 Revision 1.21  2005/12/12 18:02:03  Singular
 *hannes: use sorting option in Factorize

libfac/factor/MVMultiHensel.cc

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// static char * rcsid = "$Id: MVMultiHensel.cc,v 1.8 2002-07-30 15:11:19 Singular Exp $";
+// static char * rcsid = "$Id: MVMultiHensel.cc,v 1.9 2006-05-16 14:46:49 Singular Exp $";
 ///////////////////////////////////////////////////////////////////////////////
 // FACTORY - Includes
 #include <factory.h>
 #ifndef NOSTREAMIO
+#ifdef HAVE_IOSTREAM
+#include <iostream>
+#define OSTREAM std::ostream
+#define ISTREAM std::istream
+#define CERR std::cerr
+#define CIN std::cin
+#elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
+#define ISTREAM istream
+#define CERR cerr
+#define CIN cin
+#endif
 #endif
 // Factor - Includes
@@ -104 +116 @@
   Variable x(levelU);
 
-  DEBOUT(cout, "diophant: called with: ", F1);
-  DEBOUT(cout, "  ", F2); DEBOUTLN(cout, "  ", i);
+  DEBOUT(CERR, "diophant: called with: ", F1);
+  DEBOUT(CERR, "  ", F2); DEBOUTLN(CERR, "  ", i);
 
   // Did we solve the diophantine equation yet?
@@ -121 +133 @@
 #else
 #ifndef NOSTREAMIO
-    cerr << "libfac: diophant ERROR: degree too large!  "
-         << (degree(F1,levelU) + degree(F2,levelU) ) <<endl;
+    CERR << "libfac: diophant ERROR: degree too large!  "
+         << (degree(F1,levelU) + degree(F2,levelU) ) <<"\n";
 #else
     ;
@@ -139 +151 @@
 #else
 #ifndef NOSTREAMIO
-      cerr << "libfac: diophant ERROR: " << F1 << "  and  " << F2
-           << "  are not relatively prime!" << endl;
+      CERR << "libfac: diophant ERROR: " << F1 << "  and  " << F2
+           << "  are not relatively prime!" << "\n";
 #else
      ;
@@ -176 +188 @@
     A[i].calculated = true ; B[i].calculated = true ;
   }
-  DEBOUT(cout, "diophant: Returnvalue is: ", Retvalue.One);
-  DEBOUTLN(cout, "  ", Retvalue.Two);
+  DEBOUT(CERR, "diophant: Returnvalue is: ", Retvalue.One);
+  DEBOUTLN(CERR, "  ", Retvalue.Two);
 
   return  Retvalue;
@@ -193 +205 @@
   DiophantForm intermediate;
 
-  DEBOUT(cout, "make_delta: W= ", W);
-  DEBOUTLN(cout, "  degree(W,levelU)= ", degree(W,levelU) );
+  DEBOUT(CERR, "make_delta: W= ", W);
+  DEBOUTLN(CERR, "  degree(W,levelU)= ", degree(W,levelU) );
 
   if ( levelU == level(W) ){ // same level, good
@@ -206 +218 @@
     Retvalue = W * intermediate.One;
   }
-  DEBOUTLN(cout, "make_delta: Returnvalue= ", Retvalue);
+  DEBOUTLN(CERR, "make_delta: Returnvalue= ", Retvalue);
   return Retvalue;
 }
@@ -217 +229 @@
   DiophantForm intermediate;
 
-  DEBOUT(cout, "make_square: W= ", W );
-  DEBOUTLN(cout, "  degree(W,levelU)= ", degree(W,levelU));
+  DEBOUT(CERR, "make_square: W= ", W );
+  DEBOUTLN(CERR, "  degree(W,levelU)= ", degree(W,levelU));
 
   if ( levelU == level(W) ){ // same level, good
@@ -230 +242 @@
     Retvalue = W * intermediate.Two;
   }
-  DEBOUTLN(cout, "make_square: Returnvalue= ", Retvalue);
+  DEBOUTLN(CERR, "make_square: Returnvalue= ", Retvalue);
 
   return Retvalue;
@@ -252 +264 @@
   RememberArray B(degree(F,levelU)+degree(G,levelU)+1);
 
-  DEBOUTLN(cout, "mvhensel called with: U= ", U);
-  DEBOUTLN(cout, "                      F= ", F);
-  DEBOUTLN(cout, "                      G= ", G);
-  DEBOUTLN(cout, "                   degU= ", degU);
+  DEBOUTLN(CERR, "mvhensel called with: U= ", U);
+  DEBOUTLN(CERR, "                      F= ", F);
+  DEBOUTLN(CERR, "                      G= ", G);
+  DEBOUTLN(CERR, "                   degU= ", degU);
 
   V=change_poly(U,Substitutionlist,0); // change x_i <- x_i + a_i for all i
   Rk = F*G-V;
 #ifdef HENSELDEBUG2
-  cout << "mvhensel: V = " << V << endl
-       << "          Fk= " << F << endl
-       << "          Gk= " << G << endl
-       << "          Rk= " << Rk << endl;
+  CERR << "mvhensel: V = " << V << "\n"
+       << "          Fk= " << F << "\n"
+       << "          Gk= " << G << "\n"
+       << "          Rk= " << Rk << "\n";
 #endif
   for ( int k=2; k<=degU+1; k++){//2; k++){//degU+1; k++){
     W = mod_power(Rk,k,levelU);
 #ifdef HENSELDEBUG2
-    cout << "mvhensel: Iteration: " << k << endl;
-    cout << "mvhensel: W= " << W << endl;
+    CERR << "mvhensel: Iteration: " << k << "\n";
+    CERR << "mvhensel: W= " << W << "\n";
 #endif
     D = make_delta(levelU,W,F,G,A,B);
 #ifdef HENSELDEBUG2
-    cout << "mvhensel: D= " << D << endl;
+    CERR << "mvhensel: D= " << D << "\n";
 #endif
     S = make_square(levelU,W,F,G,A,B);
 #ifdef HENSELDEBUG2
-    cout << "mvhensel: S= " << S << endl;
+    CERR << "mvhensel: S= " << S << "\n";
 #endif
     Rk += S*D - D*Fk - S*Gk;
 #ifdef HENSELDEBUG2
-    cout << "mvhensel: Rk= " << Rk << endl;
+    CERR << "mvhensel: Rk= " << Rk << "\n";
 #endif
     Fk -= S;
 #ifdef HENSELDEBUG2
-    cout << "mvhensel: Fk= " << Fk << endl;
+    CERR << "mvhensel: Fk= " << Fk << "\n";
 #endif
     Gk -= D;
 #ifdef HENSELDEBUG2
-    cout << "mvhensel: Gk= " << Gk << endl;
+    CERR << "mvhensel: Gk= " << Gk << "\n";
 #endif
     if ( Rk.isZero() ) break;
@@ -296 +308 @@
   Retvalue.Two = change_poly(Gk,Substitutionlist,1);
 
-  DEBOUTLN(cout, "mvhensel: Retvalue: ", Retvalue.One);
-  DEBOUTLN(cout, "                    ", Retvalue.Two);
+  DEBOUTLN(CERR, "mvhensel: Retvalue: ", Retvalue.One);
+  DEBOUTLN(CERR, "                    ", Retvalue.Two);
 
   return Retvalue ;
@@ -313 +325 @@
   int n = factorlist.length();
 
-  DEBOUT(cout, "multihensel: called with ", mF);
-  DEBOUTLN(cout, "  ", factorlist);
+  DEBOUT(CERR, "multihensel: called with ", mF);
+  DEBOUTLN(CERR, "  ", factorlist);
 
   if ( n == 1 ) {
@@ -329 +341 @@
     else { // more then two factors
 #ifdef HENSELDEBUG2
-      cout << "multihensel: more than two factors!" << endl;
+      CERR << "multihensel: more than two factors!" << "\n";
 #endif
       Pl=factorlist.getFirst().factor(); factorlist.removeFirst();
@@ -336 +348 @@
         Pr *=  i.getItem().factor() ;
 #ifdef HENSELDEBUG2
-      cout << "multihensel: Pl,Pr, factorlist: " << Pl << "  " << Pr
-           << "  " << factorlist << endl;
+      CERR << "multihensel: Pl,Pr, factorlist: " << Pl << "  " << Pr
+           << "  " << factorlist << "\n";
 #endif
       intermediat= mvhensel(mF,Pl,Pr,Substitutionlist);
@@ -364 +376 @@
   int n = factorlist.length(),h=n/2, k;
 
-  DEBOUT(cout, "MultiHensel: called with ", mF);
-  DEBOUTLN(cout, "  ", factorlist);
-  DEBOUT(cout,"           : n,h = ", n);
-  DEBOUTLN(cout,"  ", h);
+  DEBOUT(CERR, "MultiHensel: called with ", mF);
+  DEBOUTLN(CERR, "  ", factorlist);
+  DEBOUT(CERR,"           : n,h = ", n);
+  DEBOUTLN(CERR,"  ", h);
 
   if ( n == 1 ) {
@@ -386 +398 @@
       }
 
-      DEBOUTLN(cout, "MultiHensel: Ll= ", Ll);
-      DEBOUTLN(cout, "     factorlist= ", factorlist);
+      DEBOUTLN(CERR, "MultiHensel: Ll= ", Ll);
+      DEBOUTLN(CERR, "     factorlist= ", factorlist);
 
       Pl = 1; Pr = 1;
       for ( i = Ll; i.hasItem(); i++)
         Pl *= i.getItem().factor();
-      DEBOUTLN(cout, "MultiHensel: Pl= ", Pl);
+      DEBOUTLN(CERR, "MultiHensel: Pl= ", Pl);
       for ( i = factorlist; i.hasItem(); i++)
         Pr *= i.getItem().factor();
-      DEBOUTLN(cout, "MultiHensel: Pr= ", Pr);
+      DEBOUTLN(CERR, "MultiHensel: Pr= ", Pr);
       intermediat = mvhensel(mF,Pl,Pr,Substitutionlist);
       // divison test for intermediat.One and intermediat.Two ?
@@ -418 +430 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.8  2002/07/30 15:11:19  Singular
+*hannes: minor cleanups
+
 Revision 1.7  2001/08/22 14:21:17  Singular
 *hannes: added search for main var to Factorize

libfac/factor/SqrFree.cc

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-static char * rcsid = "$Id: SqrFree.cc,v 1.9 2006-04-28 13:46:29 Singular Exp $";
+static char * rcsid = "$Id: SqrFree.cc,v 1.10 2006-05-16 14:46:50 Singular Exp $";
 static char * errmsg = "\nYou found a bug!\nPlease inform (Michael Messollen) michael@math.uni-sb.de .\n Please include above information and your input (the ideal/polynomial and characteristic) in your bug-report.\nThank you.";
 ///////////////////////////////////////////////////////////////////////////////
@@ -8 +8 @@
 #include<factory.h>
 #ifndef NOSTREAMIO
+#ifdef HAVE_IOSTREAM
+#include <iostream>
+#define OSTREAM std::ostream
+#define ISTREAM std::istream
+#define CERR std::cerr
+#define CIN std::cin
+#elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
+#define ISTREAM istream
+#define CERR cerr
+#define CIN cin
+#endif
 #endif
 // Factor - Includes
@@ -178 +190 @@
 #else
 #ifndef NOSTREAMIO
-  cerr << "\nlibfac: ERROR: SqrFreeTest: we should never fall trough here!\n"
-       << rcsid << errmsg << endl;
+  CERR << "\nlibfac: ERROR: SqrFreeTest: we should never fall trough here!\n"
+       << rcsid << errmsg << "\n";
 #endif
 #endif
@@ -198 +210 @@
   int n = level(f);
 
-  DEBINCLEVEL(cout, "SqrFreed");
-  DEBOUTLN(cout, "Called with r= ", r);
+  DEBINCLEVEL(CERR, "SqrFreed");
+  DEBOUTLN(CERR, "Called with r= ", r);
   if (getNumVars(f)==0 ) { // just a constant; return it
     Outputlist= myappend(Outputlist,CFFactor(f,1));
@@ -213 +225 @@
       if ( ! (g.isOne() || (-g).isOne() || degree(g)==0 )) {
         g = swapvar(g,k,n);
-        DEBOUTLN(cout, "We have a content: ", g);
+        DEBOUTLN(CERR, "We have a content: ", g);
         Outputlist = myUnion(InternalSqrFree(g,mipo),Outputlist); // should we add a
                                                 // SqrFreeTest(g) first ?
-        DEBOUTLN(cout, "Outputlist is now: ", Outputlist);
+        DEBOUTLN(CERR, "Outputlist is now: ", Outputlist);
         f /=g;
-        DEBOUTLN(cout, "f is now: ", f);
+        DEBOUTLN(CERR, "f is now: ", f);
       }
     }  
@@ -225 +237 @@
 // Now f is primitive; Let`s look if f is univariate
   if ( f.isUnivariate() ) {
-    DEBOUTLN(cout, "f is univariate: ", f);
+    DEBOUTLN(CERR, "f is univariate: ", f);
     g = content(g);
     if ( ! (g.isOne() || (-g).isOne() ) ){
@@ -232 +244 @@
     }
     Outputlist = Union(sqrFree(f),Outputlist) ;
-    DEBOUTLN(cout, "Outputlist after univ. sqrFree(f) = ", Outputlist);
-    DEBDECLEVEL(cout, "SqrFreed");
+    DEBOUTLN(CERR, "Outputlist after univ. sqrFree(f) = ", Outputlist);
+    DEBDECLEVEL(CERR, "SqrFreed");
     return Outputlist ;
   }
@@ -240 +252 @@
   if ( totaldegree(f) <= 1 ) {
     Outputlist= myappend(Outputlist,CFFactor(f,1)) ;
-    DEBDECLEVEL(cout, "SqrFreed");
+    DEBDECLEVEL(CERR, "SqrFreed");
     return Outputlist ;
   }
@@ -266 +278 @@
       if ( k==n )
       { // really is Pth power
-        DEBOUTLN(cout, "f is a p'th root: ", f);
+        DEBOUTLN(CERR, "f is a p'th root: ", f);
         CFMap m;
         g = compress(f,m);
@@ -273 +285 @@
         else
           f = m(PthRoot(g,mipo));
-        DEBOUTLN(cout, "  that is       : ", f);
+        DEBOUTLN(CERR, "  that is       : ", f);
         // now : Outputlist union ( SqrFreed(f) )^getCharacteristic()
         Outputlist=myUnion(Powerup(InternalSqrFree(f),getCharacteristic()),Outputlist);
-        DEBDECLEVEL(cout, "SqrFreed");
+        DEBDECLEVEL(CERR, "SqrFreed");
         return Outputlist ;
       }
@@ -282 +294 @@
   }
   g = f.deriv();
-  DEBOUTLN(cout, "calculating mygcd of ", f);
-  DEBOUTLN(cout, "               and ", g);
+  DEBOUTLN(CERR, "calculating mygcd of ", f);
+  DEBOUTLN(CERR, "               and ", g);
   h = mygcd(f,pp(g));  h /= lc(h);
-  DEBOUTLN(cout,"mygcd(f,g)= ",h);
+  DEBOUTLN(CERR,"mygcd(f,g)= ",h);
   if ( (h.isOne()) || ( h==f) || ((-h).isOne()) || getNumVars(h)==0 ) { // no common factor
     Outputlist= myappend(Outputlist,CFFactor(f,1)) ;
-    DEBOUTLN(cout, "Outputlist= ", Outputlist);
-    DEBDECLEVEL(cout, "SqrFreed");
+    DEBOUTLN(CERR, "Outputlist= ", Outputlist);
+    DEBDECLEVEL(CERR, "SqrFreed");
     return Outputlist ;
   }
@@ -299 +311 @@
        f /= g;
     }
-    DEBOUTLN(cout, "Split into f= ", f);
-    DEBOUTLN(cout, "       and h= ", h);
+    DEBOUTLN(CERR, "Split into f= ", f);
+    DEBOUTLN(CERR, "       and h= ", h);
     // For char > 0 the polys f and h can have Pth roots; so we need a test
     // Test is disabled because timing is the same
@@ -312 +324 @@
 //    else
     Outputlist=myUnion(Outputlist,InternalSqrFree(h));
-    DEBOUTLN(cout, "Returning list ", Outputlist);
-    DEBDECLEVEL(cout, "SqrFreed");
+    DEBOUTLN(CERR, "Returning list ", Outputlist);
+    DEBDECLEVEL(CERR, "SqrFreed");
     return Outputlist ;
   }
@@ -320 +332 @@
 #else
 #ifndef NOSTREAMIO
-  cerr << "\nlibfac: ERROR: SqrFreed: we should never fall trough here!\n"
-       << rcsid << errmsg << endl;
-#endif
-#endif
-  DEBDECLEVEL(cout, "SqrFreed");
+  CERR << "\nlibfac: ERROR: SqrFreed: we should never fall trough here!\n"
+       << rcsid << errmsg << "\n";
+#endif
+#endif
+  DEBDECLEVEL(CERR, "SqrFreed");
   return Outputlist; // for safety purpose
 }
@@ -337 +349 @@
   CFFList Outputlist, Outputlist2;
 
-  DEBINCLEVEL(cout, "InternalSqrFree");
-  DEBOUTMSG(cout, rcsid);
-  DEBOUTLN(cout,"Called with f= ", f);
+  DEBINCLEVEL(CERR, "InternalSqrFree");
+  DEBOUTMSG(CERR, rcsid);
+  DEBOUTLN(CERR,"Called with f= ", f);
 
   // Take care of stupid users giving us constants
@@ -359 +371 @@
       }
   }
-  DEBOUTLN(cout,"Outputlist = ", Outputlist);
+  DEBOUTLN(CERR,"Outputlist = ", Outputlist);
   for ( CFFListIterator i=Outputlist; i.hasItem(); i++ )
     if ( getNumVars(i.getItem().factor()) > 0 )
       Outputlist2.append(i.getItem());
 
-  DEBOUTLN(cout,"Outputlist2 = ", Outputlist2);
-  DEBDECLEVEL(cout, "InternalSqrFree");
+  DEBOUTLN(CERR,"Outputlist2 = ", Outputlist2);
+  DEBDECLEVEL(CERR, "InternalSqrFree");
   return Outputlist2 ;
 }
@@ -376 +388 @@
   int n=totaldegree(r);
 
-  DEBINCLEVEL(cout, "SqrFree");
+  DEBINCLEVEL(CERR, "SqrFree");
 
   if ( sqrfreelist.length() < 2 ){
-    DEBDECLEVEL(cout, "SqrFree");
+    DEBDECLEVEL(CERR, "SqrFree");
     return sqrfreelist;
   }
@@ -396 +408 @@
   outputlist.insert(CFFactor(elem,1));
 
-  DEBOUTLN(cout, "SqrFree returns list:", outputlist);
-  DEBDECLEVEL(cout, "SqrFree");
+  DEBOUTLN(CERR, "SqrFree returns list:", outputlist);
+  DEBDECLEVEL(CERR, "SqrFree");
   return outputlist;
 }
@@ -403 +415 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.9  2006/04/28 13:46:29  Singular
+*hannes: better tests for 0, 1
+
 Revision 1.8  2002/08/19 11:11:33  Singular
 * hannes/pfister: alg_gcd etc.

libfac/factor/Truefactor.cc

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-//static char * rcsid = "@(#) $Id: Truefactor.cc,v 1.9 2001-08-08 14:26:56 Singular Exp $";
+//static char * rcsid = "@(#) $Id: Truefactor.cc,v 1.10 2006-05-16 14:46:50 Singular Exp $";
 ///////////////////////////////////////////////////////////////////////////////
 // Factory - Includes
 #include <factory.h>
 #ifndef NOSTREAMIO
+#ifdef HAVE_IOSTREAM
+#include <iostream>
+#define OSTREAM std::ostream
+#define ISTREAM std::istream
+#define CERR std::cerr
+#define CIN std::cin
+#elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
+#define ISTREAM istream
+#define CERR cerr
+#define CIN cin
+#endif
 #endif
 // Factor - Includes
@@ -78 +90 @@
     if (f.level()!=0)
     {
-      //cout << "hasAlgVar:" << f.mvar() <<endl;
+      //CERR << "hasAlgVar:" << f.mvar() <<"\n";
       return 1;
     }
@@ -162 +174 @@
   CFFList Returnlist;
 
-  DEBOUTLN(cout, "Remove_from_List called with L= ",L);
-  DEBOUTLN(cout, "                     and  elem= ",elem);
+  DEBOUTLN(CERR, "Remove_from_List called with L= ",L);
+  DEBOUTLN(CERR, "                     and  elem= ",elem);
   for ( ListIterator<CFFactor> i = L ; i.hasItem(); i++)
     if ( i.getItem().factor() != elem )
@@ -220 +232 @@
   ListIterator<CFFactor> i;
 
-  //cout << "SubstitutionList="<< SubstitutionList<<endl;
+  //CERR << "SubstitutionList="<< SubstitutionList<<"\n";
 // step 1: simply test the generated factors alone
   for ( i= PiList; i.hasItem();i++){
@@ -226 +238 @@
     //CanonicalForm test_f=change_poly(factor.factor(),SubstitutionList,0);
     CanonicalForm test_f=factor.factor();
-    //cout <<"f:" << factor.factor() << " -> test_f:"<<test_f <<endl;
-    //cout << "           1:" << change_poly(factor.factor(),SubstitutionList,1) <<endl;
+    //CERR <<"f:" << factor.factor() << " -> test_f:"<<test_f <<"\n";
+    //CERR << "           1:" << change_poly(factor.factor(),SubstitutionList,1) <<"\n";
     c= mydivremt(U,test_f,a,b);
     if (  c  && b == U.genZero() && !hasAlgVar(test_f))
     // factor.getFactor() divides U
     {
-      //cout << " teilt:" << test_f <<endl;
+      //CERR << " teilt:" << test_f <<"\n";
       U= a;
       FAC.append(factor);
     }
     else{
-      //cout << " teilt nicht:" << test_f <<endl;
+      //CERR << " teilt nicht:" << test_f <<"\n";
       L.append(factor);
     }
   }
-  DEBOUTLN(cout,"Truefactors: (step1) L  = ", L);
-  DEBOUTLN(cout,"                     FAC= ", FAC);
+  DEBOUTLN(CERR,"Truefactors: (step1) L  = ", L);
+  DEBOUTLN(CERR,"                     FAC= ", FAC);
 
 // step 2: Do we have to check combinations?
@@ -257 +269 @@
     }
 
-  DEBOUTLN(cout,"Truefactors: (step2) M   = ", M);
-  DEBOUTLN(cout,"                     r   = ", r);
-  DEBOUTLN(cout,"                     degU= ", degU);
+  DEBOUTLN(CERR,"Truefactors: (step2) M   = ", M);
+  DEBOUTLN(CERR,"                     r   = ", r);
+  DEBOUTLN(CERR,"                     degU= ", degU);
 
 // Now do the real work!
@@ -277 +289 @@
     // step 5
     E_all = combine(M, L); // generate all combinations of M elements from L
-    DEBOUTLN(cout,"Truefactors: (step5) E_all= ", E_all);
+    DEBOUTLN(CERR,"Truefactors: (step5) E_all= ", E_all);
     // select combinations with the degree not to exceed degU:
     E_all = Rightdegree( E_all, degU, levelU );
-    DEBOUTLN(cout,"Truefactors: (step5) E_all(Rightdegree)= ", E_all);
+    DEBOUTLN(CERR,"Truefactors: (step5) E_all(Rightdegree)= ", E_all);
     if ( E_all.length() == 0 ){
       FAC.append( CFFactor(U,1) );
@@ -288 +300 @@
       factor = i.getItem();
       Y = Multmod_power( factor.factor(), SubstitutionList, h, levelU);
-      DEBOUTLN(cout, "Truefactors: (step6) Testing Y  = ", Y);
+      DEBOUTLN(CERR, "Truefactors: (step6) Testing Y  = ", Y);
       c = mydivremt(U,Y,a,b);
       //      if (  c  && b == U.genZero()) { // Y divides U
       if ( c && b.isZero() ){
-        DEBOUT(cout,"Truefactors: (step6): ",Y );
-        DEBOUTLN(cout, "  divides  ",U);
+        DEBOUT(CERR,"Truefactors: (step6): ",Y );
+        DEBOUTLN(CERR, "  divides  ",U);
         U = a;
         FAC.append(Y); // Y is a real factor
@@ -363 +375 @@
 #else
 #ifndef NOSTREAMIO
-      cerr << "libfac: ERROR: TakeNorms less then two items remaining! "
-           << endl;
+      CERR << "libfac: ERROR: TakeNorms less then two items remaining! "
+           << "\n";
 #else
       ;
@@ -388 +400 @@
         }
         else {
-          //cout << "Schade!" << endl;
+          //CERR << "Schade!" << "\n";
         }
-        DEBOUT(cout, "Truefactor: Combined ", n);
-        DEBOUTLN(cout, " factors to: ", intermediate);
+        DEBOUT(CERR, "Truefactor: Combined ", n);
+        DEBOUTLN(CERR, " factors to: ", intermediate);
       }
       n += 1;
@@ -409 +421 @@
 #else
 #ifndef NOSTREAMIO
-        cerr << "libfac: TakeNorms: somethings wrong with remaining factors!"
-             << endl;
+        CERR << "libfac: TakeNorms: somethings wrong with remaining factors!"
+             << "\n";
 #endif
 #endif
@@ -422 +434 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.9  2001/08/08 14:26:56  Singular
+*hannes: Dan's HAVE_SINGULAR_ERROR
+
 Revision 1.8  2001/08/08 11:59:13  Singular
 *hannes: Dan's NOSTREAMIO changes

libfac/factor/class.h

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: class.h,v 1.5 2000-05-29 08:06:47 pohl Exp $
+// $Id: class.h,v 1.6 2006-05-16 14:46:50 Singular Exp $
 ///////////////////////////////////////////////////////////////////////////////
 #ifndef INCL_CLASS_H
@@ -10 +10 @@
 
 #ifndef NOSTREAMIO
+#ifdef HAVE_IOSTREAM
+#include <iostream>
+#define OSTREAM std::ostream
+#define ISTREAM std::istream
+#elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
+#define ISTREAM istream
+#endif
 #endif
 
@@ -33 +41 @@
 //     Substitution<T>& operator*= ( const T & f ) { _factor *= f; _exp *= f; return *this; }
 #ifndef NOSTREAMIO
-    void print ( ostream& ) const;
-    friend ostream& operator<< ( ostream & os, const Substitution<T> & f )
+    void print ( OSTREAM& ) const;
+    friend OSTREAM& operator<< ( OSTREAM & os, const Substitution<T> & f )
     {
         f.print( os );
@@ -53 +61 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.5  2000/05/29 08:06:47  pohl
+no artificial friend
+
 Revision 1.4  1997/09/12 07:19:54  Singular
 * hannes/michael: libfac-0.3.0

libfac/factor/debug.h

@@ -1 +1 @@
 /* Copyright 1996 Michael Messollen. All rights reserved. */
 ////////////////////////////////////////////////////////////
-// static char * rcsid = "$Id: debug.h,v 1.3 1997-09-12 07:19:55 Singular Exp $" ;
+// static char * rcsid = "$Id: debug.h,v 1.4 2006-05-16 14:46:50 Singular Exp $" ;
 ////////////////////////////////////////////////////////////
 // It is possible to include this file multiple times for different 
@@ -39 +39 @@
 extern char * deb_level_msg;
 #define DEBINCLEVEL(stream,msg) \
-(stream << "\n" << deb_level_msg << "entering << " << msg << " >>" << endl, deb_inc_level())
+(stream << "\n" << deb_level_msg << "entering << " << msg << " >>" << "\n", deb_inc_level())
 #define DEBDECLEVEL(stream,msg) \
-(deb_dec_level(), stream << deb_level_msg << "leaving << " << msg << " >>" << endl)
+(deb_dec_level(), stream << deb_level_msg << "leaving << " << msg << " >>" << "\n")
 #define DEBOUTSL(stream) \
 (stream << deb_level_msg, stream.flush())
@@ -47 +47 @@
 (stream << deb_level_msg << msg << object, stream.flush())
 #define DEBOUTLN(stream,msg,object) \
-(stream << deb_level_msg << msg << object << endl)
+(stream << deb_level_msg << msg << object << "\n")
 #define DEBOUTMSG(stream,msg) \
-(stream << deb_level_msg << msg << endl)
+(stream << deb_level_msg << msg << "\n")
 #define DEBOUTNL(stream) \
-(stream << endl)
+(stream << "\n")
 #else
 #define DEBINCLEVEL(stream,msg)
@@ -64 +64 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.3  1997/09/12 07:19:55  Singular
+* hannes/michael: libfac-0.3.0
+
 Revision 1.2  1997/04/25 22:15:33  michael
 Version for libfac-0.2.1

libfac/factor/homogfactor.cc

@@ -1 +1 @@
 /* Copyright 1997 Michael Messollen. All rights reserved. */
 ////////////////////////////////////////////////////////////
-// static char * rcsid = "$Id: homogfactor.cc,v 1.6 2005-12-09 08:36:11 Singular Exp $ ";
+// static char * rcsid = "$Id: homogfactor.cc,v 1.7 2006-05-16 14:46:50 Singular Exp $ ";
 ////////////////////////////////////////////////////////////
 // FACTORY - Includes
 #include <factory.h>
+#ifdef HAVE_IOSTREAM
+#include <iostream>
+#define OSTREAM std::ostream
+#define ISTREAM std::istream
+#define CERR std::cerr
+#define CIN std::cin
+#elif defined(HAVE_IOSTREAM_H)
+#include <iostream.h>
+#define OSTREAM ostream
+#define ISTREAM istream
+#define CERR cerr
+#define CIN cin
+#endif
+
 // Factor - Includes
 #include "tmpl_inst.h"
@@ -121 +135 @@
 CFFList
 HomogFactor( const CanonicalForm & g, const CanonicalForm  & minpoly, const int Mainvar ){
-  DEBINCLEVEL(cout, "HomogFactor");
+  DEBINCLEVEL(CERR, "HomogFactor");
   Variable xn = get_max_degree_Variable(g);
   int d_xn = degree(g,xn);
@@ -127 +141 @@
   CanonicalForm F = compress(g(1,xn),n); // must compress F! 
 
-  DEBOUTLN(cout, "xn= ", xn);
-  DEBOUTLN(cout, "d_xn=   ", d_xn);
-  DEBOUTLN(cout, "F= ", F);  
+  DEBOUTLN(CERR, "xn= ", xn);
+  DEBOUTLN(CERR, "d_xn=   ", d_xn);
+  DEBOUTLN(CERR, "F= ", F);  
 
   // should we do this for low degree polys g ? e.g. quadratic?
@@ -143 +157 @@
     Homoglist.append(CFFactor( n(j.getItem().factor()), j.getItem().exp()) );
   // Now we have uncompressed factors in Homoglist
-  DEBOUTLN(cout, "F factors as: ", Homoglist);
+  DEBOUTLN(CERR, "F factors as: ", Homoglist);
   CFFList Unhomoglist;
   CanonicalForm unhomogelem;
   for ( j=Homoglist; j.hasItem(); j++ ){
-    DEBOUTLN(cout, "Homogenizing ",j.getItem().factor()); 
+    DEBOUTLN(CERR, "Homogenizing ",j.getItem().factor()); 
     unhomogelem= homogenize(j.getItem().factor(),xn);
-    DEBOUTLN(cout, "      that is ", unhomogelem);
+    DEBOUTLN(CERR, "      that is ", unhomogelem);
     Unhomoglist.append(CFFactor(unhomogelem,j.getItem().exp()));
     d_xn -= degree(unhomogelem,xn)*j.getItem().exp();
   }
-  DEBOUTLN(cout, "Power of xn to append is ", d_xn);
+  DEBOUTLN(CERR, "Power of xn to append is ", d_xn);
   if ( d_xn != 0 ) // have to append xn^(d_xn)
     Unhomoglist.append(CFFactor(CanonicalForm(xn),d_xn));
 
-  DEBDECLEVEL(cout, "HomogFactor");
+  DEBDECLEVEL(CERR, "HomogFactor");
   return Unhomoglist;
 }
@@ -163 +177 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.6  2005/12/09 08:36:11  Singular
+*hannes: stuff for homog. polys ->factory
+
 Revision 1.5  2005/12/05 15:47:32  Singular
 *hannes: is_homogeneous -> factory: isHomogeneous

libfac/factor/timing.h

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// static char * rcsid = "$Id: timing.h,v 1.3 1997-09-12 07:19:59 Singular Exp $";
+// static char * rcsid = "$Id: timing.h,v 1.4 2006-05-16 14:46:50 Singular Exp $";
 ////////////////////////////////////////////////////////////
 // It is possible to include this file multiple times for different 
@@ -16 +16 @@
 #include <time.h>
 #include <sys/times.h>
+#ifdef HAVE_IOSTREAM
+#include <iostream>
+#define OSTREAM std::ostream
+#define ISTREAM std::istream
+#elif defined(HAVE_IOSTREAM_H)
 #include <iostream.h>
+#define OSTREAM ostream
+#define ISTREAM istream
+#endif
 #define TIMING_START(t) { struct tms timing_ ## t ## _start, timing_ ## t ## _end; \
   times( &timing_ ## t ## _start );
@@ -22 +30 @@
   timing_ ## t ## _time += timing_ ## t ## _end.tms_utime - timing_ ## t ## _start.tms_utime; }
 #define TIMING_DEFINE_PRINT(t) long timing_ ## t ## _time; \
-void timing_print_ ## t ( char * msg ) { cout.setf( ios::fixed, ios::floatfield); cout.precision(2); \
-  cout << msg << float(timing_ ## t ## _time) / 60 << " sec" << endl; }
+void timing_print_ ## t ( char * msg ) { CERR.setf( ios::fixed, ios::floatfield); CERR.precision(2); \
+  CERR << msg << float(timing_ ## t ## _time) / 60 << " sec" << "\n"; }
 #define TIMING_PRINT(t,msg) timing_print_ ## t ( msg );
 #define TIMING_DEFINE_PRINTPROTO(t) void timing_print_ ## t ( char * );
@@ -36 +44 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.3  1997/09/12 07:19:59  Singular
+* hannes/michael: libfac-0.3.0
+
 Revision 1.2  1997/04/25 22:13:56  michael
 Version for libfac-0.2.1

libfac/test.cc

@@ -1 @@
-//static char rcsid[] = "$Id: test.cc,v 1.3 1997-09-12 07:19:34 Singular Exp $";
+//static char rcsid[] = "$Id: test.cc,v 1.4 2006-05-16 14:46:48 Singular Exp $";
 ///////////////////////////////////////////////////////////////////////////////
 // Factor - Includes
 #include "factor.h"
+#ifdef HAVE_IOSTREAM
+#include <iostream>
+#define CERR std::cerr
+#define COUT std::cout
+#define CIN std::cin
+#elif defined(HAVE_IOSTREAM_H)
+#include <iostream.h>
+#define CERR cerr
+#define COUT cout
+#define CIN cin
+#endif
+
 
 
@@ -21 +33 @@
     CFFactor copy;
 
-cout << libfac_name  <<", Version " << libfac_version << endl;
-//    cout << " Characteristic = "; 
-    cin >> charac;
+COUT << libfac_name  <<", Version " << libfac_version << "\n";
+//    COUT << " Characteristic = "; 
+    CIN >> charac;
     setCharacteristic(charac);
     On(SW_SYMMETRIC_FF);
@@ -35 +47 @@
 //
 //////////////////////////////////////////////////////////////
-//    cout << " f = "; 
-    cin >> f;
-    cout << f  << " mod " << charac << " = " ;
+//    COUT << " f = "; 
+    CIN >> f;
+    COUT << f  << " mod " << charac << " = " ;
     Factorlist= Factorize( f,0 );
-     cout << Factorlist ;//<< endl;
+     COUT << Factorlist ;//<< "\n";
 // Ueberpruefen:
     g=1;
@@ -50 +62 @@
     }
     if ( (f-g) != f.genZero() ){
-        cerr << "\nList and f differ: f= " << f << "  g= " << g << endl;
+        CERR << "\nList and f differ: f= " << f << "  g= " << g << "\n";
     }
 }

libfac/testcs.cc

@@ -1 @@
-// $Id: testcs.cc,v 1.2 1997-09-12 07:19:35 Singular Exp $
+// $Id: testcs.cc,v 1.3 2006-05-16 14:46:48 Singular Exp $
 
 #include <factory.h>
 #include <factor.h>
+#ifdef HAVE_IOSTREAM
+#include <iostream>
+#define COUT std::cout
+#define CIN std::cin
+#elif defined(HAVE_IOSTREAM_H)
+#include <iostream.h>
+#define COUT cout
+#define CIN cin
+#endif
+
 
 // testing: Characteristic Sets
@@ -18 +28 @@
   int reord=0; // use strategy for reordering?
   int charac;
-  cout << " Characteristic = "; cin >> charac;
+  COUT << " Characteristic = "; CIN >> charac;
   setCharacteristic(charac);
   On(SW_SYMMETRIC_FF);
   char vnames[30];
-  cout << " vnames = "; cin >> vnames;
+  COUT << " vnames = "; CIN >> vnames;
 
   setVarNames( vnames );
@@ -34 +44 @@
   Varlist betterorder;
 
-  cout << " f[" << i << "] = "; cin >> f;
+  COUT << " f[" << i << "] = "; cin >> f;
   while ( f != 0 ) {
     F1.append( f ); i++;
-    cout << " f[" << i << "] = "; cin >> f;
+    COUT << " f[" << i << "] = "; cin >> f;
   }
   F2=F1;
-  cout << endl;
+  COUT << "\n";
 
-  cout << "F = " << F1 << endl;
+  COUT << "F = " << F1 << "\n";
   if (reord){
     betterorder= neworder(F1);
-    cout << "new orderd vars: " << betterorder << endl;
+    COUT << "new orderd vars: " << betterorder << "\n";
     F1=reorder(betterorder,F1);
-    cout << "new F= " << F1 << endl;
+    COUT << "new F= " << F1 << "\n";
   }
-//   cout << "\nUsing Modified CharSet:" << endl;
+//   COUT << "\nUsing Modified CharSet:" << "\n";
 //   F2 = MCharSetN( F1, Remembern );
-//   cout << "MCsN(F) = " << F2 << endl;
-//   cout << "Factors removed: " << Remembern.FS2 << endl;
-//   cout << "Possible Factors considered: " << Remembern.FS1 << endl;
+//   COUT << "MCsN(F) = " << F2 << "\n";
+//   COUT << "Factors removed: " << Remembern.FS2 << "\n";
+//   COUT << "Possible Factors considered: " << Remembern.FS1 << "\n";
 //   for ( I = F2; I.hasItem(); I++ )
-//     cout << "  vars: " << getVars( I.getItem() ) << endl;
-  cout << "\nUsing IrrCharSeries:" << endl;
+//     COUT << "  vars: " << getVars( I.getItem() ) << "\n";
+  COUT << "\nUsing IrrCharSeries:" << "\n";
   Q= IrrCharSeries( F1 );
-  cout << "ics(F) = " << Q << endl;
+  COUT << "ics(F) = " << Q << "\n";
   if (reord){
     Q=reorder(betterorder,Q);
-    cout << "reorderd ics(F) = " << Q << endl;
+    COUT << "reorderd ics(F) = " << Q << "\n";
   }
 }