/home/mine/apron/apronxx/apxx_linexpr1.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * apxx_linexpr1.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_LINEXPR1_HH
#define __APXX_LINEXPR1_HH
 
#include "ap_linexpr1.h"
#include "apxx_environment.hh"
#include "apxx_linexpr0.hh"
 
 
namespace apron {
 
 
/* ================================= */
/* linexpr1                          */
/* ================================= */
 


 *
 * Level 1 version of linear expressions with scalar or interval coefficients (coeff).
 * Terms are indexed using variable names (var) instead of dimensions (ap_dim_t).
 * Internally, a linexpr1 wraps together a linexpr0 (memory managed) and an environment (holding a
 * reference count).
 */
class linexpr1 : public use_malloc {
 
protected:
  
  ap_linexpr1_t l; 

  //! Internal use only. Shallow copy (no copy of linexpr0 or environment).
  linexpr1(ap_linexpr1_t& p);
 
 
public:
 
 
  /* constructors */
  /* ============ */



  linexpr1(const environment& e, const linexpr0& x);

   *
   * \arg \c e associates a variable name to each dimension.
   * \arg \c discr whether the expression is sparse (\c AP_LINEXPR_SPARSE) or dense (\c AP_LINEXPR_DENSE).
   * \arg \c size, for \c AP_LINEXPR_SPARSE expressions, is the initial number of dimensions in the
   * underlying linexpr0 (new dimensions being added as needed); ignored for \c AP_LINEXPR_DENSE
   * expressions (the size being always the size of the environment).
   */
  linexpr1(const environment& e, ap_linexpr_discr_t lin_discr=AP_LINEXPR_SPARSE, size_t size=0);
  
  //! Makes a (deep) copy.
  linexpr1(const linexpr1& x);

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

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


  
  ~linexpr1();

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


  //@{

  linexpr1& operator= (const linexpr1& x);

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



   *
   * \throw std::invalid_argument if e is not a super-environment of that of *this.
   */
  void extend_environment(const environment& e);

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



  environment get_environment() const;

  const linexpr0& get_linexpr0() const;

  linexpr0& get_linexpr0();

  //! Returns the number of coefficients in the expression.
  size_t size() const;

  ap_linexpr_discr_t get_discr() const;

  coeff& get_cst();

  //! Returns a reference to the constant coefficient.
  const coeff& get_cst() const;

  coeff& operator[](const var& v);
  

   */
  const coeff& operator[](const var& v) const;

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

  /** @name Printing */

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

  void print(FILE* stream=stdout) const;


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

  /** @name Tests */

  bool is_integer() const;

  bool is_real() const;


   */
  ap_linexpr_type_t get_type() const;

  bool is_linear() const;

  //! Whether all coefficients are scalar, except maybe the constant one.
  bool is_quasilinear() const;
 
 
  // TODO: equal, compare (currently not in ap_linexpr1.h) ???
 

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


  //@{


   * The expression is traversed in increasing order of integer variable names followed by
   * real variable names also in increasing order.
   *
   * To mutate a linear expression, use the iterator class instead.
   *
   * Sample code:
   * \code for (linexpr1::const_iterator i = m.begin();i.valid();++i) cout << i.get_coeff() << " "; \endcode
   */
  class const_iterator {
 
    /* TODO:
       - reverse traversal (operator--).
     */
 
    friend class linexpr1;
    
  protected:
 
    ap_linexpr1_t* l; 
    ap_dim_t pos;     

    void skip_AP_DIM_MAX();

    const_iterator(ap_linexpr1_t* l);
 
  public:
    
    const_iterator(const linexpr1& e);


    const_iterator(const const_iterator& i);

    const_iterator& operator=(const const_iterator& i);


    const var& get_var() const;

    ap_dim_t get_dim() const;

    const coeff& get_coeff() const;

    //! Moves the iterator to the following position.
    void next();


     */
    void operator++();

    bool valid() const;
 
  };


   * As const_iterator, but for non-constant linexpr1.
   *
   * Caution: do not modify the expression during traversal, except through the iterator.
   *
   * Sample code:
   * \code for (linexpr1::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:
    
    friend class linexpr1;
    
    iterator(ap_linexpr1_t* l);
 
  public:
   
    iterator(linexpr1& e);

    iterator(const iterator& i);

    //! Assigns the iterator.
    iterator& operator=(const iterator& i);


    coeff& get_coeff() const;
 
  };

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


  void minimize();

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


  const ap_linexpr1_t* get_ap_linexpr1_t() const;

  ap_linexpr1_t* get_ap_linexpr1_t();

 
};
 
#include "apxx_linexpr1_inline.hh"
 
}
 
#endif /* __APXX_LINEXPR1_HH */