Linear_Expression.defs.hh

Go to the documentation of this file.

/* Linear_Expression 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_Expression_defs_hh
#define PPL_Linear_Expression_defs_hh 1

#include "Linear_Expression.types.hh"
#include "Scalar_Products.types.hh"
#include "Constraint.types.hh"
#include "Generator.types.hh"
#include "Congruence.types.hh"
#include "Grid_Generator.types.hh"
#include "Linear_Row.defs.hh"
#include "Coefficient.types.hh"
#include "Variable.defs.hh"
#include "Constraint_System.types.hh"
#include "Generator_System.types.hh"
#include "Congruence_System.types.hh"
#include "Grid_Generator_System.types.hh"
#include "Polyhedron.types.hh"
#include "Grid.types.hh"
#include <cstddef>

namespace Parma_Polyhedra_Library {


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

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


Linear_Expression
operator+(const Linear_Expression& e1, const Linear_Expression& e2);


Linear_Expression
operator+(Variable v, Variable w);


Linear_Expression
operator+(Variable v, const Linear_Expression& e);


Linear_Expression
operator+(const Linear_Expression& e, Variable v);


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


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


Linear_Expression
operator+(const Linear_Expression& e);


Linear_Expression
operator-(const Linear_Expression& e);


Linear_Expression
operator-(const Linear_Expression& e1, const Linear_Expression& e2);


Linear_Expression
operator-(Variable v, Variable w);


Linear_Expression
operator-(Variable v, const Linear_Expression& e);


Linear_Expression
operator-(const Linear_Expression& e, Variable v);


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


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


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


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


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


Linear_Expression&
operator+=(Linear_Expression& e, Variable v);


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


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


Linear_Expression&
operator-=(Linear_Expression& e, Variable v);


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


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


Linear_Expression&
add_mul_assign(Linear_Expression& e,
               Coefficient_traits::const_reference n, Variable v);


Linear_Expression&
sub_mul_assign(Linear_Expression& e,
               Coefficient_traits::const_reference n, Variable v);

namespace IO_Operators {


std::ostream& operator<<(std::ostream& s, const Linear_Expression& e);

} // namespace IO_Operators

} // namespace Parma_Polyhedra_Library


class Parma_Polyhedra_Library::Linear_Expression : private Linear_Row {
public:
  Linear_Expression();

  Linear_Expression(const Linear_Expression& e);

  ~Linear_Expression();

  explicit Linear_Expression(Coefficient_traits::const_reference n);


  Linear_Expression(Variable v);


  explicit Linear_Expression(const Constraint& c);

  explicit Linear_Expression(const Generator& g);

  explicit Linear_Expression(const Grid_Generator& g);


  explicit Linear_Expression(const Congruence& cg);

  static dimension_type max_space_dimension();

  dimension_type space_dimension() const;

  Coefficient_traits::const_reference coefficient(Variable v) const;

  Coefficient_traits::const_reference inhomogeneous_term() const;

  bool is_zero() const;

  bool all_homogeneous_terms_are_zero() const;

  static void initialize();

  static void finalize();

  static const Linear_Expression& zero();

  memory_size_type total_memory_in_bytes() const;

  memory_size_type external_memory_in_bytes() const;

  PPL_OUTPUT_DECLARATIONS

  bool ascii_load(std::istream& s);

  bool OK() const;

  void m_swap(Linear_Expression& y);

private:
  static const Linear_Expression* zero_p;

  friend class Parma_Polyhedra_Library::Scalar_Products;
  friend class Parma_Polyhedra_Library::Constraint;
  friend class Parma_Polyhedra_Library::Generator;
  // The following declaration grants access to Grid_Generator::parameter.
  friend class Parma_Polyhedra_Library::Grid_Generator;
  friend class Parma_Polyhedra_Library::Congruence;
  // FIXME: the following friend declaration should be avoided.
  friend class Parma_Polyhedra_Library::Polyhedron;
  friend class Parma_Polyhedra_Library::Grid;

  // FIXME: the following friend declaration is only to grant access to
  // Constraint_System::affine_preimage().
  friend class Parma_Polyhedra_Library::Constraint_System;

  // FIXME: the following friend declaration is only to grant access to
  // Generator_System::affine_image().
  friend class Parma_Polyhedra_Library::Generator_System;

  // FIXME: the following friend declaration is only to grant access to
  // Congruence_System::affine_preimage().
  friend class Parma_Polyhedra_Library::Congruence_System;

  // FIXME: the following friend declaration is only to grant access to
  // Grid_Generator_System::affine_image().
  friend class Parma_Polyhedra_Library::Grid_Generator_System;

  Linear_Expression(const Linear_Expression& e, dimension_type sz);


  Linear_Expression(dimension_type sz, bool);

  Linear_Expression(Variable v, Variable w);

  friend Linear_Expression
  operator+(const Linear_Expression& e1, const Linear_Expression& e2);
  friend Linear_Expression
  operator+(Coefficient_traits::const_reference n, const Linear_Expression& e);
  friend Linear_Expression
  operator+(const Linear_Expression& e, Coefficient_traits::const_reference n);
  friend Linear_Expression
  operator+(Variable v, const Linear_Expression& e);
  friend Linear_Expression
  operator+(Variable v, Variable w);

  friend Linear_Expression
  operator-(const Linear_Expression& e);

  friend Linear_Expression
  operator-(const Linear_Expression& e1, const Linear_Expression& e2);
  friend Linear_Expression
  operator-(Variable v, Variable w);
  friend Linear_Expression
  operator-(Coefficient_traits::const_reference n, const Linear_Expression& e);
  friend Linear_Expression
  operator-(const Linear_Expression& e, Coefficient_traits::const_reference n);
  friend Linear_Expression
  operator-(Variable v, const Linear_Expression& e);
  friend Linear_Expression
  operator-(const Linear_Expression& e, Variable v);

  friend Linear_Expression
  operator*(Coefficient_traits::const_reference n, const Linear_Expression& e);
  friend Linear_Expression
  operator*(const Linear_Expression& e, Coefficient_traits::const_reference n);

  friend Linear_Expression&
  operator+=(Linear_Expression& e1, const Linear_Expression& e2);
  friend Linear_Expression&
  operator+=(Linear_Expression& e, Variable v);
  friend Linear_Expression&
  operator+=(Linear_Expression& e, Coefficient_traits::const_reference n);

  friend Linear_Expression&
  operator-=(Linear_Expression& e1, const Linear_Expression& e2);
  friend Linear_Expression&
  operator-=(Linear_Expression& e, Variable v);
  friend Linear_Expression&
  operator-=(Linear_Expression& e, Coefficient_traits::const_reference n);

  friend Linear_Expression&
  operator*=(Linear_Expression& e, Coefficient_traits::const_reference n);

  friend Linear_Expression&
  add_mul_assign(Linear_Expression& e,
                 Coefficient_traits::const_reference n, Variable v);
  friend Linear_Expression&
  sub_mul_assign(Linear_Expression& e,
                 Coefficient_traits::const_reference n, Variable v);

  friend std::ostream&
  Parma_Polyhedra_Library::IO_Operators
  ::operator<<(std::ostream& s, const Linear_Expression& e);
};

#include "Linear_Expression.inlines.hh"

#endif // !defined(PPL_Linear_Expression_defs_hh)