Changeset e2ca88 in git for libfac/factor

Timestamp:

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

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '17f1d200f27c5bd38f5dfc6e8a0879242279d1d8')

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/factor

Files:

• Factor.cc (modified) (40 diffs)
• MVMultiHensel.cc (modified) (17 diffs)
• SqrFree.cc (modified) (19 diffs)
• Truefactor.cc (modified) (12 diffs)
• class.h (modified) (4 diffs)
• debug.h (modified) (4 diffs)
• homogfactor.cc (modified) (5 diffs)
• timing.h (modified) (4 diffs)

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