/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                          */
/* ================================= */


class lincons1 : public use_malloc {

protected:
  
  ap_lincons1_t l; 

  lincons1(ap_lincons1_t p);


  friend class lincons1_array;

public:


  /* constructors */
  /* ============ */


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

  lincons1(const environment& e, ap_constyp_t constyp=AP_CONS_SUPEQ);

  lincons1(ap_constyp_t constyp, const linexpr1& lin);

  lincons1(ap_constyp_t constyp, const linexpr1& lin, const scalar& modulo);

  lincons1(const environment& e, unsat x);

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

  void set_linexpr(const linexpr1& c);



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


  void extend_environment(const environment& e);


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


  environment get_environment() const;

  const lincons0& get_lincons0() const;

  lincons0& get_lincons0();

  size_t size() const;

  ap_constyp_t& get_constyp();
  
  const ap_constyp_t& get_constyp() const;

  bool has_modulo() const;

  bool has_linexpr() const;

  scalar& get_modulo();
 
  const scalar& get_modulo() const;

  linexpr1 get_linexpr() const;

  coeff& get_cst();

  const coeff& get_cst() const;

  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                    */
/* ================================= */


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

  lincons1_array(const environment& e, size_t size);

  lincons1_array(const lincons1_array& x);

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

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

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

  void extend_environment(const environment& e);



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


  size_t size() const;

  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 */
  /* ========== */
  

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



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


  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 */