Any_Pointset_defs.hh

Go to the documentation of this file.

/* Any_Pointset 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_Any_Pointset_defs_hh
#define PPL_Any_Pointset_defs_hh 1

#include "Any_Pointset_types.hh"
#include "C_Polyhedron_defs.hh"
#include "NNC_Polyhedron_defs.hh"
#include "Grid_defs.hh"
#include "Box_defs.hh"
#include "BD_Shape_defs.hh"
#include "Octagonal_Shape_defs.hh"

namespace Parma_Polyhedra_Library {

namespace IO_Operators {


std::ostream&
operator<<(std::ostream& s, const Any_Pointset& ph);

} // namespace IO_Operators


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

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

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

} // namespace Parma_Polyhedra_Library



class Parma_Polyhedra_Library::Any_Pointset {
public:
#if 0
  static dimension_type max_space_dimension();
#endif

  Any_Pointset();

  Any_Pointset(const Any_Pointset& y);



  virtual dimension_type space_dimension() const = 0;

  virtual dimension_type affine_dimension() const = 0;

  virtual Constraint_System constraints() const = 0;

#if 0
  virtual Congruence_System congruences() const = 0;
#endif

  Poly_Con_Relation relation_with(const Constraint& c) const;

  Poly_Gen_Relation relation_with(const Generator& g) const;

  virtual bool is_empty() const = 0;

  virtual bool is_universe() const = 0;

  virtual bool is_topologically_closed() const = 0;

  virtual bool is_discrete() const = 0;

  virtual bool is_bounded() const = 0;

  virtual bool contains_integer_point() const = 0;

  virtual bool bounds_from_above(const Linear_Expression& expr) const = 0;

  virtual bool bounds_from_below(const Linear_Expression& expr) const = 0;

  virtual bool
  maximize(const Linear_Expression& expr,
           Coefficient& sup_n, Coefficient& sup_d, bool& maximum) const = 0;

  virtual bool maximize(const Linear_Expression& expr,
                        Coefficient& sup_n, Coefficient& sup_d, bool& maximum,
                        Generator& point) const = 0;

  virtual bool
  minimize(const Linear_Expression& expr,
           Coefficient& inf_n, Coefficient& inf_d, bool& minimum) const = 0;

  virtual bool minimize(const Linear_Expression& expr,
                        Coefficient& inf_n, Coefficient& inf_d, bool& minimum,
                        Generator& point) const = 0;


  virtual bool contains(const Any_Pointset& y) const = 0;


  virtual bool strictly_contains(const Any_Pointset& y) const = 0;


  virtual bool is_disjoint_from(const Any_Pointset& y) const = 0;

  virtual bool OK() const = 0;




  virtual void add_constraint(const Constraint& c) = 0;

#if 0

  virtual void add_generator(const Generator& g) = 0;

  virtual void add_grid_generator(const Grid_Generator& g) const = 0;

  virtual void add_congruence(const Congruence& cg) = 0;
#endif

  virtual void add_constraints(const Constraint_System& cs) = 0;

#if 0

  virtual void add_generators(const Generator_System& gs) = 0;

  virtual void add_congruences(const Congruence_System& cgs) = 0;
#endif

  virtual void unconstrain(Variable var) = 0;

  virtual void unconstrain(const Variables_Set& vars) = 0;

  virtual void intersection_assign(const Any_Pointset& y) = 0;


  virtual void upper_bound_assign(const Any_Pointset& y) = 0;

  virtual void difference_assign(const Any_Pointset& y) = 0;

  virtual void affine_image(Variable var,
                            const Linear_Expression& expr,
                            Coefficient_traits::const_reference denominator
                            = Coefficient_one()) = 0;

  virtual void affine_preimage(Variable var,
                               const Linear_Expression& expr,
                               Coefficient_traits::const_reference denominator
                               = Coefficient_one()) = 0;

  virtual
  void generalized_affine_image(Variable var,
                                Relation_Symbol relsym,
                                const Linear_Expression& expr,
                                Coefficient_traits::const_reference denominator
                                = Coefficient_one()) = 0;

  virtual void
  generalized_affine_preimage(Variable var,
                              Relation_Symbol relsym,
                              const Linear_Expression& expr,
                              Coefficient_traits::const_reference denominator
                              = Coefficient_one()) = 0;

  virtual void generalized_affine_image(const Linear_Expression& lhs,
                                        Relation_Symbol relsym,
                                        const Linear_Expression& rhs) = 0;

  virtual void generalized_affine_preimage(const Linear_Expression& lhs,
                                           Relation_Symbol relsym,
                                           const Linear_Expression& rhs) = 0;

  virtual
  void bounded_affine_image(Variable var,
                            const Linear_Expression& lb_expr,
                            const Linear_Expression& ub_expr,
                            Coefficient_traits::const_reference denominator
                            = Coefficient_one()) = 0;

  virtual
  void bounded_affine_preimage(Variable var,
                               const Linear_Expression& lb_expr,
                               const Linear_Expression& ub_expr,
                               Coefficient_traits::const_reference denominator
                               = Coefficient_one()) = 0;

  virtual void time_elapse_assign(const Any_Pointset& y) = 0;

  void topological_closure_assign();

#if 0
  void widening_assign(const Any_Pointset& y, unsigned* tp = 0);

  void limited_H79_extrapolation_assign(const Any_Pointset& y,
                                        const Constraint_System& cs,
                                        unsigned* tp = 0);

  void bounded_H79_extrapolation_assign(const Any_Pointset& y,
                                        const Constraint_System& cs,
                                        unsigned* tp = 0);
#endif




  virtual void add_space_dimensions_and_embed(dimension_type m) = 0;

  virtual void add_space_dimensions_and_project(dimension_type m) = 0;

  virtual void concatenate_assign(const Any_Pointset& y) = 0;


  virtual void remove_space_dimensions(const Variables_Set& vars) = 0;

  virtual
  void remove_higher_space_dimensions(dimension_type new_dimension) = 0;

#if 0

  template <typename Partial_Function>
  void map_space_dimensions(const Partial_Function& pfunc);
#endif


  void expand_space_dimension(Variable var, dimension_type m);


  void fold_space_dimensions(const Variables_Set& vars, Variable dest);


#if 0
  friend bool Parma_Polyhedra_Library::operator==(const Any_Pointset& x,
                                                  const Any_Pointset& y);
#endif



  virtual ~Any_Pointset();

  void m_swap(Any_Pointset& y);

  PPL_OUTPUT_DECLARATIONS

  bool ascii_load(std::istream& s);

  virtual memory_size_type total_memory_in_bytes() const = 0;

  virtual memory_size_type external_memory_in_bytes() const = 0;

  virtual int32_t hash_code() const = 0;

};

#define PPL_ANY_POINTSET_WRAPPER_CLASS(TEMPLATE, WRAPPER_NAME, BASE_CLASS) \
TEMPLATE                                                                \
class WRAPPER_NAME : public Any_Pointset {                              \
 private:                                                               \
  BASE_CLASS x;                                                         \
 public:                                                                \
  explicit WRAPPER_NAME(const C_Polyhedron& y)                          \
    : x(y) {                                                            \
  }                                                                     \
  explicit WRAPPER_NAME(const NNC_Polyhedron& y)                        \
    : x(y) {                                                            \
  }                                                                     \
  template <typename U>                                                 \
  explicit WRAPPER_NAME(const Box<U>& y)                                \
    : x(y) {                                                            \
  }                                                                     \
  template <typename U>                                                 \
  explicit WRAPPER_NAME(const BD_Shape<U>& y)                           \
    : x(y) {                                                            \
  }                                                                     \
  template <typename U>                                                 \
  explicit WRAPPER_NAME(const Octagonal_Shape<U>& y)                    \
    : x(y) {                                                            \
  }                                                                     \
                                                                        \
  explicit WRAPPER_NAME(const Constraint_System& y)                     \
    : x(y) {                                                            \
  }                                                                     \
  explicit WRAPPER_NAME(const Congruence_System& y)                     \
    : x(y) {                                                            \
  }                                                                     \
                                                                        \
  ~WRAPPER_NAME() {                                                     \
  }                                                                     \
                                                                        \
  dimension_type space_dimension() const {                              \
    return x.space_dimension();                                         \
  }                                                                     \
  dimension_type affine_dimension() const {                             \
    return x.space_dimension();                                         \
  }                                                                     \
  Constraint_System constraints() const {                               \
    return x.constraints();                                             \
  }                                                                     \
  Congruence_System congruences() const {                               \
    return x.congruences();                                             \
  }                                                                     \
                                                                        \
  bool is_empty() const {                                               \
    return x.is_empty();                                                \
  }                                                                     \
  bool is_universe() const {                                            \
    return x.is_universe();                                             \
  }                                                                     \
  bool is_bounded() const {                                             \
    return x.is_bounded();                                              \
  }                                                                     \
  bool is_topologically_closed() const {                                \
    return x.is_topologically_closed();                                 \
  }                                                                     \
  bool is_discrete() const {                                            \
    return x.is_discrete();                                             \
  }                                                                     \
  bool contains_integer_point() const {                                 \
    return x.contains_integer_point();                                  \
  }                                                                     \
                                                                        \
  bool contains(const Any_Pointset& y) const {                          \
    return x.contains(dynamic_cast<const BASE_CLASS&>(y));              \
  }                                                                     \
  bool strictly_contains(const Any_Pointset& y) const {                 \
    return x.strictly_contains(dynamic_cast<const BASE_CLASS&>(y));     \
  }                                                                     \
  bool is_disjoint_from(const Any_Pointset& y) const {                  \
    return x.is_disjoint_from(dynamic_cast<const BASE_CLASS&>(y));      \
  }                                                                     \
                                                                        \
  void add_space_dimensions_and_embed(dimension_type m) {               \
    return x.add_space_dimensions_and_embed(m);                         \
  }                                                                     \
  void add_space_dimensions_and_project(dimension_type m) {             \
    return x.add_space_dimensions_and_project(m);                       \
  }                                                                     \
  void remove_space_dimensions(const Variables_Set& vars) {             \
    x.remove_space_dimensions(vars);                                    \
  }                                                                     \
  void remove_higher_space_dimensions(dimension_type new_dimension) {   \
    x.remove_higher_space_dimensions(new_dimension);                    \
  }                                                                     \
                                                                        \
  void add_constraint(const Constraint& c) {                            \
    x.add_constraint(c);                                                \
  }                                                                     \
                                                                        \
  void add_constraints(const Constraint_System& cs) {                   \
    x.add_constraints(cs);                                              \
  }                                                                     \
                                                                        \
  void intersection_assign(const Any_Pointset& y) {                     \
    x.intersection_assign(dynamic_cast<const BASE_CLASS&>(y));          \
  }                                                                     \
  void upper_bound_assign(const Any_Pointset& y) {                      \
    x.upper_bound_assign(dynamic_cast<const BASE_CLASS&>(y));           \
  }                                                                     \
  void difference_assign(const Any_Pointset& y) {                       \
    x.difference_assign(dynamic_cast<const BASE_CLASS&>(y));            \
  }                                                                     \
  void concatenate_assign(const Any_Pointset& y) {                      \
    x.concatenate_assign(dynamic_cast<const BASE_CLASS&>(y));           \
  }                                                                     \
  void time_elapse_assign(const Any_Pointset& y) {                      \
    x.time_elapse_assign(dynamic_cast<const BASE_CLASS&>(y));           \
  }                                                                     \
                                                                        \
  void affine_image(Variable var,                                       \
                    const Linear_Expression& expr,                      \
                    Coefficient_traits::const_reference denominator     \
                    = Coefficient_one()) {                              \
    x.affine_image(var, expr, denominator);                             \
  }                                                                     \
  void affine_preimage(Variable var,                                    \
                       const Linear_Expression& expr,                   \
                       Coefficient_traits::const_reference denominator  \
                       = Coefficient_one()) {                           \
    x.affine_image(var, expr, denominator);                             \
  }                                                                     \
  void generalized_affine_image(Variable var,                           \
                                Relation_Symbol relsym,                 \
                                const Linear_Expression& expr,          \
                                Coefficient_traits::const_reference     \
                                denominator = Coefficient_one()) {      \
    x.generalized_affine_image(var, relsym, expr, denominator);         \
  }                                                                     \
  void                                                                  \
  generalized_affine_preimage(Variable var,                             \
                              Relation_Symbol relsym,                   \
                              const Linear_Expression& expr,            \
                              Coefficient_traits::const_reference denominator \
                              = Coefficient_one()) {                    \
    x.generalized_affine_preimage(var, relsym, expr, denominator);      \
  }                                                                     \
  virtual void generalized_affine_image(const Linear_Expression& lhs,   \
                                        Relation_Symbol relsym,         \
                                        const Linear_Expression& rhs) { \
    x.generalized_affine_image(lhs, relsym, rhs);                       \
  }                                                                     \
  void generalized_affine_preimage(const Linear_Expression& lhs,        \
                                   Relation_Symbol relsym,              \
                                   const Linear_Expression& rhs) {      \
    x.generalized_affine_preimage(lhs, relsym, rhs);                    \
  }                                                                     \
                                                                        \
  void bounded_affine_image(Variable var,                               \
                            const Linear_Expression& lb_expr,           \
                            const Linear_Expression& ub_expr,           \
                            Coefficient_traits::const_reference         \
                            denominator = Coefficient_one()) {          \
    x.bounded_affine_image(var, lb_expr, ub_expr, denominator);         \
  }                                                                     \
  void bounded_affine_preimage(Variable var,                            \
                               const Linear_Expression& lb_expr,        \
                               const Linear_Expression& ub_expr,        \
                               Coefficient_traits::const_reference      \
                               denominator = Coefficient_one()) {       \
    x.bounded_affine_preimage(var, lb_expr, ub_expr, denominator);      \
  }                                                                     \
                                                                        \
  bool bounds_from_above(const Linear_Expression& expr) const {         \
    return x.bounds_from_above(expr);                                   \
  }                                                                     \
  bool bounds_from_below(const Linear_Expression& expr) const {         \
    return x.bounds_from_below(expr);                                   \
  }                                                                     \
  bool maximize(const Linear_Expression& expr,                          \
                Coefficient& sup_n, Coefficient& sup_d,                 \
                bool& maximum) const {                                  \
    return maximize(expr, sup_n, sup_d, maximum);                       \
  }                                                                     \
  bool maximize(const Linear_Expression& expr,                          \
                Coefficient& sup_n, Coefficient& sup_d,                 \
                bool& maximum, Generator& point) const {                \
    return maximize(expr, sup_n, sup_d, maximum, point);                \
  }                                                                     \
  bool minimize(const Linear_Expression& expr,                          \
                Coefficient& inf_n, Coefficient& inf_d,                 \
                bool& minimum) const {                                  \
    return minimize(expr, inf_n, inf_d, minimum);                       \
  }                                                                     \
  bool minimize(const Linear_Expression& expr,                          \
                Coefficient& inf_n, Coefficient& inf_d,                 \
                bool& minimum, Generator& point) const {                \
    return minimize(expr, inf_n, inf_d, minimum, point);                \
  }                                                                     \
                                                                        \
  memory_size_type total_memory_in_bytes() const {                      \
    return x.total_memory_in_bytes();                                   \
  }                                                                     \
  memory_size_type external_memory_in_bytes() const {                   \
    return x.total_memory_in_bytes();                                   \
  }                                                                     \
                                                                        \
  int32_t hash_code() const {                                           \
    return x.hash_code();                                               \
  }                                                                     \
                                                                        \
  bool OK() const {                                                     \
    return x.OK();                                                      \
  }                                                                     \
};

namespace Parma_Polyhedra_Library {

PPL_ANY_POINTSET_WRAPPER_CLASS(, C_Polyhedron_Pointset, C_Polyhedron)
PPL_ANY_POINTSET_WRAPPER_CLASS(, NNC_Polyhedron_Pointset, NNC_Polyhedron)
//PPL_ANY_POINTSET_WRAPPER_CLASS(, Grid_Pointset, Grid)

PPL_ANY_POINTSET_WRAPPER_CLASS(template <typename T>, Box_Pointset, Box<T>)
PPL_ANY_POINTSET_WRAPPER_CLASS(template <typename T>, BD_Shape_Pointset, BD_Shape<T>)
PPL_ANY_POINTSET_WRAPPER_CLASS(template <typename T>, Octagonal_Shape_Pointset, Octagonal_Shape<T>)

//C_Polyhedron_Pointset a(C_Polyhedron(3));
//Octagonal_Shape_Pointset<double> b(C_Polyhedron(3));
//BD_Shape_Pointset<double> c(C_Polyhedron(3));

} // namespace Parma_Polyhedra_Library

#include "Any_Pointset_inlines.hh"
//#include "Any_Pointset_templates.hh"

#endif // !defined(PPL_Any_Pointset_defs_hh)