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


class texpr1 : public use_malloc {

protected:

  ap_texpr1_t l; 

  texpr1(ap_texpr1_t* x);

  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

  texpr1(const linexpr1& l);

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

  texpr1(const texpr1& x, const var& src, const texpr1& dst);



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


  ~texpr1();


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


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


    const_iterator(const texpr1& e);

    const_iterator(const const_iterator& i);



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


    environment get_environment() const;

    texpr0::const_iterator get_texpr0() const;

    ap_texpr_discr_t get_discr() const;

    const coeff& get_coeff() const;

    const var& get_var() const;

    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;

    const_iterator left() const;

    const_iterator right() const;



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



    bool equal(const texpr1& x) const;

    bool is_zero() 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;

    bool is_interval_polyfrac() const;

    bool is_scalar() const;



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


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

    void print(FILE* stream=stdout) const;



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


    ap_texpr1_t* get_ap_texpr1_t();

    const ap_texpr1_t* get_ap_texpr1_t() const;


  };


  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;

    void set_var(const var& v) const;

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


    iterator& operator=(const iterator& i);

    iterator child() const;

    iterator left() const;

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


  class builder : public use_malloc {

    friend class texpr1;

  protected:

    ap_texpr1_t l;

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

    void init_from(ap_texpr1_t* x);

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

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

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


    ~builder();



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



    bool is_zero() const;


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


    ap_texpr1_t* get_ap_texpr1_t();

    const ap_texpr1_t* get_ap_texpr1_t() const;



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


    friend builder unary(ap_texpr_op_t op, const builder& a,
                         ap_texpr_rtype_t rtype, ap_texpr_rdir_t rdir);

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

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

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

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

    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;

  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;

  bool is_interval_polyfrac() const;

  bool is_scalar() const;


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


  void substitute(const var& src, const texpr1& dst);




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


  ap_texpr1_t* get_ap_texpr1_t();

  const ap_texpr1_t* get_ap_texpr1_t() const;


};

#include "apxx_texpr1_inline.hh"

}

#endif /* __APXX_TEXPR1_HH */