/home/mine/apron/apronxx/apxx_tcons1.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_tcons1.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_TCONS1_HH
#define __APXX_TCONS1_HH
 
#include "ap_tcons1.h"
#include "apxx_tcons0.hh"
#include "apxx_texpr1.hh"
 
 
namespace apron {
 
 
/* ================================= */
/* tcons1                            */
/* ================================= */
 

/*! \brief Level 1 arbitrary constraint (ap_tcons1_t wrapper).
 *
 * Level 1 version of arbitrary constraints using expression trees.
 * Variable names (var) are used instead of dimensions (ap_dim_t).
 * Internally, a tcons1 wraps together a tcons0 (memory managed) and an environment (holding a
 * reference count).
 */
class tcons1 : public use_malloc {
 
protected:
  
  ap_tcons1_t l;  

  //! Internal use only. Performs a shallow copy and takes ownership of the contents.
  tcons1(ap_tcons1_t l);
 
  friend class abstract0;
  friend class tcons1_array;
 
public:
 
  
  /* constructors */
  /* ============ */

  /** @name Constructors */

  tcons1(const environment& env, ap_constyp_t constyp=AP_CONS_SUPEQ);


   *
   * The extra scalar is not created (has_modulo returns false).
   * \arg \c constyp can be \c AP_CONS_EQ, \c AP_CONS_SUPEQ, \c AP_CONS_SUP, or \c AP_CONS_DISEQ (but not \c AP_CONS_EQMOD).
   */
  tcons1(ap_constyp_t constyp, const texpr1::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.
   */
  tcons1(ap_constyp_t constyp, const texpr1::builder& t, const scalar& modulo);

  tcons1(const tcons1& x);
 


  tcons1(const tcons1& x, const environment& e);

  tcons1(const environment& e, unsat x);

  tcons1(const lincons1& x);
 

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

  /** @name Destructor */

  ~tcons1();


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


  //! Makes a constraint a-b >= 0.
  friend tcons1 operator>=(const texpr1::builder& a, const texpr1::builder& b);

  friend tcons1 operator<=(const texpr1::builder& a, const texpr1::builder& b);


  friend tcons1 operator> (const texpr1::builder& a, const texpr1::builder& b);

  friend tcons1 operator< (const texpr1::builder& a, const texpr1::builder& b);

  friend tcons1 operator==(const texpr1::builder& a, const texpr1::builder& b);

  friend tcons1 operator!=(const texpr1::builder& a, const texpr1::builder& b);
  
  //@}
 
  /* assignment */
  /* ========== */



  tcons1& operator= (const tcons1& x);

  tcons1& operator= (unsat x);


   * Real-valued addition and multiplication operators are used (i.e., no rounding).
   */
  tcons1& operator= (const lincons1& 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 texpr1::builder& c);

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


  void extend_environment(const environment& e);

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

  /** @name Accesses */
 
  /* get */
 
  //! Returns the environment of the expression (with incremented reference count).
  environment get_environment() const;

  const tcons0& get_tcons0() const;

  tcons0& get_tcons0();


   *
   * \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();
  
  /*! \brief Returns a reference to the constraint type.
   *
   * \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;


   */
  scalar& get_modulo();
 

   */
  const scalar& get_modulo() const;


   */
  texpr1::iterator get_texpr();
 

   */
  texpr1::const_iterator get_texpr() const;
 
 
 
  /* print */
  /* ===== */


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

  void print(FILE* stream=stdout) const;

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



   */
  bool is_interval_cst() const;


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


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

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


  bool is_scalar() const;

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


  //@{

  const ap_tcons1_t* get_ap_tcons1_t() const;

  ap_tcons1_t* get_ap_tcons1_t();
 
 
};
 
 
 
/* ================================= */
/* tcons1_array                    */
/* ================================= */
 


 * A tcons1_array represents an array of constraints on arbitrary expressions.
 * An constraints share the same environment.
 */
class tcons1_array : public use_malloc {
 
protected:
 
  ap_tcons1_array_t a;  

  tcons1_array(ap_tcons1_array_t& a);
 
  friend class abstract0;
  friend class abstract1;
 
public:
  
  /* constructors */
  /* ============ */

  //@{

  tcons1_array(const environment& e, const tcons0_array& x);


   * has_modulo and has_texpr will return false on all elements of the array.
   */
  tcons1_array(const environment& e, size_t size);

  tcons1_array(const tcons1_array& x);


   * \throw std::invalid_argument if e is not a super-environment of that of x.
   */
  tcons1_array(const tcons1_array& x, const environment& e);
 


  tcons1_array(size_t size, const tcons1 x[]);

   * \warning assumes that all constraints have the same environment (unchecked).
   * \throw std::invalid_argument if vector size<1.
   */
  tcons1_array(const std::vector<tcons1>& x);

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


  ~tcons1_array();

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


  tcons1_array& operator= (const tcons1_array& x);


   * \arg x should contain (at least) size elements.
   */
  tcons1_array& operator= (const tcons1 x[]);

  tcons1_array& operator= (const std::vector<tcons1>& x);

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



  void resize(size_t size);


  void extend_environment(const environment& e);

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


  size_t size() const;

  environment get_environment() const;

  //! Returns a reference to the underlying tcons0_array.
  const tcons0_array& get_tcons0_array() const;

  tcons0_array& get_tcons0_array();


  tcons1 get(size_t i) const;


   * \throw std::out_of_range if i exceeds the dimension of the array.
   */
  void set(size_t i, const tcons1& x);

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

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

 
 
  /* print */
  /* ===== */


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

  void print(FILE* stream=stdout) const;

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



  const ap_tcons1_array_t* get_ap_tcons1_array_t() const;

  ap_tcons1_array_t* get_ap_tcons1_array_t();

 
};
 
#include "apxx_tcons1_inline.hh"
 
}
 
#endif /* __APXX_TCONS1_HH */