/home/mine/apron/apronxx/apxx_coeff.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_coeff.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_COEFF_HH
#define __APXX_COEFF_HH
 
#include "ap_coeff.h"
#include "apxx_scalar.hh"
#include "apxx_interval.hh"
 
 
namespace apron {
 
 
/* ================================= */
/* coeff                             */
/* ================================= */
 


 *
 * A coeff is either a scalar or an interval.
 */
class coeff : public use_malloc {
 
protected:
 
  ap_coeff_t c;  
 
public:
 
 
  /* constructors */
  /* ============ */

  /** @name Constructors */

  coeff();

  //! Makes a copy of a coeff.
  coeff(const coeff& x);

  coeff(const scalar& x);

  //! Makes a MPQ scalar coeff from a native integer.
  coeff(int x);

  coeff(long x);

  //! Makes a double scalar coeff from a double.
  coeff(double x);

  coeff(const frac& x);

  //! Makes a MPQ scalar coeff from a MPQ (copied).
  coeff(const mpq_class& x);
  
  coeff(mpfr_t x);
  
  //! Makes an interval coeff from an interval (copied).
  coeff(const interval& x);

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

  coeff(int inf, int sup);

  //! Makes an interval coeff with MPQ bounds from native integer bounds.
  coeff(long inf, long sup);

  coeff(double inf, double sup);


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

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

  coeff(mpfr_t inf, mpfr_t sup);

  //! Makes an interval coeff representing ]-oo,+oo[.
  coeff(top t);

  coeff(bottom t);

  //@}
 
 
  /* destructor */
  /* ========== */

  /** @name Destructor */
 
  ~coeff();


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


  //@{

  coeff& operator= (const coeff& x);
  
  coeff& operator= (const scalar& x);

  //! Assigns a native integer to *this, setting its type to MPQ scalar coeff.
  coeff& operator= (int x);

  coeff& operator= (long x);

  //! Assigns a double to *this, setting its type to double scalar coeff.
  coeff& operator= (double x);

  coeff& operator= (const frac& x);

  //! Assigns a MPQ to *this, setting its type to MPQ scalar coeff and copying the MPQ.
  coeff& operator= (const mpq_class& x);

  coeff& operator= (mpfr_t x);

  coeff& operator= (const interval& x);

  coeff& operator= (top t);

  coeff& operator= (bottom t);

  coeff& set(const coeff& x);

  coeff& set(const scalar& x);

  coeff& set(int x);


  coeff& set(long x);

  coeff& set(double x) ;


  coeff& set(const frac& x);

  coeff& set(const mpq_class& x);
  

  coeff& set(mpfr_t x);
  
  coeff& set(const interval& x);


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

  coeff& set(int inf, int sup);


  coeff& set(long inf, long sup);

  coeff& set(double inf, double sup);


  coeff& set(const frac& inf, const frac& sup);
  
  coeff& set(const mpq_class& inf, const mpq_class& sup);


  coeff& set(mpfr_t inf, mpfr_t sup);

  coeff& set(top t);


  coeff& set(bottom t);
 

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

  //@}
 
 
  /* access */
  /* ====== */
  
  /** @name Accesses */


  ap_coeff_discr_t get_discr() const;

   * \throw bad_discriminant when the coeff is not of scalar type
   */
  scalar& get_scalar();


   *
   * \throw bad_discriminant when the coeff is not of scalar type
   */
  const scalar& get_scalar() const;
 

  /*! \brief Returns a (modifiable) reference to the interval contained in the coeff.
   *
   * \throw bad_discriminant when the coeff is not of interval type
   */  
  interval& get_interval();

  /*! \brief Returns a reference to the interval contained in the coeff.
   *
   * \throw bad_discriminant when the coeff is not of interval type
   */
  const interval& get_interval() const;

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

  //@{

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


  void print(FILE* stream=stdout) const;
 
 
 
  /* tests */
  /* ===== */



  bool is_zero() const;

  friend int cmp(const coeff& a, const coeff& b);
 
  /*
  //! Set inclusion.
  friend bool operator<= (const coeff& a, const coeff& b);

  friend bool operator>= (const coeff& a, const coeff& b);
  
  //! Strict set inclusion.
  friend bool operator< (const coeff& a, const coeff& b);
  
  friend bool operator> (const coeff& a, const coeff& b);
  */

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

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

  /** @name Operators */

  void reduce();

  //! Negates *this.
  void neg();

  coeff operator- () const;

  long hash() const;

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


  const ap_coeff_t* get_ap_coeff_t() const;

  ap_coeff_t* get_ap_coeff_t();

};
 
#include "apxx_coeff_inline.hh"
 
}
 
#endif /* __APXX_COEFF_HH */