powerprod.H

Go to the documentation of this file.

#ifndef _POWERPROD_H_
#define _POWERPROD_H_

#include "tables.H"
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <iomanip>
#include "alphabet.H"
using namespace std;



#define LEX 1
#define LEXSV 101 // SV is for super-variable
#define DEGLEX 2
#define DEGLEXSV 102
#define DEGREVLEX 3
#define DEGREVLEXSV 103


class PowProd {
private:
  static Alphabet *alphabet;
  static AutoAlphabet default_alphabet;
  static int order;

public:
  Tuple<long> powers;



  // constructors **************************
  // ***************************************

  PowProd();
  PowProd(long var_num);
  PowProd(long var_num, long thepower);
  PowProd(const PowProd& that);

  void debug() const {
    cout << powers << endl;
  }

  bool is_correct() const {
    return powers.size() == 0 || powers[ powers.size()-1 ] != 0 ;
  }

  // info **********************************
  // ***************************************

  long nvars() const;
  long degree() const;
  long power_of(long i) const;
 
  PowProd& operator=(const PowProd& that);
  PowProd& operator*=(const PowProd& that);
  PowProd operator*( const PowProd& that)  const ;

  // all about the order relation ********************
  // *************************************************

  bool lex_lessthan(const PowProd& that) const;
  bool lexsv_lessthan(const PowProd& that, long sv) const;
  bool deglex_lessthan(const PowProd& that) const;
  bool deglexsv_lessthan(const PowProd& that, long sv) const;
  bool degrevlex_lessthan(const PowProd& that) const;
  bool degrevlexsv_lessthan(const PowProd& that, long sv) const;

  bool operator<(const PowProd& that)  const;
  static void use_order(int theorder);
  static int current_order();
  friend bool powprod_compare(const PowProd& one, const PowProd& two, int order, long priority);
  bool operator==(const PowProd& that) const;

  // some arithmetic ****************************
  // ********************************************

  bool divides(const PowProd& that) const;
  PowProd& operator/=(const PowProd& that);
  PowProd operator/(const PowProd& that) const;
  bool prime_to(const PowProd& that) const;
  friend PowProd lcm(const PowProd& a, const PowProd& b);

  
  // some ad-hoc manipulations *****************
  // *******************************************

  void swap(long i, long j);
  void shift(long n);

  // display -- alphabets **********************
  // *******************************************

  // a bunch of static methods related to the alphabet mechanism
  static Alphabet* get_current_alphabet();
  static Alphabet* get_default_alphabet();
  static void set_alphabet(Alphabet *thealphabet);

  friend ostream& operator<<(ostream& os, const PowProd& P);
  friend ofstream& operator<<(ofstream& file, PowProd& x);
  friend void operator>>(ifstream& file, PowProd& x);

};








#endif

---