Grid_Generator_defs.hh

Go to the documentation of this file.

/* Grid_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_Grid_Generator_defs_hh
#define PPL_Grid_Generator_defs_hh 1

#include "Grid_Generator_types.hh"
#include "Grid_types.hh"

#include "Variables_Set_types.hh"
#include "Grid_Generator_System_types.hh"
#include "Linear_System_types.hh"

#include "Coefficient_defs.hh"
#include "Linear_Expression_defs.hh"
#include "Topology_types.hh"
#include "Expression_Hide_Inhomo_defs.hh"
#include "Expression_Hide_Last_defs.hh"

#include "Grid_types.hh"
#include <iosfwd>

namespace Parma_Polyhedra_Library {

// Put these 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 Grid_Generator& x, const Grid_Generator& y);

namespace IO_Operators {


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

} // namespace IO_Operators


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

} // namespace Parma_Polyhedra_Library


class Parma_Polyhedra_Library::Grid_Generator {
public:

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


  static const Representation default_representation = SPARSE;


  static Grid_Generator grid_line(const Linear_Expression& e,
                                  Representation r = default_representation);


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

  // TODO: Improve the documentation of this method.
  static Grid_Generator parameter(Representation r);

  static Grid_Generator parameter(const Linear_Expression& e,
                                  Representation r);


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

  static Grid_Generator grid_point(Representation r);

  static Grid_Generator grid_point(const Linear_Expression& e,
                                   Representation r);

  explicit Grid_Generator(Representation r = default_representation);

  Grid_Generator(const Grid_Generator& g);

  Grid_Generator(const Grid_Generator& g, Representation r);

  Grid_Generator(const Grid_Generator& g, dimension_type space_dim);

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

  ~Grid_Generator();

  Grid_Generator& operator=(const Grid_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);

  /*
    \param cycle
    A vector representing a cycle of the permutation according to which the
    space dimensions must be rearranged.

    The \p cycle vector represents a cycle of a permutation of space
    dimensions.
    For example, the permutation
    \f$ \{ x_1 \mapsto x_2, x_2 \mapsto x_3, x_3 \mapsto x_1 \}\f$ can be
    represented by the vector containing \f$ x_1, x_2, x_3 \f$.
  */
  void permute_space_dimensions(const std::vector<Variable>& cycle);

  void shift_space_dimensions(Variable v, dimension_type n);

  enum Type {
    LINE,
    PARAMETER,
    POINT
  };

  Type type() const;

  bool is_line() const;

  bool is_parameter() const;

  bool is_line_or_parameter() const;

  bool is_point() const;

  bool is_parameter_or_point() const;


  Coefficient_traits::const_reference coefficient(Variable v) const;


  Coefficient_traits::const_reference divisor() const;

  static void initialize();

  static void finalize();

  static const Grid_Generator& zero_dim_point();

  memory_size_type total_memory_in_bytes() const;

  memory_size_type external_memory_in_bytes() const;

  bool is_equivalent_to(const Grid_Generator& y) const;


  bool is_equal_to(const Grid_Generator& y) const;

  bool all_homogeneous_terms_are_zero() const;

  bool OK() const;

  PPL_OUTPUT_DECLARATIONS

  bool ascii_load(std::istream& s);

  void m_swap(Grid_Generator& y);

  void scale_to_divisor(Coefficient_traits::const_reference d);


  void set_divisor(Coefficient_traits::const_reference d);

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

private:
  Linear_Expression expr;

  Kind kind_;

  static const Grid_Generator* zero_dim_point_p;

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

  // TODO: Avoid reducing the space dimension.
  Grid_Generator(Linear_Expression& e, Type t);


  void set_space_dimension_no_ok(dimension_type space_dim);

  bool is_equal_at_dimension(dimension_type dim,
                             const Grid_Generator& gg) const;

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

  void set_is_parameter();

  void set_is_line();

  void set_is_parameter_or_point();


  Topology topology() const;

  bool is_not_necessarily_closed() const;

  bool is_necessarily_closed() const;

  bool is_line_or_equality() const;

  bool is_ray_or_point_or_inequality() const;



  void set_topology(Topology x);

  void set_necessarily_closed();

  void set_not_necessarily_closed();

  void set_is_line_or_equality();

  void set_is_ray_or_point_or_inequality();

  void sign_normalize();

  void strong_normalize();

  bool check_strong_normalized() const;


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

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

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

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

  friend int
  compare(const Grid_Generator& x, const Grid_Generator& y);

  friend class Expression_Adapter<Grid_Generator>;
  friend class Grid_Generator_System;
  friend class Grid;
  friend class Linear_System<Grid_Generator>;
  friend class Scalar_Products;
  friend class Topology_Adjusted_Scalar_Product_Sign;
};


namespace Parma_Polyhedra_Library {

Grid_Generator
grid_line(const Linear_Expression& e,
          Representation r = Grid_Generator::default_representation);

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


Grid_Generator
parameter(Representation r);

Grid_Generator
parameter(const Linear_Expression& e, Representation r);

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


Grid_Generator
grid_point(Representation r);

Grid_Generator
grid_point(const Linear_Expression& e, Representation r);


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


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


namespace IO_Operators {


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

} // namespace IO_Operators

} // namespace Parma_Polyhedra_Library

#include "Grid_Generator_inlines.hh"

#endif // !defined(PPL_Grid_Generator_defs_hh)