/home/mine/apron/apronxx/apxx_interval.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_interval.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_INTERVAL_HH
#define __APXX_INTERVAL_HH

#include <vector>
#include "ap_interval.h"
#include "apxx_scalar.hh"


namespace apron {

struct top { 
  top() {} 
};


struct bottom {
  bottom() {} 
};


/* ================================= */
/* interval                          */
/* ================================= */


class interval : public use_malloc {

protected:
  ap_interval_t c; 

  void init();

  interval(ap_interval_t* i);

  friend class abstract0;
  friend class abstract1;
  friend class linexpr0;
  friend class texpr0;

public:
  
  enum order { 
    INCLUDED = -1, 
    EQUAL    =  0, 
    CONTAINS =  1, 
    LESS     = -2, 
    GREATER  =  2, 
  };


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


  interval();
  
  interval(const interval& x);

  interval(const scalar& inf, const scalar& sup);

  interval(int inf, int sup);

  interval(long inf, long sup);

  interval(double inf, double sup);

  interval(const frac& inf, const frac& sup);

  interval(const mpq_class& inf, const mpq_class& sup);

  interval(mpfr_t inf, mpfr_t sup);

  interval(top t);

  interval(bottom t);



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


  ~interval();



  /* assignments */
  /* =========== */


  /* = */

  interval& operator= (const interval& x);

  interval& operator= (top t);

  interval& operator= (bottom t);


  /* set */

  interval& set(const interval& x);

  interval& set(const scalar& inf, const scalar& sup);

  interval& set(int inf, int sup);

  interval& set(long inf, long sup);

  interval& set(double inf, double sup);

  interval& set(const frac& inf, const frac& sup);

  interval& set(const mpq_class& inf, const mpq_class& sup);

  interval& set(mpfr_t inf, mpfr_t sup);

  interval& set(top t);

  interval& set(bottom t);


  /* swap */

  friend void swap(interval& a, interval &b);



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


  scalar& get_inf();
  
  scalar& get_sup();

  const scalar& get_inf() const;
  
  const scalar& get_sup() const;



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


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

  void print(FILE* stream=stdout) const;



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

  bool is_top() const;

  bool is_bottom() const;

  friend bool operator<= (const interval&a, const interval &b);

  friend bool operator>= (const interval&a, const interval &b);

  friend bool operator< (const interval&a, const interval &b);

  friend bool operator> (const interval&a, const interval &b);

  friend bool operator== (const interval&a, const interval &b);

  friend bool operator!= (const interval&a, const interval &b);

  friend order cmp (const interval&a, const interval &b);


 
  /* other operators */
  /* =============== */


  void neg();

  interval operator- () const;

  long hash() const;



  /* C API compatibility */
  /* =================== */


  const ap_interval_t* get_ap_interval_t() const;

  ap_interval_t* get_ap_interval_t();

};




/* ================================= */
/* interval_array                    */
/* ================================= */


class interval_array : public use_malloc {

protected:

  size_t sz;           
  ap_interval_t** c;   

  interval_array(size_t size, ap_interval_t** c);

  friend class abstract0;
  friend class abstract1;

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


  interval_array(size_t size);

  interval_array(const interval_array &x);

  interval_array(const std::vector<interval>& x);

  interval_array(size_t size, const interval x[]);



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


  ~interval_array();



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


  interval_array& operator= (const interval_array &x);

  interval_array& operator= (const std::vector<interval>& x);

  interval_array& operator= (const interval x[]);



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


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



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


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

  void print(FILE* stream=stdout) const;



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


  size_t size() const;

  interval** contents();

  interval& operator[](size_t i);

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

  interval& get(size_t i);
 
  const interval& get(size_t i) const;



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


  const ap_interval_t * const * get_ap_interval_t_array() const;

  ap_interval_t** get_ap_interval_t_array();

};


#include "apxx_interval_inline.hh"

}

#endif /* __APXX_INTERVAL_HH */