Congruence_defs.hh

Go to the documentation of this file.

/* Congruence class declaration.
   Copyright (C) 2001-2010 Roberto Bagnara <bagnara@cs.unipr.it>
   Copyright (C) 2010-2016 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_defs_hh
#define PPL_Congruence_defs_hh 1

#include "Congruence_types.hh"

#include "Coefficient_defs.hh"
#include "Variable_defs.hh"

#include "Constraint_types.hh"
#include "Grid_types.hh"
#include "Scalar_Products_types.hh"
#include "Linear_Expression_defs.hh"
#include "Expression_Adapter_defs.hh"

#include <iosfwd>
#include <vector>

// These are declared here because they are friend of Congruence.
namespace Parma_Polyhedra_Library {


bool
operator==(const Congruence& x, const Congruence& y);


bool
operator!=(const Congruence& x, const Congruence& y);

} // namespace Parma_Polyhedra_Library



class Parma_Polyhedra_Library::Congruence {
public:


  static const Representation default_representation = SPARSE;

  explicit Congruence(Representation r = default_representation);


  Congruence(const Congruence& cg);

  Congruence(const Congruence& cg, Representation r);


  explicit Congruence(const Constraint& c,
                      Representation r = default_representation);

  ~Congruence();

  Congruence& operator=(const Congruence& y);

  Representation representation() const;

  void set_representation(Representation r);

  static dimension_type max_space_dimension();

  dimension_type space_dimension() const;

  void permute_space_dimensions(const std::vector<Variable>& cycles);

  typedef Expression_Adapter_Transparent<Linear_Expression> expr_type;
  expr_type expression() const;


  Coefficient_traits::const_reference coefficient(Variable v) const;

  Coefficient_traits::const_reference inhomogeneous_term() const;

  Coefficient_traits::const_reference modulus() const;

  void set_modulus(Coefficient_traits::const_reference m);

  void scale(Coefficient_traits::const_reference factor);

  // TODO: Document this.
  void affine_preimage(Variable v,
                       const Linear_Expression& expr,
                       Coefficient_traits::const_reference denominator);


  Congruence&
  operator/=(Coefficient_traits::const_reference k);

  bool is_tautological() const;

  bool is_inconsistent() const;


  bool is_proper_congruence() const;


  bool is_equality() const;

  static void initialize();

  static void finalize();

  static const Congruence& zero_dim_integrality();

  static const Congruence& zero_dim_false();

  static Congruence
  create(const Linear_Expression& e1, const Linear_Expression& e2,
         Representation r = default_representation);

  static Congruence
  create(const Linear_Expression& e, Coefficient_traits::const_reference n,
         Representation r = default_representation);

  static Congruence
  create(Coefficient_traits::const_reference n, const Linear_Expression& e,
         Representation r = default_representation);

  memory_size_type total_memory_in_bytes() const;

  memory_size_type external_memory_in_bytes() const;

  bool OK() const;

  PPL_OUTPUT_DECLARATIONS

  bool ascii_load(std::istream& s);

  void m_swap(Congruence& y);


  Congruence(const Congruence& cg, dimension_type new_space_dimension);

  Congruence(const Congruence& cg, dimension_type new_space_dimension,
             Representation r);

  Congruence(const Constraint& cg, dimension_type new_space_dimension,
             Representation r = default_representation);


  Congruence(Linear_Expression& le,
             Coefficient_traits::const_reference m, Recycle_Input);

  void swap_space_dimensions(Variable v1, Variable v2);

  void set_space_dimension(dimension_type n);

  void shift_space_dimensions(Variable v, dimension_type n);


  void sign_normalize();


  void normalize();


  void strong_normalize();

private:
  static const Congruence* zero_dim_false_p;

  static const Congruence* zero_dim_integrality_p;

  Linear_Expression expr;

  Coefficient modulus_;

  bool is_equal_at_dimension(Variable v,
                             const Congruence& cg) const;

  void
  throw_invalid_argument(const char* method, const char* message) const;

  void
  throw_dimension_incompatible(const char* method,
                               const char* v_name,
                               Variable v) const;

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

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

  friend class Scalar_Products;
  friend class Grid;
};

namespace Parma_Polyhedra_Library {

namespace IO_Operators {


std::ostream&
operator<<(std::ostream& s, const Congruence& c);

} // namespace IO_Operators


Congruence
operator%=(const Linear_Expression& e1, const Linear_Expression& e2);


Congruence
operator%=(const Linear_Expression& e, Coefficient_traits::const_reference n);


Congruence
operator/(const Congruence& cg, Coefficient_traits::const_reference k);


Congruence
operator/(const Constraint& c, Coefficient_traits::const_reference m);

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

} // namespace Parma_Polyhedra_Library

#include "Congruence_inlines.hh"

#endif // !defined(PPL_Congruence_defs_hh)