Congruence_System.defs.hh

Go to the documentation of this file.

/* Congruence_System class declaration.
   Copyright (C) 2001-2010 Roberto Bagnara <bagnara@cs.unipr.it>
   Copyright (C) 2010-2012 BUGSENG srl (http://bugseng.com)

This file is part of the Parma Polyhedra Library (PPL).

The PPL 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 3 of the License, or (at your
option) any later version.

The PPL 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, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.

For the most up-to-date information see the Parma Polyhedra Library
site: http://bugseng.com/products/ppl/ . */

#ifndef PPL_Congruence_System_defs_hh
#define PPL_Congruence_System_defs_hh 1

#include "Congruence_System.types.hh"
#include "Linear_Expression.types.hh"
#include "Constraint.types.hh"
#include "Congruence.types.hh"
#include "Grid_Generator.types.hh"
#include "Dense_Matrix.defs.hh"
#include "Grid.types.hh"
#include "Grid_Certificate.types.hh"
#include <iosfwd>

namespace Parma_Polyhedra_Library {

namespace IO_Operators {


std::ostream&
operator<<(std::ostream& s, const Congruence_System& cgs);

} // namespace IO_Operators


void swap(Congruence_System& x, Congruence_System& y);

} // namespace Parma_Polyhedra_Library


class Parma_Polyhedra_Library::Congruence_System : private Dense_Matrix {
public:
  Congruence_System();

  explicit Congruence_System(const Congruence& cg);

  explicit Congruence_System(const Constraint& c);

  explicit Congruence_System(const Constraint_System& cs);

  Congruence_System(const Congruence_System& cgs);

  ~Congruence_System();

  Congruence_System& operator=(const Congruence_System& y);

  static dimension_type max_space_dimension();

  dimension_type space_dimension() const;

  bool is_equal_to(const Congruence_System& y) const;

  bool has_linear_equalities() const;

  void clear();

  void insert(const Congruence& cg);

  void insert(const Constraint& c);

  // TODO: Consider adding a recycling_insert(cg).

  void insert(const Congruence_System& y);

  void recycling_insert(Congruence_System& cgs);

  static void initialize();

  static void finalize();

  static const Congruence_System& zero_dim_empty();


  class const_iterator
    : public std::iterator<std::forward_iterator_tag,
                           Congruence,
                           ptrdiff_t,
                           const Congruence*,
                           const Congruence&> {
  public:
    const_iterator();

    const_iterator(const const_iterator& y);

    ~const_iterator();

    const_iterator& operator=(const const_iterator& y);

    const Congruence& operator*() const;

    const Congruence* operator->() const;

    const_iterator& operator++();

    const_iterator operator++(int);

    bool operator==(const const_iterator& y) const;

    bool operator!=(const const_iterator& y) const;

  private:
    friend class Congruence_System;

    Dense_Matrix::const_iterator i;

    const Dense_Matrix* csp;

    const_iterator(const Dense_Matrix::const_iterator& iter,
                   const Congruence_System& cgs);

    void skip_forward();
  };

  bool empty() const;

  const_iterator begin() const;

  const_iterator end() const;

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
  bool OK() const;

  PPL_OUTPUT_DECLARATIONS

  bool ascii_load(std::istream& s);

  memory_size_type total_memory_in_bytes() const;

  memory_size_type external_memory_in_bytes() const;

  dimension_type num_equalities() const;

  dimension_type num_proper_congruences() const;

  void m_swap(Congruence_System& y);

  void add_unit_rows_and_columns(dimension_type dims);

protected:

  bool satisfies_all_congruences(const Grid_Generator& g) const;

private:
  static const Congruence_System* zero_dim_empty_p;

  explicit Congruence_System(dimension_type d);

  void concatenate(const Congruence_System& y);

  void normalize_moduli();


  bool increase_space_dimension(dimension_type new_space_dim);

  void insert_verbatim(const Congruence& cg);

  friend class const_iterator;
  friend class Grid;
  friend class Grid_Certificate;

  friend bool
  operator==(const Congruence_System& x, const Congruence_System& y);

  Congruence& operator[](dimension_type k);

  const Congruence& operator[](dimension_type k) const;

  bool has_a_free_dimension() const;

  void affine_preimage(dimension_type v,
                       const Linear_Expression& expr,
                       Coefficient_traits::const_reference denominator);

  void remove_higher_space_dimensions(dimension_type new_dimension);


  void resize_no_copy(dimension_type new_num_rows,
                      dimension_type new_num_columns);
};

// Congruence_System.inlines.hh is not included here on purpose.

#endif // !defined(PPL_Congruence_System_defs_hh)