Changeset 14b1e65 in git


Ignore:
Timestamp:
Aug 8, 2001, 1:59:13 PM (23 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '648d28f488f6ff08f5607ff229b9ad9e4a5b93c2')
Children:
456842ed1cd4bb0af35f859e0befe623c3991393
Parents:
c794a95c85e7ae1437369ab150d85b7c4ff17fd0
Message:
*hannes: Dan's NOSTREAMIO changes


git-svn-id: file:///usr/local/Singular/svn/trunk@5572 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
libfac/factor
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • libfac/factor/Factor.cc

    rc794a9 r14b1e65  
    11/* Copyright 1996 Michael Messollen. All rights reserved. */
    22///////////////////////////////////////////////////////////////////////////////
    3 static char * rcsid = "$Id: Factor.cc,v 1.8 2001-08-06 08:32:54 Singular Exp $ ";
     3static char * rcsid = "$Id: Factor.cc,v 1.9 2001-08-08 11:59:12 Singular Exp $ ";
    44static 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.";
    55///////////////////////////////////////////////////////////////////////////////
    66// FACTORY - Includes
    77#include <factory.h>
     8#ifndef NOSTREAMIO
     9#include <iostream.h>
     10#endif
    811// Factor - Includes
    912#include "tmpl_inst.h"
     
    324327    WerrorS("libfac: evaluate: Extension not inFF() or inGF() !");
    325328#else
     329#ifndef NOSTREAMIO
    326330    cerr << "libfac: evaluate: " << Extension << " not inFF() or inGF() !"
    327331         << endl;
     332#endif
    328333#endif
    329334    FFRandom gen;
     
    534539      CFList as(mipo);
    535540      Outputlist = newfactoras( F, as, 1);
    536      #endif 
     541     #endif
    537542      TIMING_END(evaluate_time);
    538543      return Outputlist;
     
    644649      CFList as(mipo);
    645650      UnivariateFactorlist = newfactoras( ffuni, as, 1);
    646      #endif 
     651     #endif
    647652    }
    648653  }
     
    823828/*
    824829$Log: not supported by cvs2svn $
     830Revision 1.8  2001/08/06 08:32:54  Singular
     831* hannes: code cleanup
     832
    825833Revision 1.7  2001/06/21 14:57:05  Singular
    826834*hannes/GP: Factorize, newfactoras, ...
  • libfac/factor/MVMultiHensel.cc

    rc794a9 r14b1e65  
    22///////////////////////////////////////////////////////////////////////////////
    33// emacs edit mode for this file is -*- C++ -*-
    4 // static char * rcsid = "$Id: MVMultiHensel.cc,v 1.4 1997-11-18 16:39:05 Singular Exp $";
     4// static char * rcsid = "$Id: MVMultiHensel.cc,v 1.5 2001-08-08 11:59:12 Singular Exp $";
    55///////////////////////////////////////////////////////////////////////////////
    66// FACTORY - Includes
    77#include <factory.h>
     8#ifndef NOSTREAMIO
     9#include <iostream.h>
     10#endif
    811// Factor - Includes
    912#include "tmpl_inst.h"
     
    4851public:
    4952  inline RememberForm operator=( CanonicalForm & value ){
    50     this->calculated = true; 
     53    this->calculated = true;
    5154    this->poly = value;
    5255    return *this;
     
    5659};
    5760
    58 // Array to remember already calculated values; used for the diophantine 
    59 // equation s*f + t*g = x^i 
     61// Array to remember already calculated values; used for the diophantine
     62// equation s*f + t*g = x^i
    6063class RememberArray {
    6164public:
     
    8790// Returns s and t.                                          //
    8891///////////////////////////////////////////////////////////////
    89 static DiophantForm 
     92static DiophantForm
    9093diophant( int levelU , const CanonicalForm & F1 , const CanonicalForm & F2 , int i , RememberArray & A, RememberArray & B ) {
    9194  DiophantForm Retvalue;
     
    9699  DEBOUT(cout, "  ", F2); DEBOUTLN(cout, "  ", i);
    97100
    98   // Did we solve the diophantine equation yet? 
     101  // Did we solve the diophantine equation yet?
    99102  // If so, return the calculated values
    100103  if ( A[i].calculated && B[i].calculated ){
    101     Retvalue.One=A[i].poly; 
     104    Retvalue.One=A[i].poly;
    102105    Retvalue.Two=B[i].poly;
    103106    return Retvalue;
     
    109112    WerrorS("libfac: diophant ERROR: degree too large!  ");
    110113#else
    111     cerr << "libfac: diophant ERROR: degree too large!  " 
    112         << (degree(F1,levelU) + degree(F2,levelU) ) <<endl;
     114    cerr << "libfac: diophant ERROR: degree too large!  "
     115        << (degree(F1,levelU) + degree(F2,levelU) ) <<endl;
    113116#endif
    114117    Retvalue.One=F1;Retvalue.Two=F2;
     
    118121  if ( i == 0 ) { // call the extended gcd
    119122    r=extgcd(F1,F2,s,t);
    120     // check if gcd(F1,F2) <> 1 , i.e. F1 and F2 are not relatively prime 
    121     if ( ! r.isOne() ){ 
     123    // check if gcd(F1,F2) <> 1 , i.e. F1 and F2 are not relatively prime
     124    if ( ! r.isOne() ){
    122125#ifdef HAVE_SINGULAR
    123126      WerrorS("libfac: diophant ERROR: F1 and F2 are not relatively prime! ");
    124127#else
    125       cerr << "libfac: diophant ERROR: " << F1 << "  and  " << F2
    126            << "  are not relatively prime!" << endl;
     128#ifndef NOSTREAMIO
     129      cerr << "libfac: diophant ERROR: " << F1 << "  and  " << F2
     130           << "  are not relatively prime!" << endl;
     131#else
     132     cerr << "libfac: diophant ERROR: F1 and F2 are not relatively prime!"
     133          << endl;
     134#endif
    127135#endif
    128136      Retvalue.One=F1;Retvalue.Two=F2;
     
    132140  }
    133141  else { // recursively call diophant
    134     Retvalue=diophant(levelU,F1,F2,i-1,A,B); 
     142    Retvalue=diophant(levelU,F1,F2,i-1,A,B);
    135143    Retvalue.One *= x; // createVar(levelU,1);
    136144    Retvalue.Two *= x; // createVar(levelU,1);
     
    144152    else {
    145153      if ( degree(Retvalue.Two,levelU) >= degree(F1,levelU) ){
    146         // Make degree(Retvalue.Two,mainvar) <= degree(F1,mainvar)
    147         divrem(Retvalue.Two,F1,q,r);
    148         Retvalue.One += F2*q; Retvalue.Two = r;
     154        // Make degree(Retvalue.Two,mainvar) <= degree(F1,mainvar)
     155        divrem(Retvalue.Two,F1,q,r);
     156        Retvalue.One += F2*q; Retvalue.Two = r;
    149157      }
    150158    }
    151159
    152160  }
    153   A[i].poly = Retvalue.One ; 
     161  A[i].poly = Retvalue.One ;
    154162  B[i].poly = Retvalue.Two ;
    155163  A[i].calculated = true ; B[i].calculated = true ;
     
    165173// as in Wang and Rothschild [Wang&Roth75].                  //
    166174///////////////////////////////////////////////////////////////
    167 static CanonicalForm 
    168 make_delta( int levelU, const CanonicalForm & W, 
    169             const CanonicalForm & F1, const CanonicalForm & F2,
    170             RememberArray & A, RememberArray & B){
     175static CanonicalForm
     176make_delta( int levelU, const CanonicalForm & W,
     177            const CanonicalForm & F1, const CanonicalForm & F2,
     178            RememberArray & A, RememberArray & B){
    171179  CanonicalForm Retvalue;
    172180  DiophantForm intermediate;
     
    189197}
    190198
    191 static CanonicalForm 
    192 make_square( int levelU, const CanonicalForm & W, 
    193              const CanonicalForm & F1, const CanonicalForm & F2,
    194              RememberArray & A, RememberArray & B){
     199static CanonicalForm
     200make_square( int levelU, const CanonicalForm & W,
     201             const CanonicalForm & F1, const CanonicalForm & F2,
     202             RememberArray & A, RememberArray & B){
    195203  CanonicalForm Retvalue;
    196204  DiophantForm intermediate;
     
    222230// Return the fully lifted factors.                          //
    223231///////////////////////////////////////////////////////////////
    224 static DiophantForm 
    225 mvhensel( const CanonicalForm & U , const CanonicalForm & F , 
    226           const CanonicalForm & G , const SFormList & Substitutionlist){
     232static DiophantForm
     233mvhensel( const CanonicalForm & U , const CanonicalForm & F ,
     234          const CanonicalForm & G , const SFormList & Substitutionlist){
    227235  CanonicalForm V,Fk=F,Gk=G,Rk,W,D,S;
    228236  int  levelU=level(U), degU=subvardegree(U,levelU); // degree(U,{x_1,..,x_(level(U)-1)})
     
    284292// Recursive Version of MultiHensel.                         //
    285293///////////////////////////////////////////////////////////////
    286 CFFList 
    287 multihensel( const CanonicalForm & mF, const CFFList & Factorlist, 
    288              const SFormList & Substitutionlist){
     294CFFList
     295multihensel( const CanonicalForm & mF, const CFFList & Factorlist,
     296             const SFormList & Substitutionlist){
    289297  CFFList Returnlist,factorlist=Factorlist;
    290298  DiophantForm intermediat;
     
    298306    Returnlist.append(CFFactor(mF,1));
    299307  }
    300   else { 
     308  else {
    301309    if ( n == 2 ){
    302       intermediat= mvhensel(mF, factorlist.getFirst().factor(), 
    303                             Factorlist.getLast().factor(),
    304                             Substitutionlist);
     310      intermediat= mvhensel(mF, factorlist.getFirst().factor(),
     311                            Factorlist.getLast().factor(),
     312                            Substitutionlist);
    305313      Returnlist.append(CFFactor(intermediat.One,1));
    306314      Returnlist.append(CFFactor(intermediat.Two,1));
     
    313321      Pr=Pl.genOne();
    314322      for ( ListIterator<CFFactor> i=factorlist; i.hasItem(); i++ )
    315         Pr *=  i.getItem().factor() ;
    316 #ifdef HENSELDEBUG2
    317       cout << "multihensel: Pl,Pr, factorlist: " << Pl << "  " << Pr 
    318            << "  " << factorlist << endl;
     323        Pr *=  i.getItem().factor() ;
     324#ifdef HENSELDEBUG2
     325      cout << "multihensel: Pl,Pr, factorlist: " << Pl << "  " << Pr
     326           << "  " << factorlist << endl;
    319327#endif
    320328      intermediat= mvhensel(mF,Pl,Pr,Substitutionlist);
     
    334342// Returns the list of fully lifted factors.                 //
    335343///////////////////////////////////////////////////////////////
    336 CFFList 
    337 MultiHensel( const CanonicalForm & mF, const CFFList & Factorlist, 
    338              const SFormList & Substitutionlist){
     344CFFList
     345MultiHensel( const CanonicalForm & mF, const CFFList & Factorlist,
     346             const SFormList & Substitutionlist){
    339347  CFFList Returnlist,Retlistinter,factorlist=Factorlist,Ll;
    340348  CFFListIterator i;
     
    351359    Returnlist.append(CFFactor(mF,1));
    352360  }
    353   else { 
     361  else {
    354362    if ( n == 2 ){
    355       intermediat= mvhensel(mF, factorlist.getFirst().factor(), 
    356                             Factorlist.getLast().factor(),
    357                             Substitutionlist);
     363      intermediat= mvhensel(mF, factorlist.getFirst().factor(),
     364                            Factorlist.getLast().factor(),
     365                            Substitutionlist);
    358366      Returnlist.append(CFFactor(intermediat.One,1));
    359367      Returnlist.append(CFFactor(intermediat.Two,1));
     
    361369    else { // more then two factors
    362370      for ( k=1 ; k<=h; k++){
    363         Ll.append(factorlist.getFirst());
    364         factorlist.removeFirst();
     371        Ll.append(factorlist.getFirst());
     372        factorlist.removeFirst();
    365373      }
    366374
     
    370378      Pl = 1; Pr = 1;
    371379      for ( i = Ll; i.hasItem(); i++)
    372         Pl *= i.getItem().factor();
     380        Pl *= i.getItem().factor();
    373381      DEBOUTLN(cout, "MultiHensel: Pl= ", Pl);
    374382      for ( i = factorlist; i.hasItem(); i++)
    375         Pr *= i.getItem().factor();
     383        Pr *= i.getItem().factor();
    376384      DEBOUTLN(cout, "MultiHensel: Pr= ", Pr);
    377385      intermediat = mvhensel(mF,Pl,Pr,Substitutionlist);
     
    380388      // we add a division test now for intermediat.One and intermediat.Two
    381389      if ( mydivremt (mF,intermediat.One,a,b) && b == mF.genZero() )
    382         Retlistinter.append(CFFactor(intermediat.One,1) );
     390        Retlistinter.append(CFFactor(intermediat.One,1) );
    383391      if ( mydivremt (mF,intermediat.Two,a,b) && b == mF.genZero() )
    384         Retlistinter.append(CFFactor(intermediat.Two,1)  );
     392        Retlistinter.append(CFFactor(intermediat.Two,1)  );
    385393
    386394      Ll = MultiHensel(intermediat.One, Ll, Substitutionlist);
     
    397405/*
    398406$Log: not supported by cvs2svn $
     407Revision 1.4  1997/11/18 16:39:05  Singular
     408* hannes: moved WerrorS from C++ to C
     409     (Factor.cc MVMultiHensel.cc SqrFree.cc Truefactor.cc)
     410
    399411Revision 1.3  1997/09/12 07:19:48  Singular
    400412* hannes/michael: libfac-0.3.0
  • libfac/factor/SqrFree.cc

    rc794a9 r14b1e65  
    22///////////////////////////////////////////////////////////////////////////////
    33// emacs edit mode for this file is -*- C++ -*-
    4 static char * rcsid = "$Id: SqrFree.cc,v 1.4 1997-11-18 16:39:06 Singular Exp $";
     4static char * rcsid = "$Id: SqrFree.cc,v 1.5 2001-08-08 11:59:13 Singular Exp $";
    55static 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.";
    66///////////////////////////////////////////////////////////////////////////////
    77// FACTORY - Includes
    88#include<factory.h>
     9#ifndef NOSTREAMIO
     10#include <iostream.h>
     11#endif
    912// Factor - Includes
    1013#include "tmpl_inst.h"
     
    3033
    3134
    32 static inline CFFactor 
    33 Powerup( const CFFactor & F , int exp=1){ 
    34   return CFFactor(F.factor(), exp*F.exp()) ; 
    35 }
    36 
    37 static CFFList 
     35static inline CFFactor
     36Powerup( const CFFactor & F , int exp=1){
     37  return CFFactor(F.factor(), exp*F.exp()) ;
     38}
     39
     40static CFFList
    3841Powerup( const CFFList & Inputlist , int exp=1 ){
    3942  CFFList Outputlist;
     
    4952// Domain is q=p^m , f a uni/multivariate polynomial         //
    5053///////////////////////////////////////////////////////////////
    51 static CanonicalForm 
     54static CanonicalForm
    5255PthRoot( const CanonicalForm & f ){
    5356  CanonicalForm RES, R = f;
    5457  int n= max(level(R),getNumVars(R)), p= getCharacteristic();
    55  
     58
    5659  if (n==0){ // constant
    5760    if (R.inExtension()) // not in prime field; f over |F(q=p^k)
     
    9093    g = mygcd(f,g);
    9194    if ( g.isOne() || (-g).isOne() ) return 1;
    92     else 
     95    else
    9396      if ( getNumVars(g) == 0 ) return 1;// <- totaldegree!!!
    9497      else return 0 ;
     
    99102      // g = 1 || -1 : sqr-free, g poly : not sqr-free, g number : opt helps
    100103      if ( ! (g.isOne() || (-g).isOne() || getNumVars(g)==0 ) ) {
    101         if ( opt==0 ) return 0;
    102         else {
    103           if ( SqrFreeTest(g,1) == 0 ) return 0;
    104           g = swapvar(g,k,n);
    105           f /=g ;
    106         }
     104        if ( opt==0 ) return 0;
     105        else {
     106          if ( SqrFreeTest(g,1) == 0 ) return 0;
     107          g = swapvar(g,k,n);
     108          f /=g ;
     109        }
    107110      }
    108111    }
     
    110113    n = level(f); // maybe less indeterminants
    111114    //    if ( totaldegree(f) <= 1 ) return 1;
    112    
     115
    113116    // Let`s look if it is a Pth root
    114117    if ( getCharacteristic() > 0 )
    115118      for (int k=1; k<=n; k++ ) {
    116         g=swapvar(f,k,n); g=g.deriv();
    117         if ( ! g.isZero() ) break ;
    118         else if ( k==n) return 0 ; // really is Pth root
     119        g=swapvar(f,k,n); g=g.deriv();
     120        if ( ! g.isZero() ) break ;
     121        else if ( k==n) return 0 ; // really is Pth root
    119122      }
    120123    g = f.deriv() ;
     
    128131  WerrorS("libfac: ERROR: SqrFreeTest: we should never fall trough here!");
    129132#else
    130   cerr << "\nlibfac: ERROR: SqrFreeTest: we should never fall trough here!\n" 
     133  cerr << "\nlibfac: ERROR: SqrFreeTest: we should never fall trough here!\n"
    131134       << rcsid << errmsg << endl;
    132135#endif
     
    141144// needs not to be 1 !!!!!                                   //
    142145///////////////////////////////////////////////////////////////
    143 static CFFList 
     146static CFFList
    144147SqrFreed( const CanonicalForm & r ){
    145148  CanonicalForm h, g, f = r;
     
    154157  }
    155158
    156 // We look if we do have a content; if so, SqrFreed the content 
     159// We look if we do have a content; if so, SqrFreed the content
    157160// and continue computations with pp(f)
    158161  for (int k=1; k<=n; k++) {
     
    161164      g = swapvar(g,k,n);
    162165      DEBOUTLN(cout, "We have a content: ", g);
    163       Outputlist = myUnion(InternalSqrFree(g),Outputlist); // should we add a 
     166      Outputlist = myUnion(InternalSqrFree(g),Outputlist); // should we add a
    164167                                                // SqrFreeTest(g) first ?
    165168      DEBOUTLN(cout, "Outputlist is now: ", Outputlist);
     
    177180      f /= g;
    178181    }
    179     Outputlist = Union(sqrFree(f),Outputlist) ; 
     182    Outputlist = Union(sqrFree(f),Outputlist) ;
    180183    DEBOUTLN(cout, "Outputlist after univ. sqrFree(f) = ", Outputlist);
    181184    DEBDECLEVEL(cout, "SqrFreed");
     
    197200      g=swapvar(f,k,n) ; g = g.deriv();
    198201      if ( ! g.isZero() ){ // can`t be Pth root
    199         CFFList Outputlist2= SqrFreed(swapvar(f,k,n));
    200         for (CFFListIterator inter=Outputlist2; inter.hasItem(); inter++){
    201           Outputlist= myappend(Outputlist, CFFactor(swapvar(inter.getItem().factor(),k,n), inter.getItem().exp()));
    202         }
    203         return Outputlist;
     202        CFFList Outputlist2= SqrFreed(swapvar(f,k,n));
     203        for (CFFListIterator inter=Outputlist2; inter.hasItem(); inter++){
     204          Outputlist= myappend(Outputlist, CFFactor(swapvar(inter.getItem().factor(),k,n), inter.getItem().exp()));
     205        }
     206        return Outputlist;
    204207      }
    205       else 
    206         if ( k==n ) { // really is Pth power
     208      else
     209        if ( k==n ) { // really is Pth power
    207210          DEBOUTLN(cout, "f is a p'th root: ", f);
    208           CFMap m;
     211          CFMap m;
    209212          g = compress(f,m);
    210           f = m(PthRoot(g));
     213          f = m(PthRoot(g));
    211214          DEBOUTLN(cout, "  that is       : ", f);
    212           // now : Outputlist union ( SqrFreed(f) )^getCharacteristic()
    213           Outputlist=myUnion(Powerup(InternalSqrFree(f),getCharacteristic()),Outputlist);
    214           DEBDECLEVEL(cout, "SqrFreed");
    215           return Outputlist ;
    216         }
     215          // now : Outputlist union ( SqrFreed(f) )^getCharacteristic()
     216          Outputlist=myUnion(Powerup(InternalSqrFree(f),getCharacteristic()),Outputlist);
     217          DEBDECLEVEL(cout, "SqrFreed");
     218          return Outputlist ;
     219        }
    217220    }
    218221  }
     
    254257  WerrorS("libfac: ERROR: SqrFreed: we should never fall trough here!");
    255258#else
    256   cerr << "\nlibfac: ERROR: SqrFreed: we should never fall trough here!\n" 
     259  cerr << "\nlibfac: ERROR: SqrFreed: we should never fall trough here!\n"
    257260       << rcsid << errmsg << endl;
    258261#endif
     
    265268// Input can have a constant as content                      //
    266269///////////////////////////////////////////////////////////////
    267 CFFList 
     270CFFList
    268271InternalSqrFree( const CanonicalForm & r ){
    269272  CanonicalForm g=icontent(r), f = r;
     
    285288      f /= g;
    286289      if ( getNumVars(f) != 0 ) // a real polynomial
    287         Outputlist=myUnion(SqrFreed(f),Outputlist) ;
     290        Outputlist=myUnion(SqrFreed(f),Outputlist) ;
    288291  }
    289292  DEBOUTLN(cout,"Outputlist = ", Outputlist);
     
    331334/*
    332335$Log: not supported by cvs2svn $
     336Revision 1.4  1997/11/18 16:39:06  Singular
     337* hannes: moved WerrorS from C++ to C
     338     (Factor.cc MVMultiHensel.cc SqrFree.cc Truefactor.cc)
     339
    333340Revision 1.3  1997/09/12 07:19:50  Singular
    334341* hannes/michael: libfac-0.3.0
  • libfac/factor/Truefactor.cc

    rc794a9 r14b1e65  
    22///////////////////////////////////////////////////////////////////////////////
    33// emacs edit mode for this file is -*- C++ -*-
    4 //static char * rcsid = "@(#) $Id: Truefactor.cc,v 1.7 2001-08-06 08:32:54 Singular Exp $";
     4//static char * rcsid = "@(#) $Id: Truefactor.cc,v 1.8 2001-08-08 11:59:13 Singular Exp $";
    55///////////////////////////////////////////////////////////////////////////////
    66// Factory - Includes
    77#include <factory.h>
     8#ifndef NOSTREAMIO
     9#include <iostream.h>
     10#endif
    811// Factor - Includes
    912#include "tmpl_inst.h"
     
    410413/*
    411414$Log: not supported by cvs2svn $
     415Revision 1.7  2001/08/06 08:32:54  Singular
     416* hannes: code cleanup
     417
    412418Revision 1.6  2001/06/27 13:58:06  Singular
    413419*hannes/GP: debug newfactoras, char_series, ...
  • libfac/factor/tmpl_inst.cc

    rc794a9 r14b1e65  
    22////////////////////////////////////////////////////////////
    33// emacs edit mode for this file is -*- C++ -*-
    4 // $Id: tmpl_inst.cc,v 1.4 1998-02-27 10:34:02 schmidt Exp $
     4// $Id: tmpl_inst.cc,v 1.5 2001-08-08 11:59:13 Singular Exp $
    55////////////////////////////////////////////////////////////
    66
     
    2525template class SubMatrix<CanonicalForm>;
    2626
     27#ifndef NOSTREAMIO
    2728template ostream & operator << ( ostream &, const List<CanonicalForm> & );
    2829template ostream & operator << ( ostream &, const List<CFFactor> & );
     
    3132template ostream & operator << ( ostream &, const Factor<CanonicalForm> & );
    3233//template ostream & operator << ( ostream &, const Matrix<CanonicalForm> & );
     34#endif
    3335
    3436template List<CFFactor> Union ( const List<CFFactor>&, const List<CFFactor>& );
     
    6264template List<CanonicalForm> Difference ( const List<CanonicalForm>&, const List<CanonicalForm>& );
    6365
     66#ifndef NOSTREAMIO
    6467template ostream & operator << ( ostream &, const List<int> & );
    6568template ostream & operator << ( ostream &, const List<IntList> & );
     69#endif
    6670
    6771// for charsets:
     
    7478template List<Variable> Difference ( const List<Variable>&, const List<Variable>& );
    7579
     80#ifndef NOSTREAMIO
    7681template ostream & operator << ( ostream &, const List<CFList> & );
    7782template ostream & operator << ( ostream &, const List<Variable> & );
    7883template ostream & operator << ( ostream &, const List<int> & );
    7984template ostream & operator << ( ostream &, const Array<int> & );
     85#endif
    8086
    8187template class Array<int>;
     
    9096/*
    9197$Log: not supported by cvs2svn $
     98Revision 1.4  1998/02/27 10:34:02  schmidt
     99        * factor/tmpl_inst.cc: template names adapted (`*.cc' ->
     100          `ftmpl_*.cc')
     101
    92102Revision 1.3  1997/09/12 07:20:00  Singular
    93103* hannes/michael: libfac-0.3.0
Note: See TracChangeset for help on using the changeset viewer.