/home/mine/apron/apronxx/apxx_texpr1.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_texpr1.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_TEXPR1_HH
#define __APXX_TEXPR1_HH
 
#include "ap_texpr1.h"
 
#include "apxx_linexpr1.hh"
#include "apxx_texpr0.hh"
 
 
namespace apron {
 
/* ================================= */
/* texpr1                            */
/* ================================= */
 


 * Internally, a texpr1 wraps together a texpr0 (memory managed) and an environment (holding a
 * reference count).
 *
 * There are also level 1 equivalent of the helper classes: builder, iterator, and const_iterator.
 *
 */
class texpr1 : public use_malloc {
 
protected:
 
  ap_texpr1_t l; 

  texpr1(ap_texpr1_t* x);

  //! Internal use only. Shallow copy.
  void init_from(ap_environment_t* e, ap_texpr0_t* x);

  void init_from(ap_texpr1_t* x);
 
public:
 
  class builder;
  class iterator;
  class const_iterator;
 
 
  /* constructors */
  /* ============ */



  texpr1(const builder& c);

  texpr1(const const_iterator& x);


  texpr1(const texpr1& x);


  texpr1(const environment& e, const var& v);

  texpr1(const environment& e, const texpr0::const_iterator& x);


  texpr1(const environment& e, const texpr0& x);

  texpr1(const environment& e, const texpr0::builder& c);
 
#if 0
  template<class T> texpr1(const T& x);

  template<class T> texpr1(const environment& e, const T& x);
#endif

   * Real-valued addition and multiplication operators are used (i.e., no rounding).
   */
  texpr1(const linexpr1& l);


  texpr1(const texpr1& x, const environment& e);

  /*! \brief Makes a (deep) copy of x and substitutes every occurrence of the src variable name with
   * a fresh copy of the dst expression.
   *
   * \throw std::invalid_argument if the environments are not equal or do not contain the variable.
   */
  texpr1(const texpr1& x, const var& src, const texpr1& dst);

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


  ~texpr1();

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


  //! Makes a (deep) copy of the expression.
  texpr1& operator=(const texpr1& x);

  texpr1& operator=(const const_iterator& x);


  texpr1& operator=(const builder& x);
 
 
#if 0
  template<class T> texpr1& operator=(const T& x);
#endif


   */
  texpr1& operator= (const linexpr1& x);

 
 
 
  /* iterators */
  /* ========= */
 


  class const_iterator {
 
  protected:
 
    ap_texpr1_t l;

    const_iterator(ap_texpr1_t* l);


    const_iterator(ap_texpr0_t* t, ap_environment_t* e);
 
    friend class texpr1;
    friend class tcons1;
 
  public:
 
    /* constructors */
    /* ============ */

    /** @name Constructors */

    const_iterator(const texpr1& e);

    const_iterator(const const_iterator& i);


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

    /** @name Access */

    environment get_environment() const;

    texpr0::const_iterator get_texpr0() const;


     *
     * \return \c AP_TEXPR_CST for a constant node, \c AP_TEXPR_DIM for a dimension,
     * and \c AP_TEXPR_NODE for an operator node.
     */
    ap_texpr_discr_t get_discr() const;


    const coeff& get_coeff() const;


     */
    const var& get_var() const;


     * \throw bad_discriminant if the node is not a dimension node.
     */
    ap_dim_t get_dim() const;


     */
    ap_texpr_op_t get_op() const;

    ap_texpr_rtype_t get_rtype() const;

     */
    ap_texpr_rdir_t get_rdir() const;

 
 
    /* traversal */
    /* ========= */



    const_iterator& operator=(const const_iterator& i);

    const_iterator child() const;

     * \throw bad_discriminant if the node is not an operator node.
     */
    const_iterator left() const;


     *
     * \throw bad_discriminant if the node is not an operator node.
     * \throw std::out_of_range if the operator node is not binary.
     */
    const_iterator right() const;

    //@}
 
 
    /* tests, size, dimensions */
    /* ======================= */


 

    bool equal(const texpr1& x) const;

    bool is_zero() const;

    //! Returns the depth of the expression tree (counting only operator nodes).
    size_t depth() const;

    size_t size() const;

    bool has_var(const var& v) const;


    bool is_interval_cst() const;

    bool is_interval_linear() const;

    //! Whether the expression is polynomial and there is no rounding.
    bool is_interval_polynomial() const;

    bool is_interval_polyfrac() const;

    //! Whether all occurring constants are scalar.
    bool is_scalar() const;

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


    //! Printing.
    friend std::ostream& operator<< (std::ostream& os, const const_iterator& s);

    void print(FILE* stream=stdout) const;

    //@}
 
 
    /* C-level compatibility */
    /* ===================== */

    /** @name C API compatibility */

    ap_texpr1_t* get_ap_texpr1_t();

    const ap_texpr1_t* get_ap_texpr1_t() const;

 
  };
 


   * As const_iterator, but can be used to modify as well as traverse nodes.
   */
  class iterator : public const_iterator {
 
  protected:

    iterator(ap_texpr1_t* l);

    iterator(ap_texpr0_t* t, ap_environment_t* e);
 
    friend class texpr1;
    friend class tcons1;
 
  public:
 
    /* constructors */
    /* ============ */



    iterator(texpr1& e);

    iterator(const iterator& i);

 
 
    /* substitution */
    /* ============ */



    iterator& operator= (const builder& x);
 
#if 0
    template<class T> iterator& operator= (const T& c);
#endif

    //@}
 
 
    /* access */
    /* ====== */



    texpr0::iterator get_texpr0() const;


     */
    coeff& get_coeff() const;


     * \throw std::invalid_argument if the environment does not contain a variable.
     */
    void set_var(const var& v) const;


     *
     * \throw bad_discriminant if the node is not a dimension node.
     */
    ap_dim_t& get_dim() const;

    /*! \brief Returns a (modifiable) reference to the operator kind of an operator node.
     *
     * \return either \c AP_TEXPR_ADD, \c AP_TEXPR_SUB, \c AP_TEXPR_MUL, \c AP_TEXPR_DIV, \c AP_TEXPR_MOD, \c AP_TEXPR_POW,
     * \c AP_TEXPR_NEG, \c AP_TEXPR_CAST, or \c AP_TEXPR_SQRT.
     * \throw bad_discriminant if the node is not an operator node.
     */
    ap_texpr_op_t& get_op() const;


     * \return either \c AP_RTYPE_REAL, \c AP_RTYPE_INT, \c AP_RTYPE_SINGLE (32-bit), \c AP_RTYPE_DOUBLE (64-bit),
     *  \c AP_RTYPE_EXTENDED (80-bit), or \c AP_RTYPE_QUAD (128-bit).
     * \throw bad_discriminant if the node is not an operator node.
     */
    ap_texpr_rtype_t& get_rtype() const;

     * \throw bad_discriminant if the node is not an operator node.
     */
    ap_texpr_rdir_t& get_rdir() const;


 
 
    /* traversal */
    /* ========= */


    iterator& operator=(const iterator& i);


     */
    iterator child() const;


     *
     * (Identical to child()).
     * \throw bad_discriminant if the node is not an operator node.
     */
    iterator left() const;


     * \throw std::out_of_range if the operator node is not binary.
     */
    iterator right() const;

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


    ap_texpr1_t* get_ap_texpr1_t();

    const ap_texpr1_t* get_ap_texpr1_t() const;

 
  };
 

  const_iterator root() const;

  iterator root();

 
 
  /* builders */
  /* ======== */



   *
   * You should not create variables of type build, nor define functions that return or take
   * builder objects as arguments.
   */
  class builder : public use_malloc {
 
    friend class texpr1;
 
  protected:
 
    ap_texpr1_t l;

    //! Not to be used. (Temporaries are not to be re-assigned).
    builder& operator= (const builder& x) { assert(0); return *this; }

    void init_from(ap_texpr1_t* x);

    //! Internal use only: makes a shallow copy, copying only the root node and referencing the environment.
    void init_from(ap_environment_t* e, ap_texpr0_t* x);

    builder(ap_texpr1_t* x);
 
  public:
 
    /* constructors */
    /* ============ */


    builder(const builder& x);

    builder(const const_iterator& x);

    builder(const texpr1& x);

    //! Converts from a level 0 builder and associates an environment.
    builder(const environment& e, const texpr0::builder& b);

    builder(const environment& e, const texpr0::const_iterator& b);


    builder(const environment& e, const texpr0& b);
 

    builder(const environment& e, const coeff& x);


    builder(const environment& e, const scalar& x);

    builder(const environment& e, const mpq_class& x);

    builder(const environment& e, mpfr_t x);


    builder(const environment& e, int x);

    builder(const environment& e, long x);

    builder(const environment& e, double x);

    builder(const environment& e, const frac& x);

    builder(const environment& e, const interval& x);

    builder(const environment& e, const scalar& inf, const scalar& sup);

    builder(const environment& e, const mpq_class& inf, const mpq_class& sup);

    builder(const environment& e, mpfr_t inf, mpfr_t sup);

    builder(const environment& e, int inf, int sup);

    builder(const environment& e, long inf, long sup);

    builder(const environment& e, double inf, double sup);


    builder(const environment& e, const frac& inf, const frac& sup);

    builder(const environment& e, top t);

    //! Makes a variable name dimension leaf.
    builder(const environment& e, const var& v);

    builder(ap_texpr_op_t op, const builder& argA, ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);

    builder(ap_texpr_op_t op, const builder& argA, const builder& argB, ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);


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

    /** @name Destructor */

    ~builder();

    //@}
 
 
    /* tests */
    /* ===== */
 


    bool is_zero() const;

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

    /** @name C API compatibility */

    ap_texpr1_t* get_ap_texpr1_t();

    //! Returns a pointer to the internal APRON object stored in *this.
    const ap_texpr1_t* get_ap_texpr1_t() const;

 
 
    /* 'Intelligent' constructors */
    /* ========================== */


    /*! \brief Makes a unary expression node.
     *
     * Creates only one node. The argument expression is aliased, not copied.
     *
     * \arg \c op should be a unary operator: negation (\c AP_TEXPR_NEG), typecast (\c AP_TEXPR_CAST),
     * or square root (\c AP_TEXPR_SQRT).
     * \arg \c argA should point to the argument expression.
     * \arg \c rtype is the destination type (for rounding): reals (\c AP_RTYPE_REAL, means no rounding),
     * perfect integers (\c AP_RTYPE_INT), 32-bit single precision (\c AP_RTYPE_SINGLE), 64-bit double precision
     * (\c AP_RTYPE_DOUBLE), 80-bit extended precision (\c AP_RTYPE_EXTENDED), or
     * 128-bit quadruple precision (\c AP_RTYPE_QUAD).
     * \arg \c rdir is the rounding direction: to nearest (\c AP_RDIR_NEAREST), truncation (\c AP_RDIR_ZERO),
     * towards +oo (\c AP_RDIR_UP), towards -oo (\c AP_RDIR_DOWN), or non-deterministic (\c AP_RDIR_RND).
     * \throw std::invalid_argument if \c op is not a unary operator.
     */
    friend builder unary(ap_texpr_op_t op, const builder& a,
                         ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);

    /*! \brief Makes a binary expression node.
     *
     * Creates only one node. The argument expressions is aliased, not copied.
     *
     * \arg \c op should be a binary operator: addition (\c AP_TEXPR_ADD), subtraction (\c AP_TEXPR_SUB),
     * multiplication (\c AP_TEXPR_MUL), division (\c AP_TEXPR_DIV), or modulo (\c AP_TEXPR_MOD, \c AP_TEXPR_POW).
     * \arg \c argA should point to the left argument expression.
     * \arg \c argB should point to the right argument expression.
     * \arg \c rtype is the destination type (for rounding): reals (\c AP_RTYPE_REAL, means no rounding),
     * perfect integers (\c AP_RTYPE_INT), 32-bit single precision (\c AP_RTYPE_SINGLE), 64-bit double precision
     * (\c AP_RTYPE_DOUBLE), 80-bit extended precision (\c AP_RTYPE_EXTENDED).
     * \arg \c rdir is the rounding direction: to nearest (\c AP_RDIR_NEAREST), truncation (\c AP_RDIR_ZERO),
     * towards +oo (\c AP_RDIR_UP), towards -oo (\c AP_RDIR_DOWN), or non-deterministic (\c AP_RDIR_RND).
     * \throw std::invalid_argument if \c op is not a binary operator.
     */
    friend builder binary(ap_texpr_op_t op, const builder& a, const builder& b,
                          ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);


    friend builder add(const builder& a, const builder& b,
                       ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);

    friend builder sub(const builder& a, const builder& b,
                       ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);

    //! Makes an \c AP_TEXPR_MUL expression node.
    friend builder mul(const builder& a, const builder& b,
                       ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);

    friend builder div(const builder& a, const builder& b,
                       ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);

    friend builder mod(const builder& a, const builder& b,
                       ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);

    //! Makes an \c AP_TEXPR_POW expression node.
    friend builder pow(const builder& a, const builder& b,
                       ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);

    friend builder neg(const builder& a,
                       ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);

    friend builder cast(const builder& a, ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);


    friend builder floor(const builder& a);

    friend builder ceil(const builder& a);


    friend builder trunc(const builder& a);

    friend builder sqrt(const builder& a,
                        ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);

    //! Makes a copy of the node.
    friend builder operator+(const builder& a);

    friend builder operator-(const builder& a);

    friend builder operator+(const builder& a, const builder& b);

    //! Makes a \c AP_TEXPR_SUB expression node using \c AP_RTYPE_REAL type (no rounding).
    friend builder operator-(const builder& a, const builder& b);

    friend builder operator*(const builder& a, const builder& b);

    friend builder operator/(const builder& a, const builder& b);


    friend builder operator%(const builder& a, const builder& b);

    friend builder operator^(const builder& a, const builder& b);

  };
 
 
  /* print */
  /* ===== */


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

  void print(FILE* stream=stdout) const;

  //@}
 
 
  /* dimension operations */
  /* ==================== */



  void extend_environment(const environment& e);

  //@}
 
 
  /* access */
  /* ====== */


  //@{

  environment get_environment() const;

  texpr0::const_iterator get_texpr0() const;

  texpr0::iterator get_texpr0();

  bool is_zero() const;

  //! Whether two expressions are syntactically, structurally equal.
  bool equal(const texpr1& x) const;

  size_t depth() const;


  size_t size() const;

  bool has_var(const var& v) const;

  bool is_interval_cst() const;

  bool is_interval_linear() const;

  bool is_interval_polynomial() const;

  //! Whether the expression is a polynomial fraction and there is no rounding.
  bool is_interval_polyfrac() const;

  bool is_scalar() const;

  //@}
 
  /* operations */
  /* ========== */

  /** @name Operations */


   * \throw std::invalid_argument if the environments are not equal or do not contain src.
   */
  void substitute(const var& src, const texpr1& dst);


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


  //@{

  ap_texpr1_t* get_ap_texpr1_t();

  //! Returns a pointer to the internal APRON object stored in *this.
  const ap_texpr1_t* get_ap_texpr1_t() const;

 
};
 
#include "apxx_texpr1_inline.hh"
 
}
 
#endif /* __APXX_TEXPR1_HH */