Changeset 38e7b3 in git

Timestamp:

May 15, 2007, 4:46:49 PM (17 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '17f1d200f27c5bd38f5dfc6e8a0879242279d1d8')

Children:

10697c5f8efbddd9473d4c6b1643df3543bb6c50

Parents:

c3c515358fdfb7f2eec3dccc57840e2480316ab9

Message:

*hannes: factorize in Zp(a)[x...]


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

Location:

libfac

Files:

• charset/alg_factor.cc (modified) (7 diffs)
• charset/csutil.cc (modified) (13 diffs)
• factor/Factor.cc (modified) (18 diffs)
• factor/MVMultiHensel.cc (modified) (10 diffs)
• factor/SqrFree.cc (modified) (5 diffs)
• factor/helpstuff.h (modified) (3 diffs)
• factor/test.cc (modified) (2 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.16 2006-05-16 14:46:48 Singular Exp $";
+static char * rcsid = "$Id: alg_factor.cc,v 1.17 2007-05-15 14:46:48 Singular Exp $";
 ////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -448 +448 @@
 // the heart of the algorithm: the one from Trager
 static CFFList
-alg_factor( const CanonicalForm & f, const CFList & Astar, const Variable & vminpoly, const Varlist & oldord, const CFList & as){
+alg_factor( const CanonicalForm & f, const CFList & Astar, const Variable & vminpoly, const Varlist & oldord, const CFList & as)
+{
   CFFList L, Factorlist;
   CanonicalForm R, Rstar, s, g, h;
@@ -455 +456 @@
   DEBINCLEVEL(CERR,"alg_factor");
   DEBOUTLN(CERR, "alg_factor: f= ", f);
+
   //out_cf("start alg_factor:",f,"\n");
   substlist= simpleextension(Astar, vminpoly, Rstar);
@@ -504 +506 @@
   if ( !Factorlist.getFirst().factor().inCoeffDomain() )
     Factorlist.insert(CFFactor(1,1));
-  if ( Factorlist.length() == 2 && Factorlist.getLast().exp()== 1){ // irreduzibel (first entry is a constant)
+  if ( Factorlist.length() == 2 && Factorlist.getLast().exp()== 1)
+  { // irreduzibel (first entry is a constant)
     L.append(CFFactor(f,1));
   }
-  else{
+  else
+  {
     DEBOUTLN(CERR, "alg_factor: g= ", g);
     CanonicalForm gnew= g(s,s.mvar());
     DEBOUTLN(CERR, "alg_factor: gnew= ", gnew);
     g=gnew;
-    for ( CFFListIterator i=Factorlist; i.hasItem(); i++){
+    for ( CFFListIterator i=Factorlist; i.hasItem(); i++)
+    {
       CanonicalForm fnew=i.getItem().factor();
       fnew= fnew(s,s.mvar());
@@ -522 +527 @@
         DEBOUTLN(CERR, "alg_factor: fnew= ", fnew);
       }
-      if (degree(i.getItem().factor()) > 0 ){
+      if (degree(i.getItem().factor()) > 0 )
+      {
         // undo linear transformation!!!! and then gcd!
         //CERR << "algcd(" << g << "," << fnew << ",as" << as << ")" << "\n";
-        //out_cf("algcd g=",g,"\n");
-        //out_cf("algcd fnew=",fnew,"\n");
+        //out_cf("g=",g,"\n");
+        //out_cf("fnew=",fnew,"\n");
         //h= algcd(g,fnew, as, oldord);
         //if (as.length() >1)
@@ -537 +543 @@
         DEBOUTLN(CERR, "  alg_factor: h= ", h);
         DEBOUTLN(CERR, "  alg_factor: oldord= ", oldord);
-        if ( degree(h) > 0 ){ //otherwise it's a constant
+        if ( degree(h) > 0 )
+        { //otherwise it's a constant
+          //CanonicalForm c=LC(h,g.mvar());
+          //out_cf("new lc h:",c,"\n");
+          //h= divide(h,c,as);
+          //out_cf("new factor h/c:",h,"\n");
           g= divide(g, h,as);
           DEBOUTLN(CERR, "alg_factor: g/h= ", g);
           DEBOUTLN(CERR, "alg_factor: s= ", s);
           DEBOUTLN(CERR, "alg_factor: substlist= ", substlist);
+          //out_cf("new g:",g,"\n");
           L.append(CFFactor(h,1));
         }
+        //else printf("degree <=1\n");
       }
     }
@@ -817 +830 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.16  2006/05/16 14:46:48  Singular
+*hannes: gcc 4.1 fixes
+
 Revision 1.15  2005/10/17 13:16:18  Singular
 *hannes: code cleanup

libfac/charset/csutil.cc

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-static char * rcsid = "$Id: csutil.cc,v 1.13 2006-06-19 13:37:47 Singular Exp $";
+static char * rcsid = "$Id: csutil.cc,v 1.14 2007-05-15 14:46:48 Singular Exp $";
 /////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -202 +202 @@
 
 CanonicalForm
-divide( const CanonicalForm & ff, const CanonicalForm & f, const CFList & as){
+divide( const CanonicalForm & ff, const CanonicalForm & f, const CFList & as)
+{
   CanonicalForm r,m,q;
 
@@ -224 +225 @@
 
 static CanonicalForm
-myfitting( const CanonicalForm &f ){
+myfitting( const CanonicalForm &f )
+{
  CanonicalForm rem=f;
 
- if ( !(rem.isZero()) ){
+ if ( !(rem.isZero()) )
+ {
    if ( getCharacteristic() > 0 )
      return num((rem/lc(rem)));
-   else{
+   else
+   {
      On(SW_RATIONAL);
      CanonicalForm temp= mapinto(rem);
@@ -270 +274 @@
 
 static CanonicalForm
-premasb( const CanonicalForm & f, const CFList & as){
+premasb( const CanonicalForm & f, const CFList & as)
+{
   CanonicalForm remd=f;
   CFList AS=as;
 
-  if ( as.length() > 1 ){
+  if ( as.length() > 1 )
+  {
     AS.removeFirst(); // get rid of first elem
     CanonicalForm elem;
-    while ( ! AS.isEmpty() ){ // thats true for at least the first iteration
+    while ( ! AS.isEmpty() )
+    { // thats true for at least the first iteration
       elem= AS.getLast();
       remd= Prem(remd,elem);
@@ -291 +298 @@
 
 CFList
-remsetb( const CFList & ps, const CFList & as){
+remsetb( const CFList & ps, const CFList & as)
+{
   CFList output;
   CanonicalForm elem;
-  for (CFListIterator i=ps; i.hasItem(); i++){
+  for (CFListIterator i=ps; i.hasItem(); i++)
+  {
     elem= premasb(i.getItem(),as);
     if ( elem != elem.genZero() ) output.append(elem);
@@ -305 +314 @@
 // replace the power of factors of polys in as by 1 if any
 static CFList
-nopower( const CanonicalForm & init ){
+nopower( const CanonicalForm & init )
+{
   CFFList sqrfreelist;// = Factorize(init);//SqrFree(init);
   CFList output;
@@ -317 +327 @@
   //  CERR << "nopower: count is " << count << "\n";}
   if ( count > 1 ) sqrfreelist = CFFList( CFFactor(init,1));
-  else {
+  else
+  {
     sqrfreelist = Factorize(init);
     //sqrfreelist.removeFirst();
   }
-  for ( CFFListIterator i=sqrfreelist; i.hasItem(); i++ ){
+  for ( CFFListIterator i=sqrfreelist; i.hasItem(); i++ )
+  {
     elem=i.getItem().factor();
     if ( cls(elem) > 0 ) output.append(elem);
@@ -363 +375 @@
   CFListIterator j ;
 
-  for ( int J=1; J<= n ; J++ ){
+  for ( int J=1; J<= n ; J++ )
+  {
     testlist.append(CanonicalForm(Variable(J)));
   }
@@ -370 +383 @@
 
   // remove already removed factors
-  for ( j = Remembern.FS2 ; j.hasItem(); j++ ){
+  for ( j = Remembern.FS2 ; j.hasItem(); j++ )
+  {
     testelem = j.getItem();
-    while ( 1 ){
+    while ( 1 )
+    {
       test = mydivremt(r,testelem,a,b);
       if ( test && b == r.genZero() ) r = a;
@@ -380 +395 @@
 
   // Let's look if we have other canditates to remove
-  for ( j = testlist ; j.hasItem(); j++ ){
+  for ( j = testlist ; j.hasItem(); j++ )
+  {
     testelem = j.getItem();
 //    if ( testelem != r && testelem != r.mvar() ){
-    if ( testelem != r ){
-      while ( 1 ){
+    if ( testelem != r )
+    {
+      while ( 1 )
+      {
         test = divremt(r,testelem,a,b);
-        if ( test && b == r.genZero() ){
+        if ( test && b == r.genZero() )
+        {
           Remembern.FS2= Union(Remembern.FS2, CFList(testelem));
           r = a;
@@ -404 +423 @@
 // all irreducible nonconstant factors of a set of polynomials
 CFList
-factorps( const CFList &ps ){
+factorps( const CFList &ps )
+{
   CFList qs;
   CFFList q;
   CanonicalForm elem;
 
-  for ( CFListIterator i=ps; i. hasItem(); i++ ){
+  for ( CFListIterator i=ps; i. hasItem(); i++ )
+  {
     q=Factorize(i.getItem());
     q.removeFirst();
     // Next can be simplified ( first (already removed) elem in q is the only constant
-    for ( CFFListIterator j=q; j.hasItem(); j++ ){
+    for ( CFFListIterator j=q; j.hasItem(); j++ )
+    {
       elem = j.getItem().factor();
       if ( getNumVars(elem) > 0 )
@@ -424 +446 @@
 // the initial of poly f wrt to the order of the variables
 static CanonicalForm
-inital( const CanonicalForm &f ){
+inital( const CanonicalForm &f )
+{
   CanonicalForm leadcoeff;
 
   if ( cls(f) == 0 ) {return f.genOne(); }
-  else {
+  else
+  {
     leadcoeff = LC(f,lvar(f));
     //    if ( leadcoeff != 0 )
@@ -873 +897 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.13  2006/06/19 13:37:47  Singular
+*hannes: more CS renamed
+
 Revision 1.12  2006/05/16 14:46:49  Singular
 *hannes: gcc 4.1 fixes

libfac/factor/Factor.cc

@@ -1 +1 @@
 /* Copyright 1996 Michael Messollen. All rights reserved. */
 ///////////////////////////////////////////////////////////////////////////////
-static char * rcsid = "$Id: Factor.cc,v 1.23 2006-05-16 14:46:49 Singular Exp $ ";
+static char * rcsid = "$Id: Factor.cc,v 1.24 2007-05-15 14:46:48 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.";
 ///////////////////////////////////////////////////////////////////////////////
@@ -343 +343 @@
     if ( level(compress(g,m)) == (vars_left) ) // exactly one variable less
       if ( SqrFreeTest(g,1) ) // poly is sqrfree
-        if ( mygcd(g,g.deriv()) == 1 ) // Discriminante != 0
+        if ( gcd(g,g.deriv()) == 1 ) // Discriminante != 0
            return 1;
   return 0;
@@ -431 +431 @@
 ///////////////////////////////////////////////////////////////
 static int
-try_specializePoly(const CanonicalForm & f, const Variable & Extension, int deg, SFormList & Substitutionlist, int ii,int j){
+try_specializePoly(const CanonicalForm & f, const Variable & Extension, int deg, SFormList & Substitutionlist, int ii,int j)
+{
   int ok,i= ii;
   CanonicalForm ff= f;
@@ -440 +441 @@
   }
 
-  if ( degree(Extension) > 0 ){ // working over Extensions
+  if ( degree(Extension) > 0 )
+  { // working over Extensions
     DEBOUTLN(CERR, "try_specializePoly: working over Extensions: ", Extension);
-    AlgExtGenerator g(Extension);
-    for ( int k=i ; k<j ; k++ ){ // try to find specialization for all
-                                 // variables (# = k ) beginning with the
+    if (Extension.level() > 0)
+    {
+    //  AlgExtGenerator g(Extension,minpoly );
+    //  for ( int k=i ; k<j ; k++ ) // try to find specialization for all
+    //  {                           // variables (# = k ) beginning with the
+    //                             // starting value i
+    //    ok= specialize_agvariable( ff, deg, Substitutionlist, k, j, g );
+    //    if ( ! ok ) return 0; // we failed
+    //  }
+      printf("libfac: try_specializePoly: extension level >0\n");
+      return 0; // we failed
+    }
+    else
+    {
+      AlgExtGenerator g(Extension);
+      for ( int k=i ; k<j ; k++ ) // try to find specialization for all
+      {                           // variables (# = k ) beginning with the
                                  // starting value i
-      ok= specialize_agvariable( ff, deg, Substitutionlist, k, j, g );
-      if ( ! ok ) return 0; // we failed
+        ok= specialize_agvariable( ff, deg, Substitutionlist, k, j, g );
+        if ( ! ok ) return 0; // we failed
+      }
     }
   }
@@ -658 +675 @@
     ff = f.deriv();
     TIMING_START(discr_time);
-    ffuni = mygcd(f,ff);
+    ffuni = gcd(f,ff);
     TIMING_END(discr_time);
     if ( !(ffuni.isOne()) ){ //discriminante nonzero: split poly
@@ -692 +709 @@
   lt = LC(f);
   DEBOUTLN(CERR, "Leading term: ", lt);
-  if ( lt != f.genOne() ){
+  if ( lt != f.genOne() )
+  {
     // make the polynomial monic in the main variable
     ff = make_monic(f,lt); ffuni = ff;
@@ -702 +720 @@
   success=evaluate(min(10,max(degree(ff), 5)), min(degree(ff),3), min(degree(ff),3), ff, Extension, alpha, Substitutionlist,UnivariateFactorlist);
   DEBOUTLN(CERR,  "Returned from evaluate: success: ", success);
-  for ( SFormListIterator ii=Substitutionlist; ii.hasItem(); ii++ ){
+  for ( SFormListIterator ii=Substitutionlist; ii.hasItem(); ii++ )
+  {
     DEBOUTLN(CERR, "Substituting ", ii.getItem().factor());
     DEBOUTLN(CERR, "       with value: ", ii.getItem().exp());
   }
 
-  if ( success==0 ){ // evalute wasn't successfull
+  if ( success==0 ) // evalute wasn't successfull
+  {
     success= specializePoly(ffuni,Extension,degree(ff),Substitutionlist,1,getNumVars(compress(ff,m)));
     DEBOUTLN(CERR,  "Returned from specializePoly: success: ", success);
-    if (success == 0 ){ // No spezialisation could be found
+    if (success == 0 ) // No spezialisation could be found
+    {
 #ifdef HAVE_SINGULAR_ERROR
       WarnS("libfac: Factorize: ERROR: Not able to find a valid specialization!");
@@ -731 +752 @@
     ffuni = substitutePoly(ff,Substitutionlist);
     // We now have an univariat poly; factorize that
-    if ( degree(Extension) == 0   ){
+    if ( degree(Extension) == 0   )
+    {
       DEBOUTMSG(CERR, "Univ. Factorization over the ground field");
       UnivariateFactorlist = factorize(ffuni,1); // univ. poly is sqr-free!
     }
-    else{
+    else
+    {
       DEBOUTLN(CERR, "Univ. Factorization over extension of degree ",
                degree(getMipo(Extension,'x')) );
@@ -748 +771 @@
     }
   }
-  else{
+  else
+  {
     ffuni = substitutePoly(ff,Substitutionlist);
   }
     TIMING_END(evaluate_time);
-  if (UnivariateFactorlist.length() == 1){ // poly is irreduzibel
+  if (UnivariateFactorlist.length() == 1)
+  { // poly is irreduzibel
     DEBOUTLN(CERR, "Univ. poly is irreduzible: ", UnivariateFactorlist);
     Outputlist.append(CFFactor(F,1));
     return Outputlist;
   }
-  else{ // we have factors
+  else
+  { // we have factors
     DEBOUTSL(CERR);
     DEBOUT(CERR, "Univariate poly has " , UnivariateFactorlist.length());
@@ -812 +838 @@
 ///////////////////////////////////////////////////////////////
 int find_mvar(const CanonicalForm &f);
-CFFList
-Factorize(const CanonicalForm & F, int is_SqrFree ){
+CFFList Factorize(const CanonicalForm & F, int is_SqrFree )
+{
   CFFList Outputlist,SqrFreeList,Intermediatelist,Outputlist2;
   ListIterator<CFFactor> i,j;
@@ -828 +854 @@
   DEBOUTMSG(CERR, rcsid);
   DEBOUTLN(CERR, "Called with F= ", F);
-  if ( getCharacteristic() == 0 ) { // char == 0
+  if ( getCharacteristic() == 0 )
+  { // char == 0
     TIMING_START(factorize_time);
     //CERR << "Factoring in char=0 of " << F << " = " << Outputlist << "\n";
@@ -858 +885 @@
   ///////
   //  if ( ! SqrFreeTest(F) ){
-  if ( ! is_SqrFree ){
+  if ( ! is_SqrFree )
+  {
     TIMING_START(sqrfree_time);
     SqrFreeList = InternalSqrFree(F) ; // first sqrfree the polynomial
@@ -874 +902 @@
     SqrFreeList.append(CFFactor(F,1));
   DEBOUTLN(CERR, "InternalSqrFreeList= ", SqrFreeList);
-  for ( i=SqrFreeList; i.hasItem(); i++ ){
+  for ( i=SqrFreeList; i.hasItem(); i++ )
+  {
     DEBOUTLN(CERR, "Factor under consideration: ", i.getItem().factor());
     // We need a compress on each list item ! Maybe we have less variables!
@@ -882 +911 @@
       Outputlist.append( CFFactor(g,1) ) ;
     else// a real polynomial
-      if ( g.isUnivariate() ){
+      if ( g.isUnivariate() )
+      {
         Intermediatelist=factorize(g,1); // poly is sqr-free!
         for ( j=Intermediatelist; j.hasItem(); j++ )
@@ -888 +918 @@
           Outputlist.append( CFFactor( m(j.getItem().factor()),exp*j.getItem().exp()));
       }
-      else{ // multivariate polynomial
-        if ( g.isHomogeneous() ){
+      else
+      { // multivariate polynomial
+        if ( g.isHomogeneous() )
+        {
           DEBOUTLN(CERR, "Poly is homogeneous! : ", g);
           // Now we can substitute one variable to 1, factorize and then
@@ -911 +943 @@
   DEBOUTLN(CERR, "Outputlist is ", Outputlist);
   for ( i=Outputlist; i.hasItem(); i++ )
-    if ( level(i.getItem().factor()) > 0 ){
+    if ( level(i.getItem().factor()) > 0 )
+    {
       unit = lc(i.getItem().factor());
-      if ( getNumVars(unit) == 0 ){ // a constant; possibly 1
+      if ( getNumVars(unit) == 0 )
+      { // a constant; possibly 1
         Outputlist2.append(CFFactor(i.getItem().factor()/unit , i.getItem().exp()));
         g *=power(i.getItem().factor()/unit,i.getItem().exp());
       }
-      else{
+      else
+      {
         Outputlist2.append(i.getItem());
         g *=power(i.getItem().factor(),i.getItem().exp());
@@ -959 +994 @@
 ///////////////////////////////////////////////////////////////
 CFFList
-Factorize(const CanonicalForm & F, const CanonicalForm & minpoly, int is_SqrFree ){
+Factorize(const CanonicalForm & F, const CanonicalForm & minpoly, int is_SqrFree )
+{
   CFFList Outputlist,SqrFreeList,Intermediatelist,Outputlist2;
   ListIterator<CFFactor> i,j;
@@ -1132 +1168 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.23  2006/05/16 14:46:49  Singular
+*hannes: gcc 4.1 fixes
+
 Revision 1.22  2006/04/28 13:46:29  Singular
 *hannes: better tests for 0, 1

libfac/factor/MVMultiHensel.cc

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// static char * rcsid = "$Id: MVMultiHensel.cc,v 1.9 2006-05-16 14:46:49 Singular Exp $";
+// static char * rcsid = "$Id: MVMultiHensel.cc,v 1.10 2007-05-15 14:46:49 Singular Exp $";
 ///////////////////////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -29 +29 @@
 #ifdef SINGULAR
 #define HAVE_SINGULAR_ERROR
+#ifndef NOSTREAMIO
+void out_cf(char *s1,const CanonicalForm &f,char *s2);
+#endif
 #endif
 
 #ifdef HAVE_SINGULAR_ERROR
-   extern "C" { void WerrorS(char *); }
+   extern "C"
+   {
+     void WerrorS(char *);
+     void Werror(const char *fmt, ...);
+   }
 #endif
 
@@ -97 +104 @@
       ia[ix].calculated=false;
       ia[ix].poly=0;
-    }  
+    }
   }
 // internal data representation
@@ -111 +118 @@
 ///////////////////////////////////////////////////////////////
 static DiophantForm
-diophant( int levelU , const CanonicalForm & F1 , const CanonicalForm & F2 , int i , RememberArray & A, RememberArray & B ) {
+diophant( int levelU , const CanonicalForm & F1 , const CanonicalForm & F2 , int i , RememberArray & A, RememberArray & B )
+{
   DiophantForm Retvalue;
   CanonicalForm s,t,q,r;
@@ -121 +129 @@
   // Did we solve the diophantine equation yet?
   // If so, return the calculated values
-  if (A.checksize(i) && A[i].calculated && B[i].calculated ){
+  if (A.checksize(i) && A[i].calculated && B[i].calculated )
+  {
     Retvalue.One=A[i].poly;
     Retvalue.Two=B[i].poly;
@@ -128 +137 @@
 
   // Degrees ok? degree(F1,mainvar) + degree(F2,mainvar) <= i ?
-  if ( (degree(F1,levelU) + degree(F2,levelU) ) <= i ) {
+  if ( (degree(F1,levelU) + degree(F2,levelU) ) <= i )
+  {
 #ifdef HAVE_SINGULAR_ERROR
-    WerrorS("libfac: diophant ERROR: degree too large!  ");
+    Werror("libfac: diophant ERROR: degree too large!  (%d + %d <= %d)",degree(F1,levelU), degree(F2,levelU), i);
+      //out_cf("F1:",F1,"\n");
+      //out_cf("F2:",F2,"\n");
 #else
 #ifndef NOSTREAMIO
@@ -143 +155 @@
   }
 
-  if ( i == 0 ) { // call the extended gcd
+  if ( i == 0 )
+  { // call the extended gcd
     r=extgcd(F1,F2,s,t);
     // check if gcd(F1,F2) <> 1 , i.e. F1 and F2 are not relatively prime
-    if ( ! r.isOne() ){
+    if ( ! r.isOne() )
+    {
 #ifdef HAVE_SINGULAR_ERROR
       WerrorS("libfac: diophant ERROR: F1 and F2 are not relatively prime! ");
+      //out_cf("F1:",F1,"\n");
+      //out_cf("F2:",F2,"\n");
 #else
 #ifndef NOSTREAMIO
@@ -162 +178 @@
     Retvalue.One = s; Retvalue.Two = t;
   }
-  else { // recursively call diophant
+  else
+  { // recursively call diophant
     Retvalue=diophant(levelU,F1,F2,i-1,A,B);
     Retvalue.One *= x; // createVar(levelU,1);
@@ -168 +185 @@
     // Check degrees.
 
-    if ( degree(Retvalue.One,levelU) > degree(F2,levelU) ){
+    if ( degree(Retvalue.One,levelU) > degree(F2,levelU) )
+    {
       // Make degree(Retvalue.one,mainvar) < degree(F2,mainvar)
       divrem(Retvalue.One,F2,q,r);
       Retvalue.One = r; Retvalue.Two += F1*q;
     }
-    else {
-      if ( degree(Retvalue.Two,levelU) >= degree(F1,levelU) ){
+    else
+    {
+      if ( degree(Retvalue.Two,levelU) >= degree(F1,levelU) )
+      {
         // Make degree(Retvalue.Two,mainvar) <= degree(F1,mainvar)
         divrem(Retvalue.Two,F1,q,r);
@@ -430 +450 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.9  2006/05/16 14:46:49  Singular
+*hannes: gcc 4.1 fixes
+
 Revision 1.8  2002/07/30 15:11:19  Singular
 *hannes: minor cleanups

libfac/factor/SqrFree.cc

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-static char * rcsid = "$Id: SqrFree.cc,v 1.10 2006-05-16 14:46:50 Singular Exp $";
+static char * rcsid = "$Id: SqrFree.cc,v 1.11 2007-05-15 14:46:49 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.";
 ///////////////////////////////////////////////////////////////////////////////
@@ -149 +149 @@
     // Next: it would be best to have a *univariate* gcd-test which returns
     // 0 iff gcdtest(f,g) == 1 or a constant ( for real Polynomials )
-    g = mygcd(f,g);
+    g = gcd(f,g);
     if ( g.isOne() || (-g).isOne() ) return 1;
     else
@@ -182 +182 @@
     // Next: it would be best to have a *multivariate* gcd-test which returns
     // 0 iff gcdtest(f,g) == 1 or a constant ( for real Polynomials )
-    g= mygcd(f,g);
+    g= gcd(f,g);
     if ( g.isOne() || (-g).isOne() || (g==f) || (getNumVars(g)==0) ) return 1 ;
     else return 0 ;
@@ -294 +294 @@
   }
   g = f.deriv();
-  DEBOUTLN(CERR, "calculating mygcd of ", f);
+  DEBOUTLN(CERR, "calculating gcd of ", f);
   DEBOUTLN(CERR, "               and ", g);
-  h = mygcd(f,pp(g));  h /= lc(h);
-  DEBOUTLN(CERR,"mygcd(f,g)= ",h);
+  h = gcd(f,pp(g));  h /= lc(h);
+  DEBOUTLN(CERR,"gcd(f,g)= ",h);
   if ( (h.isOne()) || ( h==f) || ((-h).isOne()) || getNumVars(h)==0 ) { // no common factor
     Outputlist= myappend(Outputlist,CFFactor(f,1)) ;
@@ -415 +415 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.10  2006/05/16 14:46:50  Singular
+*hannes: gcc 4.1 fixes
+
 Revision 1.9  2006/04/28 13:46:29  Singular
 *hannes: better tests for 0, 1

libfac/factor/helpstuff.h

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: helpstuff.h,v 1.3 1997-09-12 07:19:57 Singular Exp $
+// $Id: helpstuff.h,v 1.4 2007-05-15 14:46:49 Singular Exp $
 ////////////////////////////////////////////////////////////
 #ifndef HELPSTUFF_H
@@ -27 +27 @@
   return (a>b ? a:b);
 }
-//////////////////
-// For testing  //
-//////////////////
-#ifdef SPARSEGCD
-#include "gcd.h"
-#define mygcd(f,g) \
-((CanonicalForm) sparsemod( f,  g ))
-#else
-#define mygcd(f,g) \
-((CanonicalForm) gcd( f, g ))
-#endif
-
 #endif /* HELPSTUFF_H */
 
@@ -44 +32 @@
 /*
 $Log: not supported by cvs2svn $
+Revision 1.3  1997/09/12 07:19:57  Singular
+* hannes/michael: libfac-0.3.0
+
 Revision 1.2  1997/04/25 22:23:49  michael
 Version for libfac-0.2.1

libfac/factor/test.cc

@@ -1 @@
-//static char rcsid[] = "@(#) $Id: test.cc,v 1.2 1997-06-09 15:56:11 Singular Exp $";
+//static char rcsid[] = "@(#) $Id: test.cc,v 1.3 2007-05-15 14:46:49 Singular Exp $";
 ///////////////////////////////////////////////////////////////////////////////
 // CLAP - Includes
@@ -27 +27 @@
 //    cout << SqrFree(f) << endl << endl;
 //cout << "gcd(f,f.deriv())= gcd(" << f << "," << f.deriv() << ")= " << gcd(f,f.deriv()) << endl;
-//cout << "mygcd(f,f.deriv())= mygcd(" << f << "," << f.deriv() << ")= " << mygcd(f,f.deriv()) << endl;
+//cout << "gcd(f,f.deriv())= gcd(" << f << "," << f.deriv() << ")= " << gcd(f,f.deriv()) << endl;
         Factorlist = Factorize( f );
         cout << Factorlist ;//<< endl;