/home/mine/apron/apronxx/apxx_lincons1.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_lincons1.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_LINCONS1_HH
#define __APXX_LINCONS1_HH
 
#include "ap_lincons1.h"
#include "apxx_environment.hh"
#include "apxx_lincons0.hh"
#include "apxx_linexpr1.hh"
 
 
namespace apron {
 
 
/* ================================= */
/* lincons1                          */
/* ================================= */
 


 * Internally, a lincons1 wraps together a lincons0 (memory managed) and an environment (holding a
 * reference count).
 */
class lincons1 : public use_malloc {
 
protected:
  
  ap_lincons1_t l; 

  lincons1(ap_lincons1_t p);
 
 
  friend class lincons1_array;
 
public:
 
 
  /* constructors */
  /* ============ */



   * incremented) associating names to dimensions in lincons0.
   */
  lincons1(const environment& e, const lincons0& x);


   *
   * The auxiliary scalar is not created (has_modulo returns false).
   * The linear expression is created sparse and empty (has_linexpr returns true).
   * \arg \c e associates a variable name to each dimension (reference counter incremented).
   * \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).
   */
  lincons1(const environment& e, ap_constyp_t constyp=AP_CONS_SUPEQ);


  lincons1(ap_constyp_t constyp, const linexpr1& lin);

  /*! \brief Creates a new constraint from a linear expression 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.
   */
  lincons1(ap_constyp_t constyp, const linexpr1& lin, const scalar& modulo);

  lincons1(const environment& e, unsat x);

  //! (Deep) copy of a constraint.
  lincons1(const lincons1& x);

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

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


  //@{

  
  ~lincons1();

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

  //@{

  lincons1& operator= (const lincons1& x);

  lincons1& operator= (unsat x);


  void set_modulo(const scalar& c);  

  /*! \brief Sets the underlying linear expression to c (copied).
   *
   * Does not fail as get_linexpr can: if the constraint was created without an underlying expression, 
   * it is created.
   *
   * \warning assumes that c and *this have equal environments (unchecked).
   */
  void set_linexpr(const linexpr1& c);


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

  /** @name Dimension operations */


   * \throw std::invalid_argument if e is not a super-environment of that of *this.
   */
  void extend_environment(const environment& e);


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

  /** @name Accesses, size */

  environment get_environment() const;

  const lincons0& get_lincons0() const;


  lincons0& get_lincons0();

  size_t size() const;

  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_linexpr() const;

  scalar& get_modulo();
 
  /*! \brief Returns a reference to the auxiliary scalar.
   *
   * \throw std::invalid_argument if no valid auxiliary scalar has been defined.
   */
  const scalar& get_modulo() const;

  linexpr1 get_linexpr() const;

  coeff& get_cst();


  const coeff& get_cst() const;

   * \throw std::invalid_argument if the variable name is not present in the environment.
   * \throw std::invalid_argument if no valid linear expression has been defined.
   */
  coeff& operator[](const var& v);
  
  const coeff& operator[](const var& v) const;


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


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

  void print(FILE* stream=stdout) const;

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



 
  bool is_unsat() const;
  

   */
  bool is_linear() const;


  bool is_quasilinear() const;
 
  // TODO: equal, compare (currently not in ap_lincons1.h) ???

 
 
  /* TODO: evaluation, linearization, intelligent constructors */
 
 
  /* C-level compatibility */
  /* ===================== */


  const ap_lincons1_t* get_ap_lincons1_t() const;


  ap_lincons1_t* get_ap_lincons1_t();

};
 
 
 
/* ================================= */
/* lincons1_array                    */
/* ================================= */
 


 *
 * Level 1 version of linear constraint arrays.
 * Internally, a lincons1_array wraps together a lincons0_array (memory managed) and an environment 
 * (holding a reference count).
 * Please note that all constraints share the same environment!
 */
class lincons1_array : public use_malloc {
 
protected:
 
  ap_lincons1_array_t a;  

  lincons1_array(ap_lincons1_array_t& a);
 
  friend class abstract1;
 
public:
  
  /* constructors */
  /* ============ */



  lincons1_array(const environment& e, const lincons0_array& x);

   * has_modulo and has_linexpr will return false on all elements of the array.
   * \arg \c e associates a variable name to each dimension (reference count incremented).
   */
  lincons1_array(const environment& e, size_t size);

  lincons1_array(const lincons1_array& x);

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

  lincons1_array(size_t size, const lincons1 x[]);

  /*! \brief Creates a lincons1_array from an vector (of size >0) of constraints of the given size (copied).
   *
   * \warning assumes that all constraints have the same environment (unchecked).
   * \throw std::invalid_argument if vector size<1.
   */
  lincons1_array(const std::vector<lincons1>& x);

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


  ~lincons1_array();

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



  lincons1_array& operator= (const lincons1_array& x);


   */
  lincons1_array& operator= (const lincons1 x[]);

  lincons1_array& operator= (const std::vector<lincons1>& x);

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



  void resize(size_t size);


   *
   * \throw std::invalid_argument if e is not a super-environment of that of *this.
   */
  void extend_environment(const environment& e);

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


  size_t size() const;

  //! Returns the environment shared by all constraints (with incremented reference count).
  environment get_environment() const;

  const lincons0_array& get_lincons0_array() const;

  lincons0_array& get_lincons0_array();

   */
  lincons1 get(size_t i) const;

  void set(size_t i, const lincons1& x);

 
 
  /* conversion */
  /* ========== */
  
  /** @name Conversion */

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

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



   * auxiliary scalar is missing (for modulo constraint).
   */
  friend std::ostream& operator<< (std::ostream& os, const lincons1_array& s);


  void print(FILE* stream=stdout) const;

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


  const ap_lincons1_array_t* get_ap_lincons1_array_t() const;

  ap_lincons1_array_t* get_ap_lincons1_array_t();

 
};
 
 
#include "apxx_lincons1_inline.hh"
 
}
 
#endif /* __APXX_LINCONS1_HH */