/home/mine/apron/apronxx/apxx_scalar.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_scalar.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_SCALAR_HH
#define __APXX_SCALAR_HH
 
#include <stdlib.h>
#include <iostream>
 
#include "ap_scalar.h"
#include "gmpxx.h"
 
 
namespace apron {
 


struct infty {
 
  int sgn;  

  infty(int sgn=1) : sgn(sgn) {}; 
 
};
 

struct frac {
 
  long num;          
  unsigned long den; 


  frac(long num, unsigned long den=1) : num(num), den(den) {}
 
};
 

class bad_discriminant : public std::logic_error {
public:
  /*! \arg \c arg: Reason of failure.
   */
  bad_discriminant(const std::string &arg) : logic_error(arg) {}
};
 
 
/* ================================= */
/* use_malloc                        */
/* ================================= */
 

//! Inherited by most wrappers to map new and delete to malloc and free.
struct use_malloc {
  void* operator new     (size_t sz);
  void* operator new[]   (size_t sz);
  void  operator delete  (void* p);
  void  operator delete[](void* p);
};
 
 
 
/* ================================= */
/* scalar                            */
/* ================================= */
 


 * or a MPQ (multi-precision fraction).
 * All operations are exact unless explicitly noted.
 */
class scalar : public use_malloc {
  
protected:
  ap_scalar_t c; 
  
public:

  enum order { 
    LESS    = -1, 
    EQUAL   =  0, 
    GREATER =  1, 
  };
 
 
  /* constructors */
  /* ============ */


  scalar();

  scalar(int x);

  scalar(long x);

  scalar(double x);

  scalar(const frac& x);

  //! Makes a double scalar equal to +oo or -oo.
  scalar(infty x);
  
  scalar(const mpq_class& x);

  //! Makes a MPFR scalar from a MPFR number (copied).
  scalar(mpfr_t x);

  scalar(const scalar& x);

  //@}
 
 
  /* destructor */
  /* ========== */
  
  /** @name Destructor */
 
  ~scalar();


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


  //@{

  scalar& operator= (int x);


  scalar& operator= (long x);

  scalar& operator= (double x);


  scalar& operator= (const frac& x);

  scalar& operator= (infty x);


  scalar& operator= (const mpq_class& x);

  scalar& operator= (mpfr_t x);

  scalar& operator= (const scalar& x);

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

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

  /** @name Accesses */


   */
  ap_scalar_discr_t get_discr() const;
    

   */
  double& get_double();


   */
  const double& get_double() const;


  mpq_class& get_mpq();

   *
   *\throw bad_discriminant when the scalar is not of MPQ type.
   */
  const mpq_class& get_mpq() const;

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


   * \arg \c round: rounding direction, may be GMP_RNDN, GMP_RNDZ, GMP_RNDU, GMP_RNDD, or GMP_RND_MAX.
   * \arg \c conv is set to either LESS, EQUAL, or GREATER, depending on whether the result is
   * less than, equal to or greater than the value of *this.
   * \note Currently round is ignored and the conversion is always exact.
   */
  mpq_class to_mpq(mp_rnd_t round, order& conv) const;


   */
  double to_double(mp_rnd_t round, order& conv) const;


  void to_mpfr(mpfr_t x, mp_rnd_t round, order& conv) const;

  operator mpq_class() const;

  operator double() const;

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


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

  void print(FILE* stream=stdout) const;

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


  //! Returns LESS if -oo, GREATER if +oo, EQUAL if finite.
  order is_infty() const;

  order sgn () const;

  friend order cmp(const scalar& a, const scalar& b);
 
  friend bool operator>=(const scalar& a, const scalar& b);
  friend bool operator<=(const scalar& a, const scalar& b);
  friend bool operator> (const scalar& a, const scalar& b);
  friend bool operator< (const scalar& a, const scalar& b);
  friend bool operator==(const scalar& a, const scalar& b);
  friend bool operator!=(const scalar& a, const scalar& b);
 
  friend order cmp(const scalar& a, int b);
  friend bool operator>=(const scalar& a, int b);
  friend bool operator<=(const scalar& a, int b);
  friend bool operator> (const scalar& a, int b);
  friend bool operator< (const scalar& a, int b);
  friend bool operator==(const scalar& a, int b);
  friend bool operator!=(const scalar& a, int b);
 
  friend order cmp(int a, const scalar& b);
  friend bool operator>=(int a, const scalar& b);
  friend bool operator<=(int a, const scalar& b);
  friend bool operator> (int a, const scalar& b);
  friend bool operator< (int a, const scalar& b);
  friend bool operator==(int a, const scalar& b);
  friend bool operator!=(int a, const scalar& b);

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



  void neg();


  scalar operator- () const;

  void inv();

  //! Returns the inverse of *this. Not exact for double type.
  scalar operator~ () const;

  long hash() const;

  //@}
 
 
  /* C API compatibility */
  /* =================== */



  const ap_scalar_t* get_ap_scalar_t() const;

  ap_scalar_t* get_ap_scalar_t();

  //@}
 
};
 
 
#include "apxx_scalar_inline.hh"
 
}
 
#endif /* __APXX_SCALAR_HH */