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


class linexpr0 : public use_malloc {

protected:
  
  ap_linexpr0_t l; 

  linexpr0(ap_linexpr0_t* p);

  friend class texpr0_tmp;
  friend class texpr0;

public:


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


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

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


  /* size */

  size_t size() const;


  /* get */
 
  ap_linexpr_discr_t get_discr() const;

  coeff& get_cst();

  const coeff& get_cst() const;

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

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




  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;

  };


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

    iterator(const iterator& i);

    iterator& operator=(const iterator& i);

    coeff& get_coeff() const;

  };

  iterator begin();
  
  const_iterator begin() const;
  


  /* other operators */
  /* =============== */


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