/home/mine/apron/apronxx/apxx_tcons0.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_tcons0.hh
 *
 * APRON Library / C++ class wrappers
 *
 * Copyright (C) Antoine Mine' 2007
 *
 */
/* This file is part of the APRON Library, released under LGPL license
   with an exception allowing the redistribution of statically linked
   executables.
  
   Please read the COPYING file packaged in the distribution.
*/
 
#ifndef __APXX_TCONS0_HH
#define __APXX_TCONS0_HH
 
#include "ap_tcons0.h"
#include "apxx_texpr0.hh"
#include "apxx_lincons0.hh"
 
 
namespace apron {
 
/* ================================= */
/* tcons0                            */
/* ================================= */
 


 *
 * A tcons0 represents a constraint of the form expr==0, expr>=0, expr>0, expr!=0, or expr==0 mod c
 * where expr is an arbitrary expression tree.
 * It stores and manages a texpr0, a constraint type (==, >=, >, !=, mod), and (for modulo constraint) 
 * an extra scalar (c).
 *
 * Constraints can be constructed using the >=, <=, >, <, ==, != operators on expression trees, or
 * dedicated constructors:
 * \code 
 * tcons0 x = dim(1) >= dim(2) * 5;
 * tcons0 y = add(sqrt(dim(1),AP_RTYPE_FLOAT), dim(0), AP_RTYPE_FLOAT) != 10;
 * tcons0 y = tcons0(AP_CONS_EQMOD, 3*dim(0)+2*dim(1), 5);
 * \endcode
 * See the documentation of the texpr0 class for more information on constructing expression trees.
 */
class tcons0 : public use_malloc {
 
protected:
  
  ap_tcons0_t l;  

  tcons0(ap_tcons0_t& l);
 
  friend class abstract0;
  
public:
 
  
  /* constructors */
  /* ============ */




  tcons0(ap_constyp_t constyp=AP_CONS_SUPEQ);


  tcons0(ap_constyp_t constyp, const texpr0::builder& t);

  /*! \brief Creates a new constraint from an expression tree and a modulo scalar (both copied).
   *
   * \arg \c constyp can be \c AP_CONS_EQ, \c AP_CONS_SUPEQ, \c AP_CONS_SUP, \c AP_CONS_EQMOD, or \c AP_CONS_DISEQ.
   */
  tcons0(ap_constyp_t constyp, const texpr0::builder& t, const scalar& modulo);

  tcons0(const tcons0& x);

  /*! \brief Makes a (deep) copy of a constraint, and applies a dimension change to the underlying expression.
   *
   * \arg \c add whether to add or remove dimensions.
   */
  tcons0(const tcons0& x, const dimchange& d, bool add=true);


  tcons0(const tcons0& x, const dimperm& d);

  tcons0(unsat x);


   * Real-valued addition and multiplication operators are used (i.e., no rounding).
   */
  tcons0(const lincons0& x);
 

 
  /* destructor */
  /* ========== */



  ~tcons0();

 
  /* 'Intelligent' constructors */
  /* ========================== */

  /** @name 'Intelligent' constructors */

  friend tcons0 operator>=(const texpr0::builder& a, const texpr0::builder& b);


  friend tcons0 operator<=(const texpr0::builder& a, const texpr0::builder& b);

  friend tcons0 operator> (const texpr0::builder& a, const texpr0::builder& b);

  friend tcons0 operator< (const texpr0::builder& a, const texpr0::builder& b);

  friend tcons0 operator==(const texpr0::builder& a, const texpr0::builder& b);

  friend tcons0 operator!=(const texpr0::builder& a, const texpr0::builder& b);
  
 
  /* assignment */
  /* ========== */


  //@{

  tcons0& operator= (const tcons0& x);

  tcons0& operator= (unsat x);

   */
  tcons0& operator= (const lincons0& x);


   * it is created.
   */
  void set_modulo(const scalar& c);  


   * Does not fail as get_texpr can: if the constraint was created without an underlying expression, 
   * it is created.
   */
  void set_texpr(const texpr0::builder& c);


 
 
  /* dimension operations */
  /* ==================== */

  //@{


   */
  void add_dimensions(const dimchange& d);


   * \throw std::invalid_argument if no valid expression tree has been defined.
   */
  void remove_dimensions(const dimchange& d);


   *
   * \throw std::invalid_argument if no valid expression tree has been defined.
   */
  void permute_dimensions(const dimperm& d);

  //@}
 
 
  /* access */
  /* ====== */

  /** @name Accesses */
 
  /* get */
 

   *
   * \return either \c AP_CONS_EQ, \c AP_CONS_SUPEQ, \c AP_CONS_SUP, \c AP_CONS_EQMOD, or \c AP_CONS_DISEQ.
   */
  ap_constyp_t& get_constyp();
  

   *
   * \return either \c AP_CONS_EQ, \c AP_CONS_SUPEQ, \c AP_CONS_SUP, \c AP_CONS_EQMOD, or \c AP_CONS_DISEQ.
   */
  const ap_constyp_t& get_constyp() const;

  bool has_modulo() const;

  bool has_texpr() const;


   * \throw std::invalid_argument if no valid extra scalar has been defined.
   */
  scalar& get_modulo();
 

  const scalar& get_modulo() const;

   *
   * \throw std::invalid_argument if no valid expression tree has been defined.
   */
  texpr0::iterator get_texpr();
 
  texpr0::const_iterator get_texpr() const;
 
 
 
  /* print */
  /* ===== */



   * Variable naming can be configured through the varname stream modifier.
   *
   * \throw std::invalid_argument if the underlying expression is missing, or the
   * extra scalar is missing (for modulo).
   */
  friend std::ostream& operator<< (std::ostream& os, const tcons0& s);

  void print(char** name_of_dim=NULL, FILE* stream=stdout) const;

  //@}
 
  /* tests */
  /* ===== */

  /** @name Tests */


   * \throw std::invalid_argument if no valid expression tree has been defined.
   */
  bool is_interval_cst() const;


  bool is_interval_linear() const;

  /*! \brief Whether the expression is polynomial and there is no rounding.
   *
   * \throw std::invalid_argument if no valid expression tree has been defined.
   */
  bool is_interval_polynomial() const;


  bool is_interval_polyfrac() const;

  bool is_scalar() const;

 
 
  /* C-level compatibility */
  /* ===================== */

  /** @name C API compatibility */

  const ap_tcons0_t* get_ap_tcons0_t() const;


  ap_tcons0_t* get_ap_tcons0_t();
 
 
};
 
 
 
/* ================================= */
/* tcons0_array                    */
/* ================================= */
 


 *
 * A tcons0_array represents an array of constraints on arbitrary expressions.
 */
class tcons0_array : public use_malloc {
 
protected:
 
  ap_tcons0_array_t a;  

  tcons0_array(ap_tcons0_array_t& a) : a(a) {}
 
  friend class abstract0;
  friend class tcons1_array;
 
public:
  
  /* constructors */
  /* ============ */


  tcons0_array(size_t size);

  tcons0_array(const tcons0_array& x);

  tcons0_array(const tcons0_array& x, const dimchange& d, bool add=true);

  tcons0_array(const tcons0_array& x, const dimperm& d);

  tcons0_array(size_t size, const tcons0 x[]);

  tcons0_array(const std::vector<tcons0>& x);


   * Real-valued addition and multiplication operators are used (i.e., no rounding).
   */
  tcons0_array(const lincons0_array& x);

 
 
  /* destructor */
  /* ========== */

  /** @name Destructor */

  ~tcons0_array();

 
 
  /* assignment */
  /* ========== */


  tcons0_array& operator= (const tcons0_array& x);


  tcons0_array& operator= (const tcons0 x[]);

  //! Copies the constraints from the vector into the array, changing its size if needed.
  tcons0_array& operator= (const std::vector<tcons0>& x);


   * Real-valued addition and multiplication operators are used (i.e., no rounding).
   */
  tcons0_array& operator= (const lincons0_array& x);


 
 
  /* dimension operations */
  /* ==================== */

  /** @name Dimension operations */

  void resize(size_t size);

  void add_dimensions(const dimchange& d);

  //! Applies remove_dimensions to all constraints in the array.
  void remove_dimensions(const dimchange& d);

  void permute_dimensions(const dimperm& d);

 
 
  /* access */
  /* ====== */


  //! Returns the size of the array.
  size_t size() const;

  tcons0* contents();

  const tcons0* contents() const;
  

  tcons0& operator[](size_t i);

  const tcons0& operator[](size_t i) const;


   *
   * \throw std::out_of_range if the index is invalid.
   */
  tcons0& get(size_t i);


  const tcons0& get(size_t i) const;

 
 
  /* conversion */
  /* ========== */
  


  operator std::vector<tcons0>() const;

  //@}
 
 
  /* print */
  /* ===== */

 
  

  friend std::ostream& operator<< (std::ostream& os, const tcons0_array& s);

  void print(char** name_of_dim = NULL, FILE* stream=stdout) const;


 
 
  /* tests */
  /* ===== */


  //! Whether all constraints are linear.
  bool is_interval_linear() const;

 
 
  /* C-level compatibility */
  /* ===================== */


  const ap_tcons0_array_t* get_ap_tcons0_array_t() const;

  ap_tcons0_array_t* get_ap_tcons0_array_t();

};
 
#include "apxx_tcons0_inline.hh"
 
}
 
#endif /* __APXX_TCONS0_HH */