/home/mine/apron/apronxx/apxx_linexpr0.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_linexpr0.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_LINEXPR0_HH
#define __APXX_LINEXPR0_HH
 
#include "ap_linexpr0.h"
#include "ap_linearize.h"
#include "apxx_coeff.hh"
#include "apxx_dimension.hh"
 
 
namespace apron {
 
 
 
/* ================================= */
/* linexpr0                          */
/* ================================= */
 

/*! \brief Level 0 linear expression (ap_linexpr0_t wrapper).
 *
 * A linexpr0 object represents a linear expression with scalar or interval coefficients (coeff).
 * They have a constant coefficient, plus a coefficient for each represented dimension.
 * An expression can be either sparse (\c AP_LINEXPR_SPARSE) or dense (\c AP_LINEXPR_DENSE).
 * Dense expressions use an array of coefficients to represent dimensions from 0 up to the 
 * expression size.
 * Sparse expressions can have 'holes' between coefficients and grow automatically when 
 * a coefficient for a non-existing dimension is accessed.
 */
class linexpr0 : public use_malloc {
 
protected:
  
  ap_linexpr0_t l; 

  linexpr0(ap_linexpr0_t* p);
 
  friend class texpr0_tmp;
  friend class texpr0;
 
public:
 
 
  /* constructors */
  /* ============ */



   *
   * \arg \c discr whether the expression is sparse (\c AP_LINEXPR_SPARSE) or dense (\c AP_LINEXPR_DENSE).
   * \arg \c size is the initial number of dimensions.
   */
  linexpr0(ap_linexpr_discr_t discr=AP_LINEXPR_SPARSE, size_t size=0);

  linexpr0(const linexpr0& x);

  linexpr0(const linexpr0& x, const dimchange& d);

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


   */
  linexpr0(size_t size, const coeff coeffs[], const coeff& cst, ap_linexpr_discr_t discr=AP_LINEXPR_SPARSE);


  linexpr0(const std::vector<coeff>& coeffs, const coeff& cst, ap_linexpr_discr_t discr=AP_LINEXPR_SPARSE);


   * \arg \c cst corresponds to the constant coefficient.
   */
  linexpr0(size_t size, const coeff coeffs[], const ap_dim_t dims[], const coeff& cst);

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


  ~linexpr0();

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



  linexpr0& operator= (const linexpr0& x);

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



  void resize(size_t size);

  void add_dimensions(const dimchange& d);

  void permute_dimensions(const dimperm& d);


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

  /** @name Accesses, size */
 
  /* size */

  size_t size() const;
 
 
  /* get */
 
  /*! \brief Returns the expression type.
   *
   * \return Either \c AP_LINEXPR_SPARSE or \c AP_LINEXPR_DENSE.
   */
  ap_linexpr_discr_t get_discr() const;

  coeff& get_cst();

  const coeff& get_cst() const;


   * Always succeeds if the expression is sparse: if the dimension has no coefficient yet, it is
   * created and returned (linear time in the worst case).
   * \throw std::out_of_range if the expression is dense and the dimension exceeds the size
   * of the expression.
   * \warning as a side-effect, the method renders previous references to coefficients within the
   * same expression invalid. For instance, \code l.get_coeff(0) = l.get_coeff(1) = 0; \endcode is invalid.
   */
  coeff& operator[](ap_dim_t dim);
 

  const coeff& operator[](ap_dim_t dim) const;

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



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

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

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


  bool is_integer(size_t intdim) const;

  bool is_real(size_t intdim) const;


  ap_linexpr_type_t get_type() const;

  bool is_linear() const;

  bool is_quasilinear() const;

  friend int compare(const linexpr0& x, const linexpr0& y);

  friend bool equal(const linexpr0& x, const linexpr0& y);
 
#if 0 // overloaded to make constraints
  friend bool operator>= (const linexpr0& x, const linexpr0& y);

  friend bool operator<= (const linexpr0& x, const linexpr0& y);

  friend bool operator> (const linexpr0& x, const linexpr0& y);

  //! Whether compare(x,y)<0.
  friend bool operator< (const linexpr0& x, const linexpr0& y);

  friend bool operator== (const linexpr0& x, const linexpr0& y);

  friend bool operator!= (const linexpr0& x, const linexpr0& y);
#endif

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

 


   * (holes are skipped.)
   * In all cases, the expression is traversed in increasing dimension order.
   *
   * To mutate a linear expression, use the iterator class instead.
   *
   * Sample code:
   * \code for (linexpr0::const_iterator i = m.begin();i.valid();++i) cout << i.get_coeff() << " "; \endcode
   */
  class const_iterator {
 
    /* TODO:
       - reverse traversal (operator--).
     */
 
  protected:
 
    ap_linexpr0_t* l; 
    ap_dim_t pos;     

    void skip_AP_DIM_MAX();

    const_iterator(ap_linexpr0_t* l);
 
    friend class linexpr0;
 
  public:
   
    const_iterator(const linexpr0& e);

    const_iterator(const const_iterator& i);

    const_iterator& operator=(const const_iterator& i);

    ap_dim_t get_dim() const;

    const coeff& get_coeff() const;

    void next();

    void operator++();

    bool valid() const;
 
  };
 

  /*! \brief Iterator to traverse and mutate a linear expression.
   *
   * As const_iterator, but for non-constant linexpr0.
   *
   * Caution: do not modify the expression during traversal, except through the iterator.
   *
   * Sample code:
   * \code for (linexpr0::iterator i = m.begin();i.valid();++i) i.get_coeff().neg(); \endcode
   */
  class iterator : public const_iterator {
 
    /* TODO:
       - removing/inserting coefficients at iterator position for sparse expressions.
     */
 
  protected:

    iterator(ap_linexpr0_t* l);
 
    friend class linexpr0;
 
 
  public:
   
    iterator(linexpr0& e);

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


    iterator& operator=(const iterator& i);


     * \throw std::out_of_range if valid() returns false (we are past the last position).
     */
    coeff& get_coeff() const;
 
  };


  iterator begin();
  
  const_iterator begin() const;
  
 
 
  /* other operators */
  /* =============== */


  /*! \brief Minimizes all coefficients.
   * 
   * In sparse expressions, also remove zero and unused (hole) coefficients to save space.
   */
  void minimize();


  long hash() const;

 
 
  /* TODO: evaluation, linearization, intelligent constructors */
 
 
  /* C-level compatibility */
  /* ===================== */



  const ap_linexpr0_t* get_ap_linexpr0_t() const;


  ap_linexpr0_t* get_ap_linexpr0_t();

 
};
 
#include "apxx_linexpr0_inline.hh"
 
}
 
#endif /* __APXX_LINEXPR0_HH */