Linear_Row.defs.hh

Go to the documentation of this file.

/* Linear_Row 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_Linear_Row_defs_hh
#define PPL_Linear_Row_defs_hh 1

#include "Linear_Row.types.hh"
#include "globals.defs.hh"
#include "Dense_Row.defs.hh"
#include "Topology.types.hh"
#include "Linear_Expression.types.hh"
#include "Constraint.types.hh"
#include "Generator.types.hh"

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS


#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)

class Parma_Polyhedra_Library::Linear_Row : public Dense_Row {
public:
  enum Kind {
    LINE_OR_EQUALITY = 0,
    RAY_OR_POINT_OR_INEQUALITY = 1
  };

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS

#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
  class Flags : public Dense_Row::Flags {
  public:
    Flags();

    explicit Flags(Topology t);

    Flags(Topology t, Kind k);


    Topology topology() const;
    bool is_necessarily_closed() const;
    bool is_not_necessarily_closed() const;
    bool is_line_or_equality() const;
    bool is_ray_or_point_or_inequality() const;

    void set_necessarily_closed();
    void set_not_necessarily_closed();
    void set_is_line_or_equality();
    void set_is_ray_or_point_or_inequality();

    bool operator==(const Flags& y) const;

    bool operator!=(const Flags& y) const;

    PPL_OUTPUT_DECLARATIONS

    bool ascii_load(std::istream& s);

  private:
    explicit Flags(base_type mask);

    explicit Flags(Dense_Row::Flags flags);


    // NB: ascii_load assumes that these are sequential.
    static const unsigned rpi_validity_bit
    = Dense_Row::Flags::first_free_bit + 0;
    static const unsigned rpi_bit
    = Dense_Row::Flags::first_free_bit + 1;
    static const unsigned nnc_validity_bit
    = Dense_Row::Flags::first_free_bit + 2;
    static const unsigned nnc_bit
    = Dense_Row::Flags::first_free_bit + 3;

  protected:
    static const unsigned first_free_bit
    = Dense_Row::Flags::first_free_bit + 4;

    friend class Parma_Polyhedra_Library::Linear_Row;
  };

  Linear_Row();

  Linear_Row(dimension_type sz, Flags f);

  Linear_Row(dimension_type sz, dimension_type capacity, Flags f);

  Linear_Row(const Linear_Row& y);


  Linear_Row(const Linear_Row& y, dimension_type capacity);


  Linear_Row(const Linear_Row& y, dimension_type sz, dimension_type capacity);

  ~Linear_Row();



  const Flags flags() const;

  void set_flags(Flags f);

  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_necessarily_closed();

  void set_not_necessarily_closed();

  void set_is_line_or_equality();

  void set_is_ray_or_point_or_inequality();

  static dimension_type max_space_dimension();

  dimension_type space_dimension() const;

  Coefficient_traits::const_reference inhomogeneous_term() const;

  Coefficient_traits::const_reference coefficient(dimension_type n) const;

  void sign_normalize();

  void strong_normalize();

  bool check_strong_normalized() const;


  void linear_combine(const Linear_Row& y, dimension_type k);

  bool is_zero() const;

  bool all_homogeneous_terms_are_zero() const;

  PPL_OUTPUT_DECLARATIONS

  bool ascii_load(std::istream& s);

  bool OK() const;

  bool OK(dimension_type row_size, dimension_type row_capacity) const;

private:
  friend class Parma_Polyhedra_Library::Linear_Expression;
  friend class Parma_Polyhedra_Library::Constraint;
  friend class Parma_Polyhedra_Library::Generator;
};

namespace Parma_Polyhedra_Library {

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS


#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
void swap(Linear_Row& x, Linear_Row& y);

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS


#endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
void iter_swap(std::vector<Linear_Row>::iterator x,
               std::vector<Linear_Row>::iterator y);


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


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

#ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS


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

} // namespace Parma_Polyhedra_Library

#include "Linear_Row.inlines.hh"

#endif // !defined(PPL_Linear_Row_defs_hh)