Changeset 4a81ec in git

Timestamp:

Sep 12, 1997, 9:20:02 AM (26 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')

Children:

0fbdd16f374f7f4570da62a453e2328e4d8a4b4c

Parents:

0479e09dbc0fb17be7ebce384df4ba0318ba20eb

Message:

* hannes/michael: libfac-0.3.0


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

Location:

libfac

Files:

• 00README (modified) (4 diffs)
• Makefile.in (modified) (5 diffs)
• charset/Makefile (deleted)
• charset/alg_factor.cc (modified) (5 diffs)
• charset/alg_factor.h (modified) (1 diff)
• charset/algfactor.cc (modified) (1 diff)
• charset/algfactor.h (modified) (1 diff)
• charset/charset.cc (modified) (9 diffs)
• charset/charset.h (modified) (2 diffs)
• charset/csutil.cc (modified) (15 diffs)
• charset/csutil.h (modified) (3 diffs)
• charset/debug.cc (modified) (1 diff)
• charset/reorder.cc (modified) (4 diffs)
• charset/reorder.h (modified) (2 diffs)
• charset/testcs.cc (deleted)
• configure (modified) (11 diffs)
• configure.in (modified) (4 diffs)
• factor.h (modified) (3 diffs)
• factor/Factor.cc (modified) (15 diffs)
• factor/Factor.h (modified) (1 diff)
• factor/MVMultiHensel.cc (modified) (2 diffs)
• factor/MVMultiHensel.h (modified) (1 diff)
• factor/Makefile (deleted)
• factor/SqrFree.cc (modified) (8 diffs)
• factor/SqrFree.h (modified) (2 diffs)
• factor/Truefactor.cc (modified) (6 diffs)
• factor/Truefactor.h (modified) (1 diff)
• factor/class.cc (modified) (3 diffs)
• factor/class.h (modified) (4 diffs)
• factor/debug.cc (modified) (1 diff)
• factor/debug.h (modified) (2 diffs)
• factor/helpstuff.cc (modified) (4 diffs)
• factor/helpstuff.h (modified) (1 diff)
• factor/homogfactor.cc (modified) (2 diffs)
• factor/homogfactor.h (modified) (1 diff)
• factor/timing.h (modified) (1 diff)
• factor/tmpl_inst.cc (modified) (2 diffs)
• factor/tmpl_inst.cc.factory1.1 (deleted)
• factor/tmpl_inst.h (modified) (2 diffs)
• factor/version.cc (modified) (1 diff)
• header.tpl (modified) (2 diffs)
• test.cc (modified) (1 diff)
• testcs.cc (modified) (1 diff)

libfac/00README

@@ -1 @@
-This is the file 00README.libfac for version 0.2.4 of libfac.
+This is the file 00README.libfac for version prae 0.3.0 of libfac.
 
 ######### What is libfac?
@@ -95 +95 @@
 any templates for libsingfac.a.
 
-B) Using Makefile.dist (this is not recommended; maybe you have to edit a lot 
-to reflect your systems configuration.)
-copy Makefile.dist to Makefile
-Edit the factoryversion and the path to the factory library in the top Makefile
-(in this directory).
-currently: factoryversion=1.2b
-(I have tested with factoryversion 1.1 & 1.2beta & 1.2c; earlier versions 
-*don't* work)
-
-type:
-   make
-to generate a testprogram (test). You'll get a non-interactive debugging 
-version of test, which is half as fast as an optimized version. 
-You get an optimized version of test by typing:
-   make opttest
-
-If you type
-   make tests
-
-a program (test) will be generated and a bunch of test-examples will
-be tested. 
-
-If you only need the library ( it will be produced anyway) just type
-   make libfac
-for the optimized version (libfac.a) or
-   make libfac-g
-for the debugging version (libfac-g.a).
-
-The include file for the libraries is called "factor.h" and is shipped
-with this version. 
-If you have perl you can generate "factor.h" with:
-   ./bin/makeheader header.tpl factor.h
-in the top directory (Perhaps you have to edit the path to perl in 
-./bin/makeheader).
+If you want to produce a test file, type:
+  configure [--with-debug] [--libdir=path-to-libcf.a] [--includedir=path-to-factory.h]
+  make tests
+this will produce libfac.a and a binary called test. "test" is then used to 
+test some examples for factorization.
+
+B) Using Makefile.dist  
+**** Since version 0.3.0 this is no longer supported ****
+**** Get an earlier version and patch Makefile.dist for your needs, ****
+**** or, better, use configure.
 
 
@@ -161 +137 @@
   is not yet implemented (but I'm working on it).
   Don't trust the result you'll get in such a case!!!!!!
+Since version 0.3.0 this problem is gone. (or should be :-) )
 
 o The performance of the irreducible characteristic series stuff heavily
@@ -260 +237 @@
         o released May 30 1997
 
+V0.3.0a o changed configure.in: will not override CFLAGS or CXXFLAGS if set in
+          the environment
+        o added new functionality in charset/algfacor.{cc/h} :
+          now we should be able to factorize over any field needed for the
+          charset-algorithm. (Internal note: perhaps there are still problems
+          for the char=0 case because of the factory implementation vs. gmp)
+        o for this,  changed charset/csutil.{cc/h} and charset/charset.{cc/h}
+        o include #include <file.h> in file.cc for some CC's
+        o Internal note: need more interrupt handles enabled;
+                         set up test examples for char=0 and char>0;
+        o released Jun 25 1997
+
+V0.3.0b o implemented Tragers algorithm; this is now the default used in 
+          charsets (file: charsets/alg_factor.cc)
+        o for char=0 case there are some problems with factory;
+          for char=p there seems to be an internal factory memory-problem in
+          some cases
+        o released Sep 11 1997

libfac/Makefile.in

@@ -1 @@
-# $Id: Makefile.in,v 1.7 1997-06-09 15:55:47 Singular Exp $
+# $Id: Makefile.in,v 1.8 1997-09-12 07:19:31 Singular Exp $
 #################################################
 SHELL           = /bin/sh
@@ -63 +63 @@
                 factor/debug.h factor/timing.h factor/homogfactor.h \
                 factor/interrupt.h
-CHARSETINCL =   charset/csutil.h charset/charset.h charset/reorder.h
+CHARSETINCL =   charset/csutil.h charset/charset.h charset/reorder.h \
+                charset/alg_factor.h charset/algfactor.h
 
 OPTFACTOROBJ1 = OPTOBJ/SqrFree.o OPTOBJ/Factor.o OPTOBJ/MVMultiHensel.o \
                 OPTOBJ/Truefactor.o OPTOBJ/helpstuff.o OPTOBJ/version.o \
-                OPTOBJ/homogfactor.o
+                OPTOBJ/homogfactor.o OPTOBJ/debug.o
 OPTFACTOROBJ2 = OPTOBJ/tmpl_inst.o
 OPTFACTOROBJ =  $(OPTFACTOROBJ2) $(OPTFACTOROBJ1)
 
-OPTCHARSETOBJ = OPTOBJ/csutil.o OPTOBJ/charset.o OPTOBJ/reorder.o
+OPTCHARSETOBJ = OPTOBJ/csutil.o OPTOBJ/charset.o OPTOBJ/reorder.o \
+                OPTOBJ/alg_factor.o OPTOBJ/algfactor.o
 
 DEBFACTOROBJ1 = DEBOBJ/SqrFree.o DEBOBJ/Factor.o DEBOBJ/MVMultiHensel.o \
                 DEBOBJ/Truefactor.o DEBOBJ/helpstuff.o DEBOBJ/version.o \
-                DEBOBJ/homogfactor.o
+                DEBOBJ/homogfactor.o DEBOBJ/debug.o
 DEBFACTOROBJ2 = DEBOBJ/tmpl_inst.o
 DEBFACTOROBJ =  $(DEBFACTOROBJ2) $(DEBFACTOROBJ1)
 
-DEBCHARSETOBJ = DEBOBJ/csutil.o DEBOBJ/charset.o DEBOBJ/reorder.o
+DEBCHARSETOBJ = DEBOBJ/csutil.o DEBOBJ/charset.o DEBOBJ/reorder.o \
+                DEBOBJ/alg_factor.o DEBOBJ/algfactor.o
 
 ##
@@ -87 +90 @@
 .SUFFIXES:      .cc .h .o
 
-all: ${TARGETNAME}
+all: OPTOBJ DEBOBJ ${TARGETNAME}
+
+OPTOBJ:
+        ${MKINSTALLDIRS} OPTOBJ
+
+DEBOBJ:
+        ${MKINSTALLDIRS} DEBOBJ
 
 OPTOBJ/%.o: %.cc 
@@ -151 +160 @@
 
 mostlyclean:
-        $(RM)   test ${LIBFACNAME}.a ${SINGLIBFACNAME}.a \
+        $(RM)   test testcs ${LIBFACNAME}.a ${SINGLIBFACNAME}.a \
                 ${LIBFACNAME-G}.a ${SINGLIBFACNAME-G}.a
 
 clean:  mostlyclean
-        $(RM) charset/DEBOBJ/* OPTOBJ/*
         $(RM) OPTOBJ/optdepend DEBOBJ/debdepend  \
               DEBOBJ/*.o OPTOBJ/*.o
@@ -175 +183 @@
                 (cd tests ; factortest )
 
+charsettest:    libfac  OPTOBJ/testcs.o
+                $(CXX) -o testcs $(LDFLAGS) OPTOBJ/testcs.o $(LIBS)
+
+#charsettests:  charsettest
+#               (cd tests ; charsettest )
+
 tests:          factests
 

libfac/charset/alg_factor.cc

@@ -3 +3 @@
 // emacs edit mode for this file is -*- C++ -*-
 ////////////////////////////////////////////////////////////
-static char * rcsid = "$Id: alg_factor.cc,v 1.1.1.1 1997-09-11 10:58:22 Singular Exp $";
+static char * rcsid = "$Id: alg_factor.cc,v 1.2 1997-09-12 07:19:37 Singular Exp $";
 ////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -155 +155 @@
       temp= gcd(R, R.deriv(vf)); 
       DEBOUTLN(cout, "sqrf_norm_sub: temp= ", temp);
-      if (degree(temp) != 0 || temp == temp.genZero() ){ sqfreetest= 0; }
+      if (degree(temp,vf) != 0 || temp == temp.genZero() ){ sqfreetest= 0; }
       else { sqfreetest= 1; }
       DEBOUTLN(cout, "sqrf_norm_sub: sqfreetest= ", sqfreetest);
@@ -336 +336 @@
   DEBOUTLN(cout, "alg_factor: R= ", R);
   Off(SW_RATIONAL);
-  Factorlist = Factorize(R,1); 
+  Factorlist = Factorize(R); 
   On(SW_RATIONAL);
   DEBOUTLN(cout, "alg_factor: Factorize(R)= ", Factorlist);
@@ -410 +410 @@
         if ( x != 0 ){
           divrem(ii.getItem(), gg, q,r);
-          cout << ii.getItem() << " divided by " << gg << endl;
+//        cout << ii.getItem() << " divided by " << gg << endl;
           DEBOUTLN(cout, "q= ", q); DEBOUTLN(cout, "r= ", r);
           ii.append(ii.getItem()+q*g); ii.remove(1);
@@ -614 +614 @@
 $Log: not supported by cvs2svn $
 */
+

libfac/charset/alg_factor.h

@@ -3 +3 @@
 // emacs edit mode for this file is -*- C++ -*-
 ////////////////////////////////////////////////////////////
-// $Id: alg_factor.h,v 1.1.1.1 1997-09-11 10:58:22 Singular Exp $
+// $Id: alg_factor.h,v 1.2 1997-09-12 07:19:37 Singular Exp $
 ////////////////////////////////////////////////////////////
 

libfac/charset/algfactor.cc

@@ -3 +3 @@
 // emacs edit mode for this file is -*- C++ -*-
 ////////////////////////////////////////////////////////////
-static char * rcsid = "$Id: algfactor.cc,v 1.1.1.1 1997-09-11 10:58:22 Singular Exp $";
+static char * rcsid = "$Id: algfactor.cc,v 1.2 1997-09-12 07:19:38 Singular Exp $";
 ////////////////////////////////////////////////////////////
 // FACTORY - Includes

libfac/charset/algfactor.h

@@ -3 +3 @@
 // emacs edit mode for this file is -*- C++ -*-
 ////////////////////////////////////////////////////////////
-// $Id: algfactor.h,v 1.1.1.1 1997-09-11 10:58:22 Singular Exp $
+// $Id: algfactor.h,v 1.2 1997-09-12 07:19:39 Singular Exp $
 ////////////////////////////////////////////////////////////
 

libfac/charset/charset.cc

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-static char * rcsid = "$Id: charset.cc,v 1.2 1997-06-09 15:55:53 Singular Exp $";
+static char * rcsid = "$Id: charset.cc,v 1.3 1997-09-12 07:19:40 Singular Exp $";
 /////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -12 +12 @@
 // Charset - Includes
 #include "csutil.h"
+#include "algfactor.h"
+#include "alg_factor.h"
+// Some CC's need this:
+#include "charset.h"
 
 #ifdef BASICSETDEBUG
@@ -47 +51 @@
         b = lowestRank( QS );
         cb = rank( b );
+        DEBOUTLN(cout, "BasicSet: choose b  = ", b);
+        DEBOUTLN(cout, "BasicSet: it's rank = ", cb);
         BS=Union(CFList(b),BS);//BS.append( b );
         if ( rank( b ) == 0 )
@@ -65 +71 @@
 }
 
- int
- checkok( const CFList & PS, CFList & FS2){
-   CanonicalForm elem;
-
-   for ( CFListIterator i=PS; i.hasItem(); i++){
-     elem= i.getItem();
-     for (CFListIterator j=FS2; j.hasItem(); j++){
-       if (elem == j.getItem()){
+int
+checkok( const CFList & PS, CFList & FS2){
+  CanonicalForm elem;
+
+  for ( CFListIterator i=PS; i.hasItem(); i++){
+    elem= i.getItem();
+    for (CFListIterator j=FS2; j.hasItem(); j++){
+      if (elem == j.getItem()){
         //      FS2= Difference(FS2,CFList(elem));
         return 0;
-       }
-     }
-   }
-   return 1;
- }
+      }
+    }
+  }
+  return 1;
+}
 
 #ifdef MCHARSETNDEBUG
@@ -147 +153 @@
 }
 
+
+CFList
+mcharset( const CFList &PS, PremForm & Remembern ){
+  CFList cs= MCharSetN(PS, Remembern );
+  CFList rs= remsetb(Difference(PS,cs),cs);
+
+  DEBOUTLN(cout, "mcharset: cs= ", cs);
+  DEBOUTLN(cout, "mcharset: rs= ", rs);
+  if ( rs.length() > 0 )
+    cs= mcharset(Union(PS,Union(cs,rs)), Remembern);
+  return cs;
+}
+
 // the "original" extended characteristic set
 CFList
@@ -311 +330 @@
 }
 
+static int
+choosefrom(){
+int choice;
+    cout << "choose from qhi! ->";
+    cin >> choice;
+return choice;
+}
+
 static ListCFList
 msort( const ListCFList & list_to_sort ){
@@ -333 +360 @@
 
 ListCFList
-IrrCharSeries( const CFList &PS ){
+IrrCharSeries( const CFList &PS, int opt ){
   CanonicalForm reducible,reducible2;
   CFList qs,cs,factorset,is,ts;
   ListCFList pi,ppi,qqi,qsi,iss,qhi= ListCFList(PS);
-  int nr_of_iteration=0,ts2,highestlevel=0;
+  int nr_of_iteration=0,ts2,highestlevel=0; 
+#ifdef EXPERIMENTAL
+  int choice=1;;
+#endif
 
   DEBOUTMSG(cout, rcsid);
+//  cout << getCharacteristic() << endl;
   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;
+//  for ( CFListIterator Ps=PS; Ps.hasItem(); Ps++ )
+//    cout << Ps.getItem() << ", " ;//<< endl;
+//  cout <<  endl;
   while ( ! qhi.isEmpty() ) {
     qhi=sort(qhi);
     DEBOUTLN(cout, "qhi is: ", qhi);
+#ifdef EXPERIMENTAL
+    choice=choosefrom();
+    cout <<"/n Choose " << choice << endl;
+    qs= getItemNr(choice, qhi);
+#else
     qs=qhi.getFirst();
+#endif
     DEBOUTLN(cout, "qs  is: ", qs);
     DEBOUTLN(cout, "ppi is: ", ppi);
@@ -454 +496 @@
   }
   if ( ! qsi.isEmpty() ){ 
-    return contract( qsi ); 
+    DEBOUTLN(cout, "qsi before contract= ", qsi);
+    if ( opt == 0 ){
+       return contract( qsi ); 
+    }
+    else { return qsi; }
   }
   else{ return ListCFList() ; }
@@ -474 +520 @@
   CFList ts,as;
   CanonicalForm elem;
-  int ind=1,nr=0;
+  int ind=1,nr=0, success=-1;
+  CFListIterator i;
 
   ja = 0;
   DEBOUTLN(cout, "irras: called with: AS= ", AS);
-  for ( CFListIterator i=AS; i.hasItem(); i++ ){
+  for ( i=AS; i.hasItem(); i++ ){
     elem = i.getItem();
     nr += 1;
     DEBOUT(cout, "irras: factoring: ", elem);
-    qs = Factorize(elem);
-
+    if ( degree(elem) > 1 ) // linear poly's are irreduzible
+      qs = Factorize(elem);
+    else{
+      qs=(CFFactor(elem,1));
+      qs.insert(CFFactor(CanonicalForm(1),1));
+    }
+    DEBOUTLN(cout, "  = ", qs);
     // INTERRUPTHANDLER
     if ( interrupt_handle() ) return CFList() ;
     // INTERRUPTHANDLER
-
     qs.removeFirst();
-    DEBOUTLN(cout, "  = ", qs);
-    //    if ( num(qs.getFirst().factor() / LC(qs.getFirst().factor())) !=
-    //         num(elem / LC(elem))){
     if ( (qs.length() >= 2 ) || (qs.getFirst().exp() > 1)){
       DEBOUTLN(cout, "irras: Setting ind=0, ja= ", nr);
       ja=nr; ind=0; reducible= elem; 
-      // return(qs); // ist das nicht genauso gut?
       break;
     }
-    else{ as.append(elem) ; }
-  }
-  AS=as; // warum das?
-  if ( (ind == 1) && ( AS.length() > 1) ){
-    if ( irreducible(AS) ) ja = 0;
+    //    else{ as.append(elem) ; }
+  }
+  //  cout << "ind= " << ind << endl;
+  if ( (ind == 1) ){ //&& ( as.length() > 1) ){
+    if ( irreducible(AS) ){ // as quasilinear? => irreducible!
+      ja = 0; 
+      DEBOUTLN(cout, "as is irreducible. as= ", AS);
+    }
     else {
-#ifdef HAVE_SINGULAR
-      extern void WerrorS(char *);
-      WerrorS("libfac: Factorization over algebraic function field required!");
-#else 
-      cerr << "Factorization over algebraic function field required!" << endl;
-#endif
-      ja = -1;
+//#ifdef HAVE_SINGULAR
+//      extern void WerrorS(char *);
+//      WerrorS("libfac: Factoring over algebraic function field!");
+//#else 
+//      cerr << "libfac: Factoring over algebraic function field!" << endl;
+//#endif
+      i=AS;
+      for ( nr=1; nr< AS.length(); nr++){
+        as.append(i.getItem());
+        i++;
+        if ( degree(i.getItem()) > 1 ){// search for a non linear elem
+          elem=i.getItem();
+//        cout << "f=  " << elem << endl;
+//        cout << "as= " << as << endl;
+          qs= newfactoras(elem,as,success);
+//        cout << "irras:newfactoras    qs= " << qs << endl;
+//        qs= factoras(elem,as,success);
+//        cout << "irras:factoras qs= " << qs << endl;
+          if ( qs.length() > 1 || qs.getFirst().exp() > 1 ){ //found elem is reducible
+            reducible=elem;
+            ja=nr+1;
+            break;
+          }
+        }
+      }
     }
   }

libfac/charset/charset.h

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: charset.h,v 1.2 1997-06-09 15:55:53 Singular Exp $
+// $Id: charset.h,v 1.3 1997-09-12 07:19:41 Singular Exp $
 ////////////////////////////////////////////////////////////
 
@@ -13 +13 @@
 CFList     BasicSet( const CFList &PS );
 CFList     CharSet( const CFList &PS );
+CFList     mcharset( const CFList &PS, PremForm & Remembern );
+int        checkok( const CFList & PS, CFList & FS2);
 /*BEGINPUBLIC*/
 CFList     MCharSetN( const CFList &PS, PremForm & Remembern );
-ListCFList IrrCharSeries( const CFList &PS );
+ListCFList IrrCharSeries( const CFList &PS, int opt=0 );
 /*ENDPUBLIC*/
 

libfac/charset/csutil.cc

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-static char * rcsid = "$Id: csutil.cc,v 1.2 1997-06-09 15:55:54 Singular Exp $";
+static char * rcsid = "$Id: csutil.cc,v 1.3 1997-09-12 07:19:41 Singular Exp $";
 /////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -10 +10 @@
 #include <Factor.h>
 #include <SqrFree.h>
+#include <helpstuff.h>
+#include <homogfactor.h>
 // Charset - Includes
 #include "csutil.h"
 
 static bool
-lowerRank ( const CanonicalForm & f, const CanonicalForm & g )
+lowerRank ( const CanonicalForm & f, const CanonicalForm & g, int & ind )
 {
   int df, dg;
   Variable vf = f.mvar(), vg = g.mvar();
     
-  if ( f.inCoeffDomain() ) return true;//( vg > vf );
-  else 
-    if ( g.inCoeffDomain() ) return false;
-    else 
-      if ( vf < vg ) return true;
-      else 
-        if ( vf == vg ) {
-          df = degree( f ); dg = degree( g );
-          if ( df < dg ) return true;
-          else 
-            if ( df == dg ) return lowerRank( LC( f ), LC( g ) );
-            else return false;
-        }
+  if ( f.inCoeffDomain() ) {
+    if ( g.inCoeffDomain() ) ind= 1; 
+    return true;//( vg > vf );
+  }
+  else if ( g.inCoeffDomain() ) return false;
+  else if ( vf < vg ) return true;
+  else if ( vf == vg ) {
+    df = degree( f ); dg = degree( g );
+    if ( df < dg ) return true;
+    else if ( df == dg ) return lowerRank( LC( f ), LC( g ) , ind);
+    else return false;
+  }
   return false;
 }
@@ -40 +41 @@
   CFListIterator i = F;
   CanonicalForm f;
+  int ind=0;
   if ( ! i.hasItem() )  return f;
   f = i.getItem(); ++i;
   while ( i.hasItem() ) {
-    if ( lowerRank( i.getItem(), f ) ) f = i.getItem();
+    //cout << "comparing " << f << "  and " << i.getItem() 
+    // << " == " << lowerRank( i.getItem(), f, ind ) << endl;
+    if ( lowerRank( i.getItem(), f, ind ) ) {
+      if ( ind ){
+        CFList Itemlist= get_Terms(i.getItem());
+        CFList Flist= get_Terms(f);
+        
+        // Have to further compare number of terms!
+        //cout << "compare terms! f= " << Flist.length() << "  item= " 
+        //     << Itemlist.length() <<endl;
+        if ( Itemlist.length() < Flist.length()) f = i.getItem();
+        ind=0;
+      }
+      else{
+        f = i.getItem();
+      }
+    }
     ++i;
   }
@@ -85 +103 @@
 CanonicalForm
 Prem ( const CanonicalForm &f, const CanonicalForm &g ){
-  CanonicalForm ff, gg, cg, l, test, lu, lv, t;
+  CanonicalForm ff, gg, l, test, lu, lv, t, retvalue;
   int df, dg;
   bool reord;
   Variable vf, vg, v;
-  
+
   if ( (vf = f.mvar()) < (vg = g.mvar()) ) return f;
   else {
@@ -103 +121 @@
       reord=true;
     }
-    cg = LC( gg, v );
     dg = degree( gg, v );
     df = degree( ff, v );
@@ -111 +128 @@
       // cout << "Start gcd..." << endl;
       test = gcd(l,LC(ff));
-      // cout << "End gcd..." << endl;
+      //cout << "gcd(" << l << "," << LC(ff) << ")= " << test << endl;
       lu = l/test; lv = LC(ff)/test;
       t = power(v,df-dg) * gg * lv;
@@ -119 +136 @@
       df = degree( ff, v );
     }
-    if ( reord ) return swapvar( ff, vg, v );
-    else return ff;
-  }
+    if ( reord ) {
+     retvalue= swapvar( ff, vg, v );
+    }
+    else {
+     retvalue= ff;
+    }
+    return retvalue;
+  }
+}
+
+static CanonicalForm
+Sprem ( const CanonicalForm &f, const CanonicalForm &g, CanonicalForm & m, CanonicalForm & q ){
+  CanonicalForm ff, gg, l, test, retvalue;
+  int df, dg,n;
+  bool reord;
+  Variable vf, vg, v;
+
+  if ( (vf = f.mvar()) < (vg = g.mvar()) ) { 
+    m=CanonicalForm(0); q=CanonicalForm(0); 
+    return f;
+  }
+  else {
+    if ( vf == vg ) {
+      ff = f; gg = g;
+      reord = false;
+      v = vg; // == x
+    }
+    else { 
+      v = Variable(level(f.mvar()) + 1);
+      ff = swapvar(f,vg,v); // == r
+      gg = swapvar(g,vg,v); // == v
+      reord=true;
+    }
+    dg = degree( gg, v ); // == dv 
+    df = degree( ff, v ); // == dr
+    if (dg <= df) {l=LC(gg); gg = gg -LC(gg)*power(v,dg);}
+    else { l = 1; }
+    n= 0;
+    while ( ( dg <= df  ) && ( ff != ff.genZero()) ){
+      test= power(v,df-dg) * gg * LC(ff);
+      if ( df == 0 ){ff= ff.genZero();}
+      else {ff= ff - LC(ff)*power(v,df);}
+      ff = l*ff-test;
+      df= degree(ff,v);
+      n++;
+    }
+    if ( reord ) {
+     retvalue= swapvar( ff, vg, v );
+    }
+    else {
+     retvalue= ff;
+    }
+    m= power(l,n);
+    if ( divides(g,m*f-retvalue) )
+      q= (m*f-retvalue)/g;
+    else {
+      q= CanonicalForm(0);
+    }
+    return retvalue;
+  }
+}
+
+CanonicalForm
+divide( const CanonicalForm & ff, const CanonicalForm & f, const CFList & as){
+  CanonicalForm r,m,q;
+
+  r= Sprem(ff,f,m,q);
+  //cout << "r= " << r << "  , m= " << m << "  , q= " << q << endl;
+  r= Prem(q,as);
+  //cout << "r= " << r << endl;
+  return r;
+}
+
+static CanonicalForm
+myfitting( const CanonicalForm &f ){
+ CanonicalForm rem=f;
+
+ if ( rem!=0 ){
+   if ( getCharacteristic() > 0 )
+     return num((rem/lc(rem)));
+   else{
+     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;
+     temp= common_den(temp/lc(temp))*(temp/lc(temp));
+     Off(SW_RATIONAL);
+     rem= mapinto(temp);
+     return rem;
+   }
+ }
+ else
+   return rem;
 }
 
@@ -131 +240 @@
 //cout << "   PREM: Prem(" << rem << "," ;
     rem = Prem( rem, i.getItem() );
-//cout << i.getItem() << ")  = " << rem << endl;
-  }
-  if ( rem!=0 )
-   return num(rem/lc(rem));
-  else
-   return rem;
+//cout << "   PREM: Prem(" << rem << "," << i.getItem() << ")  = " << rem << endl;
+  }
+  return myfitting(rem);
 }
 
@@ -142 +248 @@
 Prem( const CFList &AS, const CFList &L ){
   CFList Output;
+
   for ( CFListIterator i=AS; i.hasItem(); i++ )
     Output = Union(CFList(Prem(i.getItem(),L)), Output);
+
   return Output;
+}
+
+static CanonicalForm
+premasb( const CanonicalForm & f, const CFList & as){
+  CanonicalForm remd=f;
+  CFList AS=as;
+
+  if ( as.length() > 1 ){
+    AS.removeFirst(); // get rid of first elem
+    CanonicalForm elem;
+    while ( ! AS.isEmpty() ){ // thats true for at least the first iteration
+      elem= AS.getLast();
+      remd= Prem(remd,elem);
+      AS.removeLast();
+    }
+  }
+  CanonicalForm a,b;
+  if ( mydivremt(remd, as.getFirst(), a,b )){ remd= remd.genZero();}
+  else { remd= Prem(remd, as.getFirst()); }
+
+  return remd;
+}
+
+CFList
+remsetb( const CFList & ps, const CFList & as){
+  CFList output;
+  CanonicalForm elem;
+  for (CFListIterator i=ps; i.hasItem(); i++){
+    elem= premasb(i.getItem(),as);
+    if ( elem != elem.genZero() ) output.append(elem);
+  }
+  return output;
 }
 
@@ -208 +348 @@
     testlist.append(CanonicalForm(Variable(J)));
   }
+  
+  //  testlist = Union(Remembern.FS1, testlist); // add candidates
 
   // remove already removed factors
@@ -213 +355 @@
     testelem = j.getItem();
     while ( 1 ){
-      test = divremt(r,testelem,a,b);
+      test = mydivremt(r,testelem,a,b);
       if ( test && b == r.genZero() ) r = a;
       else break;
     }
   }
-  
+
   // Let's look if we have other canditates to remove
   for ( j = testlist ; j.hasItem(); j++ ){
     testelem = j.getItem();
+//    if ( testelem != r && testelem != r.mvar() ){
     if ( testelem != r ){
       while ( 1 ){
         test = divremt(r,testelem,a,b);
-      test = divremt(r,testelem,a,b);
-      if ( test && b == r.genZero() ) r = a;
         if ( test && b == r.genZero() ){
-            Remembern.FS2= Union(Remembern.FS2, CFList(testelem));
-              r = a;
-              if ( r == 1 ) break;
+          Remembern.FS2= Union(Remembern.FS2, CFList(testelem));
+          r = a;
+          if ( r == 1 ) break;
         }
         else break;
@@ -236 +377 @@
     }
   }
+  //  cout << "Remembern.FS1 = " << Remembern.FS1 << endl;
+  //  cout << "Remembern.FS2 = " << Remembern.FS2 << endl;
+  //  Remembern.FS1 = Difference(Remembern.FS1, Remembern.FS2);
+  //  cout << "  New Remembern.FS1 = " << Remembern.FS1 << endl;
 }
 
@@ -253 +398 @@
       elem = j.getItem().factor();
       if ( getNumVars(elem) > 0 )
-        qs= Union(qs, CFList(num(elem/lc(elem))));
+        qs= Union(qs, CFList(myfitting(elem)));
     }
   }
@@ -267 +412 @@
   else { 
     leadcoeff = LC(f,lvar(f));
-    if ( leadcoeff != 0 ) 
-      return num(leadcoeff/lc(leadcoeff));
-    else return leadcoeff;
+    //    if ( leadcoeff != 0 ) 
+    return myfitting(leadcoeff); //num(leadcoeff/lc(leadcoeff));
+    //    else return leadcoeff;
   }
 }
@@ -352 +497 @@
 //CF pfactor( ..... ) 
 
-//////////////////////////////////////////
-// for IrrCharSeries
+// //////////////////////////////////////////
+// // for IrrCharSeries
 
 #ifdef IRRCHARSERIESDEBUG

libfac/charset/csutil.h

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: csutil.h,v 1.2 1997-06-09 15:55:55 Singular Exp $
+// $Id: csutil.h,v 1.3 1997-09-12 07:19:42 Singular Exp $
 ////////////////////////////////////////////////////////////
 
@@ -54 +54 @@
 CFList         Prem( const CFList &AS, const CFList &L );
 /*ENDPUBLIC*/
+CanonicalForm  divide( const CanonicalForm & ff, const CanonicalForm & f, const CFList & as);
+CFList         remsetb( const CFList & ps, const CFList & as);
 CanonicalForm  lowestRank( const CFList & F );
 
@@ -64 +66 @@
 int            irreducible( const CFList & AS);
 CFList         select( const ListCFList & PS);
-void select( const ListCFList & ppi, int length, ListCFList & ppi1, ListCFList & ppi2);
-bool same( const CFList &A, const CFList &B );
-bool member( const CFList & cs, const ListCFList & pi );
+void           select( const ListCFList & ppi, int length, ListCFList & ppi1, 
+                       ListCFList & ppi2);
+bool           same( const CFList &A, const CFList &B );
+bool           member( const CFList & cs, const ListCFList & pi );
 bool           subset( const CFList &PS, const CFList &CS );
-ListCFList MyUnion( const ListCFList & a, const ListCFList &b );
-ListCFList MyDifference( const ListCFList & a, const CFList &b);
-ListCFList Minus( const ListCFList & a, const ListCFList &b);
+ListCFList     MyUnion( const ListCFList & a, const ListCFList &b );
+ListCFList     MyDifference( const ListCFList & a, const CFList &b);
+ListCFList     Minus( const ListCFList & a, const ListCFList &b);
 #endif /* INCL_CSUTIL_H */
 

libfac/charset/debug.cc

@@ -1 +1 @@
 /* Copyright 1997 Michael Messollen. All rights reserved. */
 ////////////////////////////////////////////////////////////
-// static char * rcsid = "$Id: debug.cc,v 1.1.1.1 1997-09-11 10:58:22 Singular Exp $ ";
+// static char * rcsid = "$Id: debug.cc,v 1.2 1997-09-12 07:19:43 Singular Exp $ ";
 ////////////////////////////////////////////////////////////
 static int deb_level;

libfac/charset/reorder.cc

@@ -12 +12 @@
 /////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-static char * rcsid = "$Id: reorder.cc,v 1.2 1997-06-09 15:55:56 Singular Exp $";
+static char * rcsid = "$Id: reorder.cc,v 1.3 1997-09-12 07:19:44 Singular Exp $";
 ////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -18 +18 @@
 // Factor - Includes
 #include <tmpl_inst.h>
+#include "homogfactor.h"
 // Charset - Includes
-#include "homogfactor.h"
+
+// some CC's need this:
+#include "reorder.h"
 
 #ifdef REORDERDEBUG
@@ -349 +352 @@
 }
 
+static CFFList
+swapvar( const CFFList & PS, const Variable & x, const Variable & y){
+  CFFList ps;
+
+  for (CFFListIterator i= PS; i.hasItem(); i++)
+    ps.append(CFFactor(swapvar(i.getItem().factor(),x,y),i.getItem().exp()));
+  return ps;
+}
+
 // a library function: we reorganize the global variable ordering
 CFList
@@ -368 +380 @@
 }
 
+CFFList
+reorder( const Varlist & betterorder, const CFFList & PS){
+  int i=1, n = betterorder.length();
+  Intarray v(1,n);
+  CFFList ps=PS;
+
+  //initalize:
+  for (VarlistIterator j = betterorder; j.hasItem(); j++){
+    v[i]= level(j.getItem()); i++;
+  }
+  DEBOUTLN(cout, "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); 
+  return ps;
+}
+
 ListCFList
 reorder(const Varlist & betterorder, const ListCFList & Q){

libfac/charset/reorder.h

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: reorder.h,v 1.2 1997-06-09 15:55:56 Singular Exp $
+// $Id: reorder.h,v 1.3 1997-09-12 07:19:45 Singular Exp $
 ////////////////////////////////////////////////////////////
 #ifndef INCL_REORDER_H
@@ -38 +38 @@
 // 
 CFList reorder( const Varlist & betterorder, const CFList & PS);
+CFFList reorder( const Varlist & betterorder, const CFFList & PS);
 ListCFList reorder(const Varlist & betterorder, const ListCFList & Q);
 /*ENDPUBLIC*/

libfac/configure

@@ -521 +521 @@
 libfac_name="\"Factorization and characteristic sets library\""
 
-libfac_version="0.2.4"
-
-libfac_date="\"May 30 1997\""
+libfac_version="0.3.0"
+
+libfac_date="\"Sep 11 1997\""
 
 libfac_author="\"M. Messollen\""
@@ -556 +556 @@
 if test "$with_Singular" = yes; then
   cat >> confdefs.h <<\EOF
-#define HAVE_SINGULAR 1
+#define SINGULAR 1
+EOF
+
+  cat >> confdefs.h <<\EOF
+#define NOSTREAMIO 1
 EOF
 
@@ -586 +590 @@
 LDFLAGS="-L. ${LDFLAGS}"
 
-if test "$with_debug" = yes; then
-  CXXFLAGS="-g"
-else
-  CXXFLAGS="-O"
-  cat >> confdefs.h <<\EOF
+if test "${CXXFLAGS+set}" != set; then
+  ac_cxxflags_set=no
+  if test "$with_debug" = yes; then
+    CXXFLAGS="-g"
+  else
+    CXXFLAGS="-O"
+    cat >> confdefs.h <<\EOF
 #define NDEBUG 1
 EOF
-  
+
+  fi  
 fi
 
@@ -645 +652 @@
 #endif
 EOF
-if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:648: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:655: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
   ac_cv_prog_gxx=yes
 else
@@ -694 +701 @@
   CXXCPP="${CXX-g++} -E"
   cat > conftest.$ac_ext <<EOF
-#line 697 "configure"
+#line 704 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:702: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:709: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out`
 if test -z "$ac_err"; then
@@ -808 +815 @@
 else
   cat > conftest.$ac_ext <<EOF
-#line 811 "configure"
+#line 818 "configure"
 #include "confdefs.h"
 #include <factory.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:816: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:823: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out`
 if test -z "$ac_err"; then
@@ -841 +848 @@
 else
   cat > conftest.$ac_ext <<EOF
-#line 844 "configure"
+#line 851 "configure"
 #include "confdefs.h"
 
@@ -891 +898 @@
 ; return 0; }
 EOF
-if { (eval echo configure:894: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:901: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_const=yes
@@ -917 +924 @@
 for ac_kw in inline __inline__ __inline; do
   cat > conftest.$ac_ext <<EOF
-#line 920 "configure"
+#line 927 "configure"
 #include "confdefs.h"
 
@@ -925 +932 @@
 ; return 0; }
 EOF
-if { (eval echo configure:928: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:935: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_inline=$ac_kw; break
@@ -950 +957 @@
 
 if test ${GXX} = yes; then
-  if test "$with_debug" = yes; then
-     CXXFLAGS="-O -g"
-  else
-     CXXFLAGS="-O3 "
+  if test "$ac_cxxflags_set" = no; then
+    if test "$with_debug" = yes; then
+       CXXFLAGS="-O -g"
+    else
+       CXXFLAGS="-O3 "
+    fi
   fi
   CXXTEMPLFLAGS="-fno-implicit-templates"

libfac/configure.in

@@ -15 +15 @@
 libfac_name="\"Factorization and characteristic sets library\""
 AC_SUBST(libfac_version)
-libfac_version="0.2.4"
+libfac_version="0.3.0"
 AC_SUBST(libfac_date)
-libfac_date="\"May 30 1997\""
+libfac_date="\"Sep 11 1997\""
 AC_SUBST(libfac_author)
 libfac_author="\"M. Messollen\""
@@ -46 +46 @@
 
 if test "$with_Singular" = yes; then
-  AC_DEFINE(HAVE_SINGULAR)
+  AC_DEFINE(SINGULAR)
+  AC_DEFINE(NOSTREAMIO)
   if test "$with_debug" = yes; then
      targetname="libsingfac-g"
@@ -77 +78 @@
 LDFLAGS="-L. ${LDFLAGS}"
 
-if test "$with_debug" = yes; then
-  CXXFLAGS="-g"
-else
-  CXXFLAGS="-O"
-  AC_DEFINE(NDEBUG)  
+if test "${CXXFLAGS+set}" != set; then
+  ac_cxxflags_set=no
+  if test "$with_debug" = yes; then
+    CXXFLAGS="-g"
+  else
+    CXXFLAGS="-O"
+    AC_DEFINE(NDEBUG)
+  fi  
 fi
 
@@ -126 +130 @@
 dnl
 if test ${GXX} = yes; then
-  if test "$with_debug" = yes; then
-     CXXFLAGS="-O -g"
-  else
-     CXXFLAGS="-O3 "
+  if test "$ac_cxxflags_set" = no; then
+    if test "$with_debug" = yes; then
+       CXXFLAGS="-O -g"
+    else
+       CXXFLAGS="-O3 "
+    fi
   fi
   CXXTEMPLFLAGS="-fno-implicit-templates"

libfac/factor.h

@@ -20 +20 @@
 
 //// Note: InternalSqrFree does only the work needed for factorization.
-// int SqrFreeTest( const CanonicalForm & r, int opt=1) ;
 // CFFList SqrFree( const CanonicalForm & f ) ;
-CFFList InternalSqrFree( const CanonicalForm & f ) ;
 
 typedef List<CFList> ListCFList;
@@ -50 +48 @@
 CFList         Prem( const CFList &AS, const CFList &L );
 CFList     MCharSetN( const CFList &PS, PremForm & Remembern );
-ListCFList IrrCharSeries( const CFList &PS );
+ListCFList IrrCharSeries( const CFList &PS, int opt=0 );
 
 // the next three give you a heuristically optimal reorderd list of the
@@ -79 +77 @@
 // 
 CFList reorder( const Varlist & betterorder, const CFList & PS);
+CFFList reorder( const Varlist & betterorder, const CFFList & PS);
 ListCFList reorder(const Varlist & betterorder, const ListCFList & Q);
 
+
 #endif /* FACTOR_H */

libfac/factor/Factor.cc

@@ -1 +1 @@
 /* Copyright 1996 Michael Messollen. All rights reserved. */
 ///////////////////////////////////////////////////////////////////////////////
-static char * rcsid = "$Id: Factor.cc,v 1.2 1997-06-09 15:55:58 Singular Exp $ ";
+static char * rcsid = "$Id: Factor.cc,v 1.3 1997-09-12 07:19:46 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.";
 ///////////////////////////////////////////////////////////////////////////////
@@ -14 +14 @@
 #include "homogfactor.h"
 #include "interrupt.h"
+// some CC's need this:
+#include "Factor.h"
+
+#ifdef SINGULAR
+#  define HAVE_SINGULAR
+#endif
 
 #ifdef FACTORDEBUG
@@ -30 +36 @@
 TIMING_DEFINE_PRINT(truefactor_time);
 
-extern int libfac_interruptflag;
-#ifdef HAVE_SINGULAR
-extern void WerrorS(char *);
-#endif
 
 ///////////////////////////////////////////////////////////////
@@ -139 +141 @@
 // Return the list of factors.                               //
 ///////////////////////////////////////////////////////////////
-CFFList 
+static CFFList 
 not_monic( const CFFList & TheList, const CanonicalForm & ltt, const CanonicalForm & F, int levelF){
   CFFList Returnlist,IntermediateList;
@@ -210 +212 @@
           else { 
 #ifdef HAVE_SINGULAR
+            extern void WerrorS(char *);
             WerrorS("libfac: ERROR: not_monic1: case lt is a sum.");
 #else 
@@ -227 +230 @@
         else {
 #ifdef HAVE_SINGULAR
+          extern void WerrorS(char *);
           WerrorS("libfac: ERROR: not_monic2: case lt is a sum.");
 #else 
@@ -308 +312 @@
 // field getCharacteristik()^Extension.                      //
 ///////////////////////////////////////////////////////////////
-static CanonicalForm
+CanonicalForm
 generate_mipo( int degree_of_Extension , const Variable & Extension ){
   FFRandom gen; 
@@ -316 +320 @@
     else { 
 #ifdef HAVE_SINGULAR
+    extern void WerrorS(char *);
     WerrorS("libfac: evaluate: Extension not inFF() or inGF() !");
 #else 
@@ -387 +392 @@
     else {
 #ifdef HAVE_SINGULAR
+      extern void WerrorS(char *);
       WerrorS("libfac: spezializePoly ERROR: Working over given extension-field not yet implemented!");
 #else 
@@ -421 +427 @@
   else { 
 #ifdef HAVE_SINGULAR
+    extern void WerrorS(char *);
     WerrorS("libfac: evaluate: Extension not inFF() or inGF() !");
 #else
@@ -428 +435 @@
     FFRandom gen; }}
   REvaluation k(1,n,gen);
+  k.nextpoint();
   for ( int i=1; i<=maxtries ; i++){
-    //    k.nextpoint();
+    // k.nextpoint();
     SFormList Substitutionlist;
     for ( int j=1; j<=n; j++ )
@@ -496 +504 @@
 ///////////////////////////////////////////////////////////////
 CFFList 
-Factorized( const CanonicalForm & F, const Variable & alpha, int Mainvar=0){
+Factorized( const CanonicalForm & F, const Variable & alpha, int Mainvar){
   CanonicalForm f,lt,ff,ffuni;
   Variable Extension=alpha;
@@ -599 +607 @@
     if (success == 0 ){ // No spezialisation could be found
 #ifdef HAVE_SINGULAR
+      extern void WerrorS(char *);
       WerrorS("libfac: Factorize: ERROR: Not able to find a valid specialization!");    
 #else
@@ -684 +693 @@
 ///////////////////////////////////////////////////////////////
 CFFList 
-Factorize( const CanonicalForm & F, int is_SqrFree=0  ){
+Factorize( const CanonicalForm & F, int is_SqrFree ){
   CFFList Outputlist,SqrFreeList,Intermediatelist,Outputlist2;
   ListIterator<CFFactor> i,j;
@@ -700 +709 @@
   if ( getCharacteristic() == 0 ) { // char == 0
     TIMING_START(factorize_time);
+    //cout << "Factoring in char=0 of " << F << " = " << Outputlist << endl;
     Outputlist= factorize(F);
-    //  cout << "Factoring in char=0 of " << F << " = " << Outputlist << endl;
     // Factorization in char=0 doesn't sometimes return at least two elements!!!
     if ( getNumVars(Outputlist.getFirst().factor()) != 0 ) 

libfac/factor/Factor.h

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: Factor.h,v 1.2 1997-06-09 15:55:59 Singular Exp $
+// $Id: Factor.h,v 1.3 1997-09-12 07:19:47 Singular Exp $
 ///////////////////////////////////////////////////////////////////////////////
 #ifndef FACTOR_H
 #define FACTOR_H
+CanonicalForm generate_mipo( int degree_of_Extension , const Variable & Extension );
 CFFList Factorized( const CanonicalForm & F, const Variable & alpha, int Mainvar=0);
 /*BEGINPUBLIC*/

libfac/factor/MVMultiHensel.cc

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// static char * rcsid = "$Id: MVMultiHensel.cc,v 1.2 1997-06-09 15:56:00 Singular Exp $";
+// static char * rcsid = "$Id: MVMultiHensel.cc,v 1.3 1997-09-12 07:19:48 Singular Exp $";
 ///////////////////////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -9 +9 @@
 #include "tmpl_inst.h"
 #include "helpstuff.h"
+// some CC's need this:
+#include "MVMultiHensel.h"
+
+#ifdef SINGULAR
+#  define HAVE_SINGULAR
+#endif
 
 #ifdef HENSELDEBUG

libfac/factor/MVMultiHensel.h

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: MVMultiHensel.h,v 1.2 1997-06-09 15:56:00 Singular Exp $
+// $Id: MVMultiHensel.h,v 1.3 1997-09-12 07:19:48 Singular Exp $
 /////////////////////////////////////////////////////////////
 #ifndef MULTIHENSEL_H

libfac/factor/SqrFree.cc

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-static char * rcsid = "$Id: SqrFree.cc,v 1.2 1997-06-09 15:56:02 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.";
+static char * rcsid = "$Id: SqrFree.cc,v 1.3 1997-09-12 07:19: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.";
 ///////////////////////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -10 +10 @@
 #include "tmpl_inst.h"
 #include "helpstuff.h"
+// some CC's need this:
+#include "SqrFree.h"
+
+#ifdef SINGULAR
+#  define HAVE_SINGULAR
+#endif
 
 #ifdef SQRFREEDEBUG
@@ -22 +28 @@
 TIMING_DEFINE_PRINT(gcd_time);
 
-#ifdef HAVE_SINGULAR
-extern void WerrorS(char *);
-#endif  
-
-// forward declaration:
-CFFList SqrFree( const CanonicalForm & r );
-CFFList InternalSqrFree( const CanonicalForm & r );
 
 static inline CFFactor 
@@ -52 +51 @@
 PthRoot( const CanonicalForm & f ){
   CanonicalForm RES, R = f;
-  int n= getNumVars(R), p= getCharacteristic();
+  int n= max(level(R),getNumVars(R)), p= getCharacteristic();
   
   if (n==0){ // constant
@@ -78 +77 @@
 ///////////////////////////////////////////////////////////////
 int
-SqrFreeTest( const CanonicalForm & r, int opt=1){
+SqrFreeTest( const CanonicalForm & r, int opt){
   CanonicalForm f=r, g;
   int n=level(f);
@@ -126 +125 @@
   }
 #ifdef HAVE_SINGULAR
+  extern void WerrorS(char *);
   WerrorS("libfac: ERROR: SqrFreeTest: we should never fall trough here!");
 #else
@@ -197 +197 @@
       g=swapvar(f,k,n) ; g = g.deriv();
       if ( ! g.isZero() ){ // can`t be Pth root
-        CFFList Outputlist2= SqrFreed(swapvar(f,k,n));
+        CFFList Outputlist2= SqrFreed(swapvar(f,k,n)); 
         for (CFFListIterator inter=Outputlist2; inter.hasItem(); inter++){
           Outputlist= myappend(Outputlist, CFFactor(swapvar(inter.getItem().factor(),k,n), inter.getItem().exp()));
@@ -252 +252 @@
   }
 #ifdef HAVE_SINGULAR
+  extern void WerrorS(char *);
   WerrorS("libfac: ERROR: SqrFreed: we should never fall trough here!");
 #else

libfac/factor/SqrFree.h

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: SqrFree.h,v 1.2 1997-06-09 15:56:03 Singular Exp $
+// $Id: SqrFree.h,v 1.3 1997-09-12 07:19:51 Singular Exp $
 ///////////////////////////////////////////////////////////////////////////////
 #ifndef SQRFREE_H
@@ -8 +8 @@
 
 /*BEGINPUBLIC*/
-// int SqrFreeTest( const CanonicalForm & r, int opt=1) ;
 // CFFList SqrFree( const CanonicalForm & f ) ;
+/*ENDPUBLIC*/
 CFFList InternalSqrFree( const CanonicalForm & f ) ;
-/*ENDPUBLIC*/
-int SqrFreeTest( const CanonicalForm & r, int opt=1) ;
+int     SqrFreeTest( const CanonicalForm & r, int opt=1) ;
 CFFList SqrFree( const CanonicalForm & f ) ;
 #endif /* SQRFREE_H */

libfac/factor/Truefactor.cc

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-//static char * rcsid = "@(#) $Id: Truefactor.cc,v 1.2 1997-06-09 15:56:04 Singular Exp $";
+//static char * rcsid = "@(#) $Id: Truefactor.cc,v 1.3 1997-09-12 07:19:52 Singular Exp $";
 ///////////////////////////////////////////////////////////////////////////////
 // Factory - Includes
@@ -9 +9 @@
 #include "tmpl_inst.h"
 #include "helpstuff.h"
+// some CC's need this:
+#include "Truefactor.h"
+
+#ifdef SINGULAR
+#  define HAVE_SINGULAR
+#endif
 
 #ifdef TRUEFACTORDEBUG
@@ -19 +25 @@
 #include "timing.h"
 
-#ifdef HAVE_SINGULAR
-extern void WerrorS(char *);
-#endif
 ///////////////////////////////////////////////////////////////
 // generate all different k-subsets of the set with n        //
@@ -233 +236 @@
 // Check if poly f is in Fp (returns true) or in Fp(a)       //
 ///////////////////////////////////////////////////////////////
-bool 
+static bool 
 is_in_Fp( const CanonicalForm & f ){
   if ( f.inCoeffDomain() )
@@ -278 +281 @@
     if ( PossibleFactors.length() < n ) { // a little check
 #ifdef HAVE_SINGULAR
+      extern void WerrorS(char *);
       WerrorS("libfac: ERROR: TakeNorms less then two items remaining!");
 #else
@@ -320 +324 @@
       else{ 
 #ifdef HAVE_SINGULAR
+        extern void WerrorS(char *);
         WerrorS("libfac: TakeNorms: somethings wrong with remaining factors!");
 #else

libfac/factor/Truefactor.h

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: Truefactor.h,v 1.2 1997-06-09 15:56:05 Singular Exp $
+// $Id: Truefactor.h,v 1.3 1997-09-12 07:19:53 Singular Exp $
 ///////////////////////////////////////////////////////////////////////////////
 #ifndef TRUEFACTOR_H

libfac/factor/class.cc

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// static char * rcsid = "@(#) $Id: class.cc,v 1.2 1997-06-09 15:56:05 Singular Exp $";
+// static char * rcsid = "@(#) $Id: class.cc,v 1.3 1997-09-12 07:19:53 Singular Exp $";
 ////////////////////////////////////////////////////////////
 
@@ -33 +33 @@
 }
 
+#ifndef NOSTREAMIO
 template <class T>
 void Substitution<T>::print ( ostream& s ) const
@@ -38 +39 @@
         s << "(" << factor() << ")^" << exp();
 }
+#endif
 
 ////////////////////////////////////////////////////////////

libfac/factor/class.h

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: class.h,v 1.3 1997-08-01 10:51:28 Singular Exp $
+// $Id: class.h,v 1.4 1997-09-12 07:19:54 Singular Exp $
 ///////////////////////////////////////////////////////////////////////////////
 #ifndef INCL_CLASS_H
@@ -12 +12 @@
 #include <iostream.h>
 #endif
-
 
 template <class T>
@@ -41 +40 @@
         return os;
     }
-#endif    
+#endif
 };
 
@@ -53 +52 @@
 /*
 $Log: not supported by cvs2svn $
-Revision 1.2  1997/06/09 15:56:06  Singular
-* hannes/michael: libfac 0.2.4
-
 Revision 1.2  1997/04/25 22:21:26  michael
 Version for libfac-0.2.1

libfac/factor/debug.cc

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// static char * rcsid = "$Id: debug.cc,v 1.2 1997-06-09 15:56:07 Singular Exp $ ";
+// static char * rcsid = "$Id: debug.cc,v 1.3 1997-09-12 07:19:55 Singular Exp $ ";
 ////////////////////////////////////////////////////////////
 static int deb_level;

libfac/factor/debug.h

@@ -1 +1 @@
 /* Copyright 1996 Michael Messollen. All rights reserved. */
 ////////////////////////////////////////////////////////////
-// static char * rcsid = "$Id: debug.h,v 1.2 1997-06-09 15:56:08 Singular Exp $" ;
+// static char * rcsid = "$Id: debug.h,v 1.3 1997-09-12 07:19:55 Singular Exp $" ;
 ////////////////////////////////////////////////////////////
 // It is possible to include this file multiple times for different 
@@ -45 +45 @@
 (stream << deb_level_msg, stream.flush())
 #define DEBOUT(stream,msg,object) \
-(stream << msg << object, stream.flush())
+(stream << deb_level_msg << msg << object, stream.flush())
 #define DEBOUTLN(stream,msg,object) \
 (stream << deb_level_msg << msg << object << endl)

libfac/factor/helpstuff.cc

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// static char * rcsid = "$Id: helpstuff.cc,v 1.2 1997-06-09 15:56:08 Singular Exp $";
+// static char * rcsid = "$Id: helpstuff.cc,v 1.3 1997-09-12 07:19:56 Singular Exp $";
 ////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -8 +8 @@
 // Factor - Includes
 #include "tmpl_inst.h"
+// some CC's need this:
+#include "helpstuff.h"
 
 bool 
@@ -18 +20 @@
   else { b=aa; }
   return retvalue;
+}
+
+void
+mydivrem( const CanonicalForm& f, const CanonicalForm& g, CanonicalForm& a, CanonicalForm& b ){
+  bool retvalue;
+  CanonicalForm aa,bb;
+  retvalue = divremt(f,g,a,bb);
+  aa= f-g*a;
+  if ( aa==bb ) { b=bb; }
+  else { b=aa; }
 }
 
@@ -60 +72 @@
 
 int
-Powerup( const int base , const int exp=1){
+Powerup( const int base , const int exp){
   int retvalue=1;
   if ( exp == 0 )  return retvalue ; 

libfac/factor/helpstuff.h

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: helpstuff.h,v 1.2 1997-06-09 15:56:09 Singular Exp $
+// $Id: helpstuff.h,v 1.3 1997-09-12 07:19:57 Singular Exp $
 ////////////////////////////////////////////////////////////
 #ifndef HELPSTUFF_H
 #define HELPSTUFF_H
 bool mydivremt ( const CanonicalForm&, const CanonicalForm&, CanonicalForm&, CanonicalForm& );
+void mydivrem( const CanonicalForm& f, const CanonicalForm& g, CanonicalForm& a, CanonicalForm& b );
 ///////////////////////////////////////////////////////////////
 // Now some procedures used in MVMultiHensel and in Truefactors

libfac/factor/homogfactor.cc

@@ -1 +1 @@
 /* Copyright 1997 Michael Messollen. All rights reserved. */
 ////////////////////////////////////////////////////////////
-// static char * rcsid = "$Id: homogfactor.cc,v 1.2 1997-06-09 15:56:10 Singular Exp $ ";
+// static char * rcsid = "$Id: homogfactor.cc,v 1.3 1997-09-12 07:19:57 Singular Exp $ ";
 ////////////////////////////////////////////////////////////
 // FACTORY - Includes
@@ -8 +8 @@
 #include "tmpl_inst.h"
 #include "Factor.h"
+// some CC's need it:
+#include "homogfactor.h"
 
 #ifdef HFACTORDEBUG

libfac/factor/homogfactor.h

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: homogfactor.h,v 1.2 1997-06-09 15:56:10 Singular Exp $
+// $Id: homogfactor.h,v 1.3 1997-09-12 07:19:58 Singular Exp $
 ///////////////////////////////////////////////////////////////////////////////
 #ifndef HFACTOR_H
 #define HFACTOR_H
-CFList get_Terms( const CanonicalForm & f );
-bool is_homogeneous( const CanonicalForm & f);
-CFFList  HomogFactor( const CanonicalForm & g, const Variable  & minpoly, const int Mainvar );
+CFList  get_Terms( const CanonicalForm & f );
+bool    is_homogeneous( const CanonicalForm & f);
+CFFList HomogFactor( const CanonicalForm & g, const Variable  & minpoly, const int Mainvar );
 #endif /* HFACTOR_H */
 

libfac/factor/timing.h

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// static char * rcsid = "$Id: timing.h,v 1.2 1997-06-09 15:56:12 Singular Exp $";
+// static char * rcsid = "$Id: timing.h,v 1.3 1997-09-12 07:19:59 Singular Exp $";
 ////////////////////////////////////////////////////////////
 // It is possible to include this file multiple times for different 

libfac/factor/tmpl_inst.cc

@@ -2 +2 @@
 ////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: tmpl_inst.cc,v 1.2 1997-06-09 15:56:12 Singular Exp $
+// $Id: tmpl_inst.cc,v 1.3 1997-09-12 07:20:00 Singular Exp $
 ////////////////////////////////////////////////////////////
 
@@ -82 +82 @@
 template class Array<Variable>;
 
+// for database
+#ifdef HAVE_DATABASE
+template class List<CFFList>;
+template class ListIterator<CFFList>;
+#endif /* HAVE_DATABASE */
 ////////////////////////////////////////////////////////////
 /*

libfac/factor/tmpl_inst.h

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: tmpl_inst.h,v 1.2 1997-06-09 15:56:14 Singular Exp $
+// $Id: tmpl_inst.h,v 1.3 1997-09-12 07:20:01 Singular Exp $
 ///////////////////////////////////////////////////////////////////////////////
 #ifndef TMPL_INST_H
@@ -37 +37 @@
 typedef Array<int> Intarray;
 
-typedef Array<CFArray> CCFArray ;
-typedef Array<CCFArray> CCCFArray ;
+#ifdef HAVE_DATABASE
+typedef List<CFFList> ListCFFList;
+typedef ListIterator<CFFList> ListCFFListIterator;
+#endif
+
+//typedef Array<CFArray> CCFArray ;
+//typedef Array<CCFArray> CCCFArray ;
 
 #endif /* TMPL_INST_H */

libfac/factor/version.cc

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: version.cc,v 1.2 1997-06-09 15:56:14 Singular Exp $
+// $Id: version.cc,v 1.3 1997-09-12 07:20:02 Singular Exp $
 static char * rcsid = "@(#) libfac version 0.2.4 [May 29 1997] (C) 1996-97 M. Messollen";
 ///////////////////////////////////////////////////////////////////////////////
 
 char * libfac_name = "Factorization and characteristic sets library";
-char * libfac_version = "0.2.4";
-char * libfac_date = "May 30 1997";
+char * libfac_version = "0.3.0";
+char * libfac_date = "Sep 11 1997";
 char * libfac_author = "M. Messollen";
 

libfac/header.tpl

@@ -26 +26 @@
 .INCLUDE factor/helpstuff.h
 .INCLUDE factor/tmpl_inst.h
+.INCLUDE factor/homogfactor.h
+.INCLUDE factor/debug.h
+.INCLUDE factor/timing.h
 
 ////////////////////////////////////////
@@ -34 +37 @@
 .INCLUDE charset/reorder.h
 
+.INCLUDE charset/algfactor.h
+
 #endif /* FACTOR_H */

libfac/test.cc

@@ -1 @@
-//static char rcsid[] = "$Id: test.cc,v 1.2 1997-06-09 15:55:50 Singular Exp $";
+//static char rcsid[] = "$Id: test.cc,v 1.3 1997-09-12 07:19:34 Singular Exp $";
 ///////////////////////////////////////////////////////////////////////////////
 // Factor - Includes

libfac/testcs.cc

@@ -1 @@
-// $Id: testcs.cc,v 1.1.1.1 1997-09-11 10:58:16 Singular Exp $
+// $Id: testcs.cc,v 1.2 1997-09-12 07:19:35 Singular Exp $
 
 #include <factory.h>