/home/mine/apron/apronxx/apxx_lincons0.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_lincons0.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_LINCONS0_HH
#define __APXX_LINCONS0_HH

#include <vector>
#include "ap_lincons0.h"
#include "apxx_linexpr0.hh"


namespace apron {


struct unsat {};



/* ================================= */
/* lincons0                          */
/* ================================= */


class lincons0 : public use_malloc {

protected:
  
  ap_lincons0_t l;  

  lincons0(ap_lincons0_t l);

  friend class abstract0;
  
public:

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


  lincons0(ap_constyp_t constyp=AP_CONS_SUPEQ);

  lincons0(ap_constyp_t constyp, const linexpr0& lin);

  lincons0(ap_constyp_t constyp, const linexpr0& lin, const scalar& modulo);

  lincons0(const lincons0& x);

  lincons0(const lincons0& x, const dimchange& d);

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

  lincons0(unsat x);



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


  ~lincons0();

    

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


  lincons0& operator= (const lincons0& x);

  lincons0& operator= (unsat x);

  void set_modulo(const scalar& c);  

  void set_linexpr(const linexpr0& c);



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


  void resize(size_t size);

  void add_dimensions(const dimchange& d);

  void permute_dimensions(const dimperm& d);



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


  /* size */

  size_t size() const;


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

  linexpr0& get_linexpr();
 
  const linexpr0& get_linexpr() const;

  coeff& get_cst();

  const coeff& get_cst() const;

  coeff& operator[](ap_dim_t dim);
  
  const coeff& operator[](ap_dim_t dim) const;



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


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

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


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


  bool is_unsat() const;
  
  bool is_linear() const;

  bool is_quasilinear() const;

  // TODO: equal, compare (currently not in ap_lincons0.h) ???


  /* TODO: evaluation, linearization, intelligent constructors */


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


  const ap_lincons0_t* get_ap_lincons0_t() const;

  ap_lincons0_t* get_ap_lincons0_t();

};



/* ================================= */
/* lincons0_array                    */
/* ================================= */


class lincons0_array : public use_malloc {

protected:

  ap_lincons0_array_t a;  

  lincons0_array(ap_lincons0_array_t& a) : a(a) {}

  friend class lincons1_array;
  friend class abstract0;

public:
  
  /* constructors */
  /* ============ */


  lincons0_array(size_t size);

  lincons0_array(const lincons0_array& x);

  lincons0_array(const lincons0_array& x, const dimchange& d);

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

  lincons0_array(size_t size, const lincons0 x[]);

  lincons0_array(const std::vector<lincons0>& x);



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


  ~lincons0_array();



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


  lincons0_array& operator= (const lincons0_array& x);

  lincons0_array& operator= (const lincons0 x[]);

  lincons0_array& operator= (const std::vector<lincons0>& x);



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


  void resize(size_t size);

  void add_dimensions(const dimchange& d);

  void permute_dimensions(const dimperm& d);



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


  size_t size() const;

  lincons0* contents();

  const lincons0* contents() const;
  
  lincons0& operator[](size_t i);

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

  lincons0& get(size_t i);

  const lincons0& get(size_t i) const;



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

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



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


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

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



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


  bool is_linear() const;

  bool is_quasilinear() const;



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


  const ap_lincons0_array_t* get_ap_lincons0_array_t() const;

  ap_lincons0_array_t* get_ap_lincons0_array_t();


};

#include "apxx_lincons0_inline.hh"

}

#endif /* __APXX_LINCONS0_HH */