/home/mine/apron/apronxx/apxx_texpr0.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_texpr0.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_TEXPR0_HH
#define __APXX_TEXPR0_HH
 
#include <vector>
 
#include "ap_texpr0.h"
#include "ap_linearize.h"
 
#include "apxx_linexpr0.hh"
#include "apxx_environment.hh"
 
namespace apron {
 
class abstract0;
 

class dim {
 
public:
 
  ap_dim_t d; 

  dim(ap_dim_t d);


  dim(const environment& e, const var& v);
};
 
 

bool is_unop(ap_texpr_op_t op);

//! Whether the operator is binary.
 bool is_binop(ap_texpr_op_t op);
 
 
 
 
/* ================================= */
/* texpr0                            */
/* ================================= */
 


 * Binary operators include addition, subtraction, multiplication, division, and modulo.
 * Unary operators include opposite, square root, and typecast.
 * Additionally, all operators are tagged with a destination type: perfect integers, reals,
 * or floating-point numbers (of various bit-size).
 * For integer and floating-point operators, a rounding direction can be specified
 * (as well as 'any direction').
 * The concrete semantics of all operators is to first perform the operation on perfect reals
 * (typecast being the identity operator here), and then round the result to the destination type
 * in the specified direction.
 *
 * A texpr0 manages a whole expression tree: assignment, copy, and destruction are deep (recursive).
 *
 * Complex expression trees can be constructed using the standard +, -, *, /, % operators, as well as
 * functions such as add, mul, div, etc. (allowing to set the destination type and rounding direction).
 * \code
 * texpr0 x = dim(1) + dim(2) * 5;
 * texpr0 y = add(sqrt(x), x, AP_RTYPE_FLOAT);
 * \endcode
 * Temporaries created by the operators have the texpr0::builder type.
 * See the texpr0::builder class documentation for the details on operator arguments.
 *
 * Expression trees can be visited and/or modified using the texpr0::iterator type.
 */
class texpr0 : public use_malloc {
 
protected:
 
  ap_texpr0_t l; 

  texpr0(ap_texpr0_t* x);

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

  //@{

  texpr0(const builder& x);

  //! Makes a (deep) copy of the expression tree.
  texpr0(const texpr0& x);

  texpr0(const const_iterator& x);


   */
  texpr0(const linexpr0& l);
 

  texpr0(const texpr0& x, const dimchange& d, bool add=true);

  texpr0(const texpr0& x, const dimperm& d);

  texpr0(const texpr0& x, ap_dim_t dim, const texpr0& dst);

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


  //! Frees the memory occupied by the expression (and, recursively, all sub-expressions).
  ~texpr0();

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

  //@{

  texpr0& operator=(const texpr0& x);

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

  texpr0& operator=(const builder& x);


  texpr0& operator= (const linexpr0& x);

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

  /** @name Iterators */


   * For lack of better name, an 'iterator' object is used to reference an
   * expression node within a constant expression tree.
   * Through the 'iterator', nodes can be examined.
   * However, 'iterators' traverse the tree in a functional way: you spawn new
   * const_iterator objects for left and right children.
   *
   * Use the iterator class if you also wish to mutate an expression.
   *
   * \warning You can no longer use a const_iterator after the corresponding node has been discarded
   * (i.e., part of a destroyed expression, part of a sub-expression substituted away, etc.).
   * However, you can safely destroy the const_iterator after the node has been destroyed
   * (provided you do not use it in the meantime).
   *
   */
  class const_iterator {
 
  protected:
 
    ap_texpr0_t* l;

    //! Internal use only.
    const_iterator(ap_texpr0_t* l);
 
    friend class texpr0;
    friend class tcons0;
    friend class texpr1;
    friend class tcons1;
 
  public:
 
    /* constructors */
    /* ============ */

    //@{

    const_iterator(const texpr0& e);

    const_iterator(const const_iterator& i);

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

 

    ap_texpr_discr_t get_discr() const;

    const coeff& get_coeff() const;

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

     */
    ap_texpr_op_t get_op() const;


     *  \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;

    /*! \brief Returns the rounding direction of an operator node.
     *
     * \return either \c AP_RDIR_NEAREST, \c AP_RDIR_ZERO, \c AP_RDIR_UP, \c AP_RDIR_DOWN, or \c AP_RDIR_RND.
     * \throw bad_discriminant if the node is not an operator node.
     */
    ap_texpr_rdir_t get_rdir() const;

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



    const_iterator& operator=(const const_iterator& i);


    const_iterator child() const;

    const_iterator left() const;

    /*! \brief Constructs a const_iterator to the right sub-expression argument of a binary operator node.
     *
     * \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 */
    /* ======================= */

    /** @name Tests, size, dimensions */
 

    bool equal(const texpr0& x) const;

    //! Whether the expression is a single coefficient node with 0 value.
    bool is_zero() const;

    size_t depth() const;

    size_t size() const;

    ap_dim_t max_dim() const;

    bool has_dim(ap_dim_t d) const;


     */
    std::vector<ap_dim_t> dimlist() const;

    bool is_interval_cst() const;

    //! Whether the expression is linear and there is no rounding.
    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;

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



     *
     * Variable naming can be configured through the varname stream modifier.
     */
    friend std::ostream& operator<< (std::ostream& os, const const_iterator& s);

    void print(char** name_of_dim = NULL, FILE* stream=stdout) const;

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

    /** @name C API compatibility */

    ap_texpr0_t* get_ap_texpr0_t();


    const ap_texpr0_t* get_ap_texpr0_t() const;

 
  };
 

  /*! \brief Iterators to traverse and mutate an expression tree.
   *
   * As const_iterator, but can be used to modify as well as traverse nodes.
   */
  class iterator : public const_iterator {
 
  protected:

    iterator(ap_texpr0_t* l);
 
    friend class tcons0;
    friend class texpr1;
    friend class tcons1;
 
  public:
 
    /* constructors */
    /* ============ */

    /** @name Constructors */

    iterator(texpr0& e);

    //! Duplicates the iterator.
    iterator(const iterator& i);

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


    //@{


     * However, any iterator in the discarded part becomes invalid.
     */
    iterator& operator= (const builder& c);


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



     */
    coeff& get_coeff() const;


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


     *
     * \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;


     *  \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;

     */
    ap_texpr_rdir_t& get_rdir() const;

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



    iterator& operator=(const iterator& i);


    iterator child() const;


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

    /*! \brief Constructs an iterator to the right sub-expression argument of a binary operator node.
     *
     * \throw bad_discriminant if the node is not an operator node.
     * \throw std::out_of_range if the operator node is not binary.
     */
    iterator right() const;

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


    ap_texpr0_t* get_ap_texpr0_t();

    const ap_texpr0_t* get_ap_texpr0_t() const;

    //@}
 
  };
 


  const_iterator root() const;

  iterator root();


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

  /** @name Builders */


   * operators (+, -, *, /, %) and friend functions (add, sub, mul, div, mod, neg, sqrt, cast,
   * unary, binary).
   *
   * Each builder object manages a single node which is allocated by the constructor and destroyed
   * by the destructor, without considering potential sub-nodes.
   * As their usage is temporary (they are normally destructed at the end of full expressions),
   * assignment, copy, and destruction can be shallow, which results in improved efficiency wrt.
   * using texpr0 as temporaries.
   *
   * 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_texpr0_t* l;
 

    builder& operator= (const builder& x) { assert(0); return *this; }

    void init_from(ap_texpr0_t* x);

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



    builder(const builder& x);

    //! Makes a shallow copy, copying only the root node. Sub-expressions are aliased, not copied.
    builder(const const_iterator& x);

    builder(const texpr0& x);

    builder(const coeff& x);


    builder(const scalar& x);

    builder(const mpq_class& x);

    builder(mpfr_t x);

    builder(int x);

    builder(long x);

    builder(double x);

    builder(const frac& x);


    builder(const interval& x);

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

    //! Makes a constant interval leaf from two MPQ bounds (copied).
    builder(const mpq_class& inf, const mpq_class& sup);

    builder(mpfr_t inf, mpfr_t sup);

    builder(int inf, int sup);


    builder(long inf, long sup);

    builder(double inf, double sup);

    //! Makes a constant interval leaf from two fraction bounds (converted to MPQ).
    builder(const frac& inf, const frac& sup);


    builder(top t);

    builder(dim d);

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

    //! Makes a binary expression node.
    builder(ap_texpr_op_t op, const builder& argA, const builder& argB, ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);


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


    //! Frees the memory occupied by the node, not its sub-expressions.
    ~builder();


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


    //! Returns a pointer to the internal APRON object stored in *this.
    ap_texpr0_t* get_ap_texpr0_t();

    const ap_texpr0_t* get_ap_texpr0_t() const;

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




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


     *
     * 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), modulo (\c AP_TEXPR_MOD), or power (\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);

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

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

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

    //! Makes an \c AP_TEXPR_NEG expression node.
    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);

    //! Makes an \c AP_TEXPR_CAST expression node to \c AP_RTYPE_INT type rounded towards \c AP_RDIR_DOWN.
    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);


    friend builder operator+(const builder& a);

    friend builder operator-(const builder& a);

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

    //! Makes a \c AP_TEXPR_DIV 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);

 

    bool is_zero() const;
 
  };
 
 
 
  /* print */
  /* ===== */


  /*! \brief Printing.
   *
   * Variable naming can be configured through the varname stream modifier.
   */
  friend std::ostream& operator<< (std::ostream& os, const texpr0& s);

  void print(char** name_of_dim = NULL, FILE* stream=stdout) const;


 
 
  /* tests, size, dimensions */
  /* ======================= */


 

  bool equal(const texpr0& x) const;

  //! Whether the expression is a single coefficient node with 0 value.
  bool is_zero() const;

  size_t depth() const;

  size_t size() const;


  ap_dim_t max_dim() const;

  bool has_dim(ap_dim_t d) const;

  /*! \brief Returns a list of all dimensions occurring in the expression
   * (in strict increasing order)
   */
  std::vector<ap_dim_t> dimlist() const;

  //! Whether the expression is constant (i.e., has no dimension leaves).
  bool is_interval_cst() const;

  bool is_interval_linear() const;

  bool is_interval_polynomial() const;


  bool is_interval_polyfrac() const;

  bool is_scalar() const;

 
  /* operations */
  /* ========== */


  void substitute(ap_dim_t dim, const texpr0& dst);
 
#if 0

   * \arg \c pexact if not NULL, sets to true whenever the evaluation was exact
   * (i.e., not over-approximated).
   */
  interval eval(manager& m, const abstract0& a, ap_scalar_discr_t discr=AP_SCALAR_DOUBLE,
                bool* pexact=NULL) const;
 
  linexpr0 intlinearize(manager& m, const abstract0& a, ap_scalar_discr_t discr=AP_SCALAR_DOUBLE,
                        bool quasilinearize=false, bool* pexact=NULL) const;
#endif

  long hash() const;


 
  /* change of dimension */
  /* =================== */



  void add_dimensions(const dimchange& d);

  void remove_dimensions(const dimchange& d);

  void permute_dimensions(const dimperm& d);

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


  ap_texpr0_t* get_ap_texpr0_t();

  const ap_texpr0_t* get_ap_texpr0_t() const;

 
};
 
#include "apxx_texpr0_inline.hh"
 
}
 
#endif /* __APXX_TEXPR0_HH */