Constraint.defs.hh

Go to the documentation of this file.

/* Constraint 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_Constraint_defs_hh
#define PPL_Constraint_defs_hh 1

#include "Constraint.types.hh"
#include "Scalar_Products.types.hh"
#include "Linear_Row.defs.hh"
#include "Variable.defs.hh"
#include "Linear_Expression.defs.hh"
#include "Constraint_System.defs.hh"
#include "Polyhedron.types.hh"
#include "Congruence.types.hh"
#include <iosfwd>

namespace Parma_Polyhedra_Library {


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

// Put them in the namespace here to declare them friend later.


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


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


Constraint
operator==(const Linear_Expression& e1, const Linear_Expression& e2);


Constraint
operator==(Variable v1, Variable v2);


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


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


Constraint
operator<=(const Linear_Expression& e1, const Linear_Expression& e2);


Constraint
operator<=(Variable v1, Variable v2);


Constraint
operator<=(const Linear_Expression& e, Coefficient_traits::const_reference n);


Constraint
operator<=(Coefficient_traits::const_reference n, const Linear_Expression& e);


Constraint
operator>=(const Linear_Expression& e1, const Linear_Expression& e2);


Constraint
operator>=(Variable v1, Variable v2);


Constraint
operator>=(const Linear_Expression& e, Coefficient_traits::const_reference n);


Constraint
operator>=(Coefficient_traits::const_reference n, const Linear_Expression& e);


Constraint
operator<(const Linear_Expression& e1, const Linear_Expression& e2);


Constraint
operator<(Variable v1, Variable v2);


Constraint
operator<(const Linear_Expression& e, Coefficient_traits::const_reference n);


Constraint
operator<(Coefficient_traits::const_reference n, const Linear_Expression& e);


Constraint
operator>(const Linear_Expression& e1, const Linear_Expression& e2);


Constraint
operator>(Variable v1, Variable v2);


Constraint
operator>(const Linear_Expression& e, Coefficient_traits::const_reference n);


Constraint
operator>(Coefficient_traits::const_reference n, const Linear_Expression& e);

} // namespace Parma_Polyhedra_Library


class Parma_Polyhedra_Library::Constraint : private Linear_Row {
public:
  Constraint(const Constraint& c);


  explicit Constraint(const Congruence& cg);

  ~Constraint();

  Constraint& operator=(const Constraint& c);

  static dimension_type max_space_dimension();

  dimension_type space_dimension() const;

  enum Type {
    EQUALITY,
    NONSTRICT_INEQUALITY,
    STRICT_INEQUALITY
  };

  Type type() const;

  bool is_equality() const;

  bool is_inequality() const;

  bool is_nonstrict_inequality() const;

  bool is_strict_inequality() const;


  Coefficient_traits::const_reference coefficient(Variable v) const;

  Coefficient_traits::const_reference inhomogeneous_term() const;

  static void initialize();

  static void finalize();

  static const Constraint& zero_dim_false();

  static const Constraint& zero_dim_positivity();

  memory_size_type total_memory_in_bytes() const;

  memory_size_type external_memory_in_bytes() const;

  bool is_tautological() const;

  bool is_inconsistent() const;

  bool is_equivalent_to(const Constraint& y) const;

  PPL_OUTPUT_DECLARATIONS

  bool ascii_load(std::istream& s);

  bool OK() const;

  void m_swap(Constraint& y);

private:
  static const Constraint* zero_dim_false_p;

  static const Constraint* zero_dim_positivity_p;

  static const Constraint* epsilon_geq_zero_p;

  static const Constraint* epsilon_leq_one_p;

  friend class Parma_Polyhedra_Library::Congruence;
  friend class Parma_Polyhedra_Library::Scalar_Products;
  friend class Parma_Polyhedra_Library::Topology_Adjusted_Scalar_Product_Sign;
  friend class Parma_Polyhedra_Library::Constraint_System;
  friend class Parma_Polyhedra_Library::Constraint_System::const_iterator;
  // FIXME: the following friend declaration should be avoided.
  friend class Parma_Polyhedra_Library::Polyhedron;

  friend
  Parma_Polyhedra_Library
  ::Linear_Expression::Linear_Expression(const Constraint& c);

  Constraint();

  Constraint(Linear_Expression& e, Type type, Topology topology);

  Constraint(const Congruence& cg, dimension_type sz, dimension_type capacity);

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

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

  friend Constraint
  operator==(const Linear_Expression& e1, const Linear_Expression& e2);
  friend Constraint
  operator==(Variable v1, Variable v2);
  friend Constraint
  operator==(const Linear_Expression& e, Coefficient_traits::const_reference n);
  friend Constraint
  operator==(Coefficient_traits::const_reference n, const Linear_Expression& e);

  friend Constraint
  operator>=(const Linear_Expression& e1, const Linear_Expression& e2);
  friend Constraint
  operator>=(Variable v1, Variable v2);
  friend Constraint
  operator>=(const Linear_Expression& e, Coefficient_traits::const_reference n);
  friend Constraint
  operator>=(Coefficient_traits::const_reference n, const Linear_Expression& e);

  friend Constraint
  operator<=(const Linear_Expression& e1, const Linear_Expression& e2);
  friend Constraint
  operator<=(const Linear_Expression& e, Coefficient_traits::const_reference n);
  friend Constraint
  operator<=(Coefficient_traits::const_reference n, const Linear_Expression& e);

  friend Constraint
  operator>(const Linear_Expression& e1, const Linear_Expression& e2);
  friend Constraint
  operator>(Variable v1, Variable v2);
  friend Constraint
  operator>(const Linear_Expression& e, Coefficient_traits::const_reference n);
  friend Constraint
  operator>(Coefficient_traits::const_reference n, const Linear_Expression& e);

  friend Constraint
  operator<(const Linear_Expression& e1, const Linear_Expression& e2);
  friend Constraint
  operator<(const Linear_Expression& e, Coefficient_traits::const_reference n);
  friend Constraint
  operator<(Coefficient_traits::const_reference n, const Linear_Expression& e);

  Constraint(const Constraint& c, dimension_type sz);

  static Constraint construct_epsilon_geq_zero();

  static const Constraint& epsilon_geq_zero();

  static const Constraint& epsilon_leq_one();

  void set_is_equality();


  void set_is_inequality();
};

namespace Parma_Polyhedra_Library {

namespace IO_Operators {


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


std::ostream& operator<<(std::ostream& s, const Constraint::Type& t);

} // namespace IO_Operators

} // namespace Parma_Polyhedra_Library

#include "Constraint.inlines.hh"

#endif // !defined(PPL_Constraint_defs_hh)