RawSquareFreeIdeal.h

Go to the documentation of this file.

/* Frobby: Software for monomial ideal computations.
   Copyright (C) 2010 University of Aarhus
   Contact Bjarke Hammersholt Roune for license information (www.broune.com)
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see http://www.gnu.org/licenses/.
*/
#ifndef RAW_SQUARE_FREE_IDEAL_GUARD
#define RAW_SQUARE_FREE_IDEAL_GUARD
 
#include <ostream>
#include <vector>
 
class Ideal;
class BigIdeal;
 
class RawSquareFreeIdeal {
 public:
  static RawSquareFreeIdeal* construct(void* buffer, size_t varCount = 0);
  static RawSquareFreeIdeal* construct(void* buffer, const Ideal& ideal);
  static RawSquareFreeIdeal* construct(void* buffer,
    const RawSquareFreeIdeal& ideal);
 
  static size_t getBytesOfMemoryFor(size_t varCount, size_t generatorCount);
 
  RawSquareFreeIdeal& operator=(const RawSquareFreeIdeal& ideal)
    {return *construct(this, ideal);}
 
  void setToTransposeOf(const RawSquareFreeIdeal& ideal, Word* eraseVars = 0);
 
  void transpose(Word* eraseVars = 0);
 
  void compact(const Word* remove);
 
  void print(FILE* file) const;
 
  void print(ostream& out) const;
 
  size_t insert(const Ideal& ideal);
  size_t insert(const BigIdeal& ideal);
 
  void insert(const RawSquareFreeIdeal& ideal);
 
  void insert(const Word* term);
  void insertIdentity();
 
  bool insert(const std::vector<std::string>& term);
  void minimize();
  void colon(const Word* by);
  void colon(size_t var);
 
  void colonReminimize(const Word* colon);
 
  void colonReminimize(size_t var);
 
  void swap01Exponents();
 
  void getLcm(Word* lcm) const;
 
  size_t getGeneratorCount() const {return _genCount;}
  size_t getVarCount() const {return _varCount;}
  size_t getWordsPerTerm() const {return _wordsPerTerm;}
 
  Word* getGenerator(size_t index);
 
  const Word* getGenerator(size_t index) const;
 
  Word* getGeneratorUnsafe(size_t index);
 
  const Word* getGeneratorUnsafe(size_t index) const;
 
  void getLcmOfNonMultiples(Word* lcm, size_t var) const;
 
  void getGcdOfMultiples(Word* gcd, size_t var) const;
 
  void getGcdOfMultiples(Word* gcd, const Word* div) const;
 
  void getVarDividesCounts(vector<size_t>& counts) const;
 
  size_t getMultiple(size_t var) const;
 
  size_t getNonMultiple(size_t var) const;
 
  size_t getMaxSupportGen() const;
 
  size_t getMinSupportGen() const;
 
  void removeGenerator(size_t index);
 
  void insertNonMultiples(const Word* term, const RawSquareFreeIdeal& ideal);
 
  void insertNonMultiples(size_t var, const RawSquareFreeIdeal& ideal);
 
  size_t getNotRelativelyPrime(const Word* term);
 
  size_t getExclusiveVarGenerator();
 
  bool hasFullSupport(const Word* ignore) const;
 
  bool isMinimallyGenerated() const;
 
  void swap(size_t a, size_t b);
 
  bool operator==(const RawSquareFreeIdeal& ideal) const;
  bool operator!=(const RawSquareFreeIdeal& ideal) const {
    return !(*this == ideal);
  }
 
  Word* back() {iterator e = end(); --e; return *e;}
  const Word* back() const {const_iterator e = end(); --e; return *e;}
 
  void sortLexAscending();
 
  class const_iterator {
  public:
  const_iterator(const Word* term, size_t wordsPerTerm):
    _term(term), _wordsPerTerm(wordsPerTerm) {
    }
 
    const Word* operator*() const {return _term;}
    const_iterator operator++() {_term += _wordsPerTerm; return *this;}
    const_iterator operator--() {_term -= _wordsPerTerm; return *this;}
 
    bool operator==(const const_iterator& it) const {
      ASSERT(_wordsPerTerm == it._wordsPerTerm);
      return _term == it._term;
    }
    bool operator!=(const const_iterator& it) const {
      ASSERT(_wordsPerTerm == it._wordsPerTerm);
      return _term != it._term;
    }
 
    ptrdiff_t operator-(const const_iterator& it) const {
      ASSERT(_wordsPerTerm == it._wordsPerTerm);
      return (_term - it._term) / _wordsPerTerm;
    }
    const_iterator operator+(ptrdiff_t i) const {
      return const_iterator(_term + i * _wordsPerTerm, _wordsPerTerm);
    }
 
    const_iterator& operator=(const const_iterator& it) {
      ASSERT(it._wordsPerTerm == _wordsPerTerm);
      _term = it._term;
      return *this;
    }
 
  private:
    const Word* _term;
    const size_t _wordsPerTerm;
  };
 
  class iterator {
  public:
  iterator(Word* term, size_t wordsPerTerm):
    _term(term), _wordsPerTerm(wordsPerTerm) {
    }
 
    operator const_iterator() const {
      return const_iterator(_term, _wordsPerTerm);
    }
 
    Word* operator*() const {return _term;}
    iterator operator++() {_term += _wordsPerTerm; return *this;}
    iterator operator--() {_term -= _wordsPerTerm; return *this;}
 
    bool operator==(const iterator& it) const {
      ASSERT(_wordsPerTerm == it._wordsPerTerm);
      return _term == it._term;
    }
    bool operator!=(const iterator& it) const {
      ASSERT(_wordsPerTerm == it._wordsPerTerm);
      return _term != it._term;
    }
 
    ptrdiff_t operator-(const iterator& it) const {
      ASSERT(_wordsPerTerm == it._wordsPerTerm);
      return (_term - it._term) / _wordsPerTerm;
    }
    iterator operator+(ptrdiff_t i) const {
      return iterator(_term + i * _wordsPerTerm, _wordsPerTerm);
    }
    iterator& operator=(const iterator& it) {
      ASSERT(it._wordsPerTerm == _wordsPerTerm);
      _term = it._term;
      return *this;
    }
 
  private:
    Word* _term;
    const size_t _wordsPerTerm;
  };
 
  iterator begin()
  {return iterator(_memory, getWordsPerTerm());}
  const_iterator begin() const
  {return const_iterator(_memory, getWordsPerTerm());}
 
  iterator end()
  {return iterator(_memoryEnd, getWordsPerTerm());}
  const_iterator end() const
  {return const_iterator(_memoryEnd, getWordsPerTerm());}
 
  bool isValid() const;
 
 private:
  RawSquareFreeIdeal(); // Not available
  RawSquareFreeIdeal(const RawSquareFreeIdeal&); // Not available
 
  size_t _varCount;
  size_t _wordsPerTerm;
  size_t _genCount;
  Word* _memoryEnd;
  Word _memory[1]; // variable size array
};
 
RawSquareFreeIdeal* newRawSquareFreeIdeal(size_t varCount, size_t capacity);
 
RawSquareFreeIdeal* newRawSquareFreeIdeal(const RawSquareFreeIdeal& ideal);
 
RawSquareFreeIdeal* newRawSquareFreeIdealParse(const char* str);
 
void deleteRawSquareFreeIdeal(RawSquareFreeIdeal* ideal);
 
inline ostream& operator<<(ostream& out, const RawSquareFreeIdeal& ideal) {
  ideal.print(out);
  return out;
}
 
inline Word* RawSquareFreeIdeal::getGenerator(size_t index) {
  ASSERT(index < getGeneratorCount());
  return _memory + index * getWordsPerTerm();
}
 
inline const Word* RawSquareFreeIdeal::getGenerator(size_t index) const {
  ASSERT(index < getGeneratorCount());
  return _memory + index * getWordsPerTerm();
}
 
inline Word* RawSquareFreeIdeal::getGeneratorUnsafe(size_t index) {
  // no assert to check index is valid as this method specifically
  // allows out-of-bounds access.
  return _memory + index * getWordsPerTerm();
}
 
inline const Word* RawSquareFreeIdeal::getGeneratorUnsafe(size_t index) const {
  // no assert to check index is valid as this method specifically
  // allows out-of-bounds access.
  return _memory + index * getWordsPerTerm();
}
 
#endif