Generator_defs.hh

Go to the documentation of this file.

/* Generator 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_Generator_defs_hh
#define PPL_Generator_defs_hh 1

#include "Generator_types.hh"
#include "Scalar_Products_types.hh"
#include "Variables_Set_types.hh"
#include "Constraint_System_types.hh"
#include "Generator_System_types.hh"
#include "Congruence_System_types.hh"
#include "Polyhedron_types.hh"
#include "Grid_Generator_types.hh"
#include "Grid_Generator_System_types.hh"
#include "MIP_Problem_types.hh"
#include "Grid_types.hh"

#include "Variable_defs.hh"
#include "Linear_Expression_defs.hh"
#include "Checked_Number_defs.hh"
#include "distances_defs.hh"
#include "Topology_types.hh"
#include "Expression_Hide_Last_defs.hh"
#include "Expression_Hide_Inhomo_defs.hh"

#include <iosfwd>

namespace Parma_Polyhedra_Library {

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

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
int compare(const Generator& x, const Generator& y);

namespace IO_Operators {


std::ostream& operator<<(std::ostream& s, const Generator& g);

} // namespace IO_Operators


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

} // namespace Parma_Polyhedra_Library



class Parma_Polyhedra_Library::Generator {
public:


  static const Representation default_representation = SPARSE;


  static Generator line(const Linear_Expression& e,
                        Representation r = default_representation);


  static Generator ray(const Linear_Expression& e,
                       Representation r = default_representation);


  static Generator point(const Linear_Expression& e
                         = Linear_Expression::zero(),
                         Coefficient_traits::const_reference d
                         = Coefficient_one(),
                         Representation r = default_representation);

  static Generator point(Representation r);

  static Generator point(const Linear_Expression& e,
                         Representation r);

  explicit Generator(Representation r = default_representation);


  static Generator
  closure_point(const Linear_Expression& e = Linear_Expression::zero(),
                Coefficient_traits::const_reference d = Coefficient_one(),
                Representation r = default_representation);

  static Generator
  closure_point(Representation r);

  static Generator
  closure_point(const Linear_Expression& e, Representation r);

  Generator(const Generator& g);

  Generator(const Generator& g, Representation r);

  Generator(const Generator& g, dimension_type space_dim);

  Generator(const Generator& g, dimension_type space_dim, Representation r);

  ~Generator();

  Generator& operator=(const Generator& g);

  Representation representation() const;

  void set_representation(Representation r);

  static dimension_type max_space_dimension();

  dimension_type space_dimension() const;

  void set_space_dimension(dimension_type space_dim);

  void swap_space_dimensions(Variable v1, Variable v2);


  bool remove_space_dimensions(const Variables_Set& vars);


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

  void shift_space_dimensions(Variable v, dimension_type n);

  enum Type {
    LINE,
    RAY,
    POINT,
    CLOSURE_POINT
  };

  Type type() const;

  bool is_line() const;

  bool is_ray() const;

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
  bool is_line_or_ray() const;

  bool is_point() const;

  bool is_closure_point() const;


  Coefficient_traits::const_reference coefficient(Variable v) const;


  Coefficient_traits::const_reference divisor() const;

  static void initialize();

  static void finalize();

  static const Generator& zero_dim_point();

  static const Generator& zero_dim_closure_point();

  memory_size_type total_memory_in_bytes() const;

  memory_size_type external_memory_in_bytes() const;

  bool is_equivalent_to(const Generator& y) const;


  bool is_equal_to(const Generator& y) const;

  bool OK() const;

  PPL_OUTPUT_DECLARATIONS

  bool ascii_load(std::istream& s);

  void m_swap(Generator& y);

  typedef Expression_Hide_Last<Expression_Hide_Inhomo<Linear_Expression> >
  expr_type;
  expr_type expression() const;

private:
  enum Kind {
    LINE_OR_EQUALITY = 0,
    RAY_OR_POINT_OR_INEQUALITY = 1
  };

  Linear_Expression expr;

  Kind kind_;

  Topology topology_;

  static const Generator* zero_dim_point_p;

  static const Generator* zero_dim_closure_point_p;

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

  Generator(Linear_Expression& e, Kind kind, Topology topology);

  Generator(dimension_type space_dim, Kind kind, Topology topology,
            Representation r = default_representation);

  bool is_line_or_equality() const;

  bool is_ray_or_point_or_inequality() const;

  void set_is_line_or_equality();

  void set_is_ray_or_point_or_inequality();


  Topology topology() const;

  bool is_not_necessarily_closed() const;

  bool is_necessarily_closed() const;



  void set_topology(Topology x);

  void set_necessarily_closed();

  void set_not_necessarily_closed();


  void mark_as_necessarily_closed();


  void mark_as_not_necessarily_closed();


  void linear_combine(const Generator& y, dimension_type i);


  void set_space_dimension_no_ok(dimension_type space_dim);

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

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

  bool is_ray_or_point() const;

  void set_is_line();

  void set_is_ray_or_point();

  bool is_matching_closure_point(const Generator& p) const;

  Coefficient_traits::const_reference epsilon_coefficient() const;

  void set_epsilon_coefficient(Coefficient_traits::const_reference n);

  void sign_normalize();

  void strong_normalize();

  bool check_strong_normalized() const;

  void fancy_print(std::ostream& s) const;

  friend class Expression_Adapter<Generator>;
  friend class Linear_System<Generator>;
  friend class Parma_Polyhedra_Library::Scalar_Products;
  friend class Parma_Polyhedra_Library::Topology_Adjusted_Scalar_Product_Sign;
  friend class Parma_Polyhedra_Library::Topology_Adjusted_Scalar_Product_Assign;
  friend class Parma_Polyhedra_Library::Generator_System;
  friend class Parma_Polyhedra_Library::Generator_System_const_iterator;
  // FIXME: the following friend declaration should be avoided.
  friend class Parma_Polyhedra_Library::Polyhedron;
  // This is for access to Linear_Expression in `insert'.
  friend class Parma_Polyhedra_Library::Grid_Generator_System;
  friend class Parma_Polyhedra_Library::MIP_Problem;
  friend class Parma_Polyhedra_Library::Grid;

  friend std::ostream&
  Parma_Polyhedra_Library::IO_Operators::operator<<(std::ostream& s,
                                                    const Generator& g);

  friend int
  compare(const Generator& x, const Generator& y);
};


namespace Parma_Polyhedra_Library {


Generator line(const Linear_Expression& e,
               Representation r = Generator::default_representation);


Generator ray(const Linear_Expression& e,
              Representation r = Generator::default_representation);

Generator
point(const Linear_Expression& e = Linear_Expression::zero(),
      Coefficient_traits::const_reference d = Coefficient_one(),
      Representation r = Generator::default_representation);


Generator
point(Representation r);

Generator
point(const Linear_Expression& e, Representation r);

Generator
closure_point(const Linear_Expression& e = Linear_Expression::zero(),
              Coefficient_traits::const_reference d = Coefficient_one(),
              Representation r = Generator::default_representation);


Generator
closure_point(Representation r);

Generator
closure_point(const Linear_Expression& e, Representation r);


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


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


template <typename To>
bool rectilinear_distance_assign(Checked_Number<To, Extended_Number_Policy>& r,
                                 const Generator& x,
                                 const Generator& y,
                                 Rounding_Dir dir);


template <typename Temp, typename To>
bool rectilinear_distance_assign(Checked_Number<To, Extended_Number_Policy>& r,
                                 const Generator& x,
                                 const Generator& y,
                                 Rounding_Dir dir);


template <typename Temp, typename To>
bool rectilinear_distance_assign(Checked_Number<To, Extended_Number_Policy>& r,
                                 const Generator& x,
                                 const Generator& y,
                                 Rounding_Dir dir,
                                 Temp& tmp0,
                                 Temp& tmp1,
                                 Temp& tmp2);


template <typename To>
bool euclidean_distance_assign(Checked_Number<To, Extended_Number_Policy>& r,
                               const Generator& x,
                               const Generator& y,
                               Rounding_Dir dir);


template <typename Temp, typename To>
bool rectilinear_distance_assign(Checked_Number<To, Extended_Number_Policy>& r,
                                 const Generator& x,
                                 const Generator& y,
                                 Rounding_Dir dir);


template <typename Temp, typename To>
bool euclidean_distance_assign(Checked_Number<To, Extended_Number_Policy>& r,
                               const Generator& x,
                               const Generator& y,
                               Rounding_Dir dir,
                               Temp& tmp0,
                               Temp& tmp1,
                               Temp& tmp2);


template <typename To>
bool l_infinity_distance_assign(Checked_Number<To, Extended_Number_Policy>& r,
                                const Generator& x,
                                const Generator& y,
                                Rounding_Dir dir);


template <typename Temp, typename To>
bool l_infinity_distance_assign(Checked_Number<To, Extended_Number_Policy>& r,
                                const Generator& x,
                                const Generator& y,
                                Rounding_Dir dir);


template <typename Temp, typename To>
bool l_infinity_distance_assign(Checked_Number<To, Extended_Number_Policy>& r,
                                const Generator& x,
                                const Generator& y,
                                Rounding_Dir dir,
                                Temp& tmp0,
                                Temp& tmp1,
                                Temp& tmp2);

namespace IO_Operators {


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

} // namespace IO_Operators

} // namespace Parma_Polyhedra_Library

#include "Generator_inlines.hh"

#endif // !defined(PPL_Generator_defs_hh)