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

 bool is_binop(ap_texpr_op_t op);




/* ================================= */
/* texpr0                            */
/* ================================= */


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

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


  ~texpr0();


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


  texpr0& operator=(const texpr0& x);

  texpr0& operator=(const const_iterator& x);

  texpr0& operator=(const builder& x);

  texpr0& operator= (const linexpr0& x);




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



  class const_iterator {

  protected:

    ap_texpr0_t* l;

    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;

    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 texpr0& x) const;

    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;

    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(char** name_of_dim = NULL, FILE* stream=stdout) const;



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


    ap_texpr0_t* get_ap_texpr0_t();

    const ap_texpr0_t* get_ap_texpr0_t() const;


  };


  class iterator : public const_iterator {

  protected:

    iterator(ap_texpr0_t* l);

    friend class tcons0;
    friend class texpr1;
    friend class tcons1;

  public:

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


    iterator(texpr0& e);

    iterator(const iterator& i);



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


    iterator& operator= (const builder& c);



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


    coeff& get_coeff() 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_texpr0_t* get_ap_texpr0_t();

    const ap_texpr0_t* get_ap_texpr0_t() const;


  };


  const_iterator root() const;

  iterator root();




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


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

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

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

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

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



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


    ~builder();



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


    ap_texpr0_t* get_ap_texpr0_t();

    const ap_texpr0_t* get_ap_texpr0_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);



    bool is_zero() const;

  };



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


  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;

  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;

  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

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