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

  //! Internal initialisation.
  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 */
  /* ============ */

  /** @name Constructors */

  interval();
  
  //! Makes a copy of an interval (bounds are copied).
  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 */
  /* ====== */


  //! Gets a (modifiable) reference to the lower bound.
  scalar& get_inf();
  
  scalar& get_sup();

  //! Gets a reference to the lower bound.
  const scalar& get_inf() const;
  
  const scalar& get_sup() const;

  //@}
 
 
  /* print */
  /* ===== */


  //! Printing.
  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);

  //! Set inclusion.
  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);

  //! Set equality.
  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;

  //! Returns a hash code.
  long hash() const;

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


  //! Returns a pointer to the internal APRON object stored in *this.
  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);

  //! Makes a copy of an interval array (copying all elements).
  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 */
  /* ========== */

  /** @name Assignments */


  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;

  //! Returns a pointer to the start of the array of elements used internally.
  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 */