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


class coeff : public use_malloc {

protected:

  ap_coeff_t c;  

public:


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


  coeff();

  coeff(const coeff& x);

  coeff(const scalar& x);

  coeff(int x);

  coeff(long x);

  coeff(double x);

  coeff(const frac& x);

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

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

  coeff(int inf, int sup);

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

  coeff(top t);

  coeff(bottom t);



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


  ~coeff();



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


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

  coeff& operator= (int x);

  coeff& operator= (long x);

  coeff& operator= (double x);

  coeff& operator= (const frac& x);

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

  ap_coeff_discr_t get_discr() const;

  scalar& get_scalar();

  const scalar& get_scalar() const;


  interval& get_interval();

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

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

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



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


  void reduce();

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