api/cxx/apxx__abstract0_8hh_source.html

 /* -*- C++ -*-
  * apxx_abstract0.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_ABSTRACT0_HH
 #define __APXX_ABSTRACT0_HH

 #include <string>
 #include "ap_abstract0.h"
 #include "apxx_linexpr0.hh"
 #include "apxx_lincons0.hh"
 #include "apxx_generator0.hh"
 #include "apxx_manager.hh"


 namespace apron {


 /* ================================= */
 /* abstract0                         */
 /* ================================= */

 class abstract0 : public use_malloc {

 protected:

   ap_abstract0_t* a;

   abstract0(ap_abstract0_t* x);

   static const abstract0 null;

   friend class manager;

 public:


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


   abstract0(manager &m, size_t intdim, size_t realdim, top x);

   abstract0(manager &m, size_t intdim, size_t realdim, bottom x);

   abstract0(manager &m, const abstract0& t);

   abstract0(manager &m, size_t intdim, size_t realdim, const interval_array& x);

   abstract0(manager &m, size_t intdim, size_t realdim, const lincons0_array& x);

   abstract0(manager &m, size_t intdim, size_t realdim, const tcons0_array& x);

   abstract0(const abstract0& t);


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


   ~abstract0();

   void free(manager& m);


   /* assignments */
   /* =========== */


   abstract0& operator=(const abstract0& t);

   abstract0& operator=(top t);

   abstract0& operator=(bottom t);

   abstract0& operator=(const interval_array& x);

   abstract0& operator=(const lincons0_array& x);

   abstract0& operator=(const tcons0_array& x);

   abstract0& set(manager& m, const abstract0& x);

   abstract0& set(manager& m, top t, size_t intdim = AP_DIM_MAX, size_t realdim = AP_DIM_MAX);

   abstract0& set(manager& m, bottom t, size_t intdim = AP_DIM_MAX, size_t realdim = AP_DIM_MAX);

   abstract0& set(manager& m, const interval_array& x, size_t intdim = AP_DIM_MAX, size_t realdim = AP_DIM_MAX);

   abstract0& set(manager& m, const lincons0_array& x, size_t intdim = AP_DIM_MAX, size_t realdim = AP_DIM_MAX);

   abstract0& set(manager& m, const tcons0_array& x, size_t intdim = AP_DIM_MAX, size_t realdim = AP_DIM_MAX);


   /* representation */
   /* ============== */


   abstract0& minimize(manager& m);

   abstract0& canonicalize(manager& m);

   abstract0& approximate(manager& m, int algorithm);


   /* printing */
   /* ======== */


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

   friend void printdiff(manager& m, const abstract0& x, const abstract0& y, char** name_of_dim, FILE* stream);

   void dump(manager& m, FILE* stream=stdout) const;

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


   /* serialisation */
   /* ============= */


   std::string* serialize(manager& m) const;

   friend abstract0& deserialize(manager& m, abstract0& dst, const std::string& s, size_t* eaten);


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


   manager get_manager() const;

   ap_dimension_t get_dimension(manager& m) const;

   size_t size(manager& m) const;


   /* predicates */
   /* ========== */


   bool is_bottom(manager& m) const;

   bool is_top(manager& m) const;

   bool is_eq(manager& m, const abstract0& x) const;

   bool is_leq(manager& m, const abstract0& x) const;

   bool sat(manager& m, const lincons0& l) const;

   bool sat(manager& m, const tcons0& l) const;

   bool sat(manager& m, ap_dim_t dim, const interval& i) const;

   bool is_dimension_unconstrained(manager& m, ap_dim_t dim) const;

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

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

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

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

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

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


   /* Properties */
   /* ========== */


   interval bound(manager& m, const linexpr0& l) const;

   interval bound(manager& m, const texpr0& l) const;

   interval bound(manager& m, ap_dim_t d) const;

   interval_array to_box(manager& m) const;

   generator0_array to_generator_array(manager& m) const;

   lincons0_array to_lincons_array(manager& m) const;

   tcons0_array to_tcons_array(manager& m) const;


   /* Meet */
   /* ==== */


   abstract0& meet(manager& m, const abstract0& y);

   friend abstract0& meet(manager& m, abstract0& dst, const abstract0& x, const abstract0& y);

   friend abstract0& meet(manager& m, abstract0& dst, const std::vector<const abstract0*>& x);

   friend abstract0& meet(manager& m, abstract0& dst, size_t size, const abstract0 * const x[]);

   abstract0& meet(manager& m, const lincons0_array& y);

   friend abstract0& meet(manager& m, abstract0& dst, const abstract0& x, const lincons0_array& y);

   abstract0& meet(manager& m, const tcons0_array& y);

   friend abstract0& meet(manager& m, abstract0& dst, const abstract0& x, const tcons0_array& y);


   abstract0& operator*=(const abstract0& y);


   abstract0& operator*=(const lincons0_array& y);

   abstract0& operator*=(const tcons0_array& y);


   /* Join */
   /* ==== */


   abstract0& join(manager& m, const abstract0& y);

   friend abstract0& join(manager& m, abstract0& dst, const abstract0& x, const abstract0& y);

   friend abstract0& join(manager& m, abstract0& dst, const std::vector<const abstract0*>& x);

   friend abstract0& join(manager& m, abstract0& dst, size_t size, const abstract0 * const x[]);

   abstract0& add_rays(manager& m, const generator0_array& y);

   friend abstract0& add_rays(manager& m, abstract0& dst, const abstract0& x, const generator0_array& y);

   abstract0& operator+=(const abstract0& y);

   abstract0& operator+=(const generator0_array& y);


   /* Assignments */
   /* =========== */


   abstract0& assign(manager& m, ap_dim_t dim, const linexpr0& l, const abstract0& inter = null);

   abstract0& assign(manager& m,  size_t size, const ap_dim_t dim[], const linexpr0 * const l[], const abstract0& inter = null);


   abstract0& assign(manager& m, const std::vector<ap_dim_t>& dim, const std::vector<const linexpr0*>& l, const abstract0& inter = null);

   friend abstract0& assign(manager& m, abstract0& dst, const abstract0& src, ap_dim_t dim, const linexpr0& l, const abstract0& inter);

   friend abstract0& assign(manager& m, abstract0& dst, const abstract0& src,  size_t size, const ap_dim_t dim[], const linexpr0 * const l[], const abstract0& inter);

   friend abstract0& assign(manager& m, abstract0& dst, const abstract0& src, const std::vector<ap_dim_t>& dim, const std::vector<const linexpr0*>& l, const abstract0& inter);


   abstract0& assign(manager& m, ap_dim_t dim, const texpr0& l, const abstract0& inter = null);

   abstract0& assign(manager& m, size_t size, const ap_dim_t dim[], const texpr0 * const l[], const abstract0& inter = null);


   abstract0& assign(manager& m, const std::vector<ap_dim_t>& dim, const std::vector<const texpr0*>& l, const abstract0& inter = null);

   friend abstract0& assign(manager& m, abstract0& dst, const abstract0& src, ap_dim_t dim, const texpr0& l, const abstract0& inter);

   friend abstract0& assign(manager& m, abstract0& dst, const abstract0& src, size_t size, const ap_dim_t dim[], const texpr0 * const l[], const abstract0& inter);

   friend abstract0& assign(manager& m, abstract0& dst, const abstract0& src, const std::vector<ap_dim_t>& dim, const std::vector<const texpr0*>& l, const abstract0& inter);


   /* Substitutions */
   /* ============== */


   abstract0& substitute(manager& m, ap_dim_t dim, const linexpr0& l, const abstract0& inter = null);

   abstract0& substitute(manager& m, size_t size, const ap_dim_t dim[], const linexpr0 * const l[], const abstract0& inter = null);


   abstract0& substitute(manager& m, const std::vector<ap_dim_t>& dim, const std::vector<const linexpr0*>& l, const abstract0& inter = null);

   friend abstract0& substitute(manager& m, abstract0& dst, const abstract0& src, ap_dim_t dim, const linexpr0& l, const abstract0& inter);

   friend abstract0& substitute(manager& m, abstract0& dst, const abstract0& src,  size_t size, const ap_dim_t dim[], const linexpr0 * const l[], const abstract0& inter);

   friend abstract0& substitute(manager& m, abstract0& dst, const abstract0& src, const std::vector<ap_dim_t>& dim, const std::vector<const linexpr0*>& l, const abstract0& inter);


   abstract0& substitute(manager& m, ap_dim_t dim, const texpr0& l, const abstract0& inter = null);

   abstract0& substitute(manager& m,  size_t size, const ap_dim_t dim[], const texpr0 * const l[], const abstract0& inter = null);


   abstract0& substitute(manager& m, const std::vector<ap_dim_t>& dim, const std::vector<const texpr0*>& l, const abstract0& inter = null);

   friend abstract0& substitute(manager& m, abstract0& dst, const abstract0& src, ap_dim_t dim, const texpr0& l, const abstract0& inter);

   friend abstract0& substitute(manager& m, abstract0& dst, const abstract0& src,  size_t size, const ap_dim_t dim[], const texpr0 * const l[], const abstract0& inter);

   friend abstract0& substitute(manager& m, abstract0& dst, const abstract0& src, const std::vector<ap_dim_t>& dim, const std::vector<const texpr0*>& l, const abstract0& inter);


   /* Projection */
   /* ========== */


   abstract0& forget(manager& m, ap_dim_t dim, bool project = false);

   abstract0& forget(manager& m, size_t size, const ap_dim_t dim[], bool project = false);

   abstract0& forget(manager& m, const std::vector<ap_dim_t> dim, bool project = false);

   friend abstract0& forget(manager& m, abstract0& dst, const abstract0& src, ap_dim_t dim, bool project);

   friend abstract0& forget(manager& m, abstract0& dst, const abstract0& src, size_t size, const ap_dim_t dim[], bool project);

   friend abstract0& forget(manager& m, abstract0& dst, const abstract0& src, const std::vector<ap_dim_t> dim, bool project);


   /* Change of dimension */
   /* =================== */


   abstract0& add_dimensions(manager& m, const dimchange& d, bool project = false);

   abstract0& remove_dimensions(manager& m, const dimchange& d);

   abstract0& permute_dimensions(manager& m, const dimperm& d);


   friend abstract0& add_dimensions(manager& m, abstract0& dst, const abstract0& src, const dimchange& d, bool project);

   friend abstract0& remove_dimensions(manager& m, abstract0& dst, const abstract0& src, const dimchange& d);

   friend abstract0& permute_dimensions(manager& m, abstract0& dst, const abstract0& src, const dimperm& d);


   /* Expansion and folding */
   /* ===================== */


   abstract0& expand(manager& m, ap_dim_t dim, size_t n = 1);

   friend abstract0& expand(manager& m, abstract0& dst, const abstract0& src, ap_dim_t dim, size_t n);

   abstract0& fold(manager& m,  size_t size, const ap_dim_t dim[]);

   abstract0& fold(manager& m, const std::vector<ap_dim_t>& dim);

   friend abstract0& fold(manager& m, abstract0& dst, const abstract0& src,  size_t size, const ap_dim_t dim[]);

   friend abstract0& fold(manager& m, abstract0& dst, const abstract0& src, const std::vector<ap_dim_t>& dim);


   /* Widenings */
   /* ========= */


   friend abstract0& widening(manager& m, abstract0& dst, const abstract0& x, const abstract0& y);

   friend abstract0& widening(manager& m, abstract0& dst, const abstract0& x, const abstract0& y, const lincons0_array& l);


   /* Closure */
   /* ======= */


   abstract0& closure(manager& m);

   friend abstract0& closure(manager& m, abstract0& dst, const abstract0& src);


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


   ap_abstract0_t* get_ap_abstract0_t();

   const ap_abstract0_t* get_ap_abstract0_t() const;


 };

 #include "apxx_abstract0_inline.hh"

 }

 #endif /* __APXX_ABSTRACT0_HH */
apron::abstract0::is_bottom
bool is_bottom(manager &m) const
Whether *this represents the empty set.
Definition: apxx_abstract0.hh:353

apron::abstract0::add_rays
abstract0 & add_rays(manager &m, const generator0_array &y)
Adds some rays to *this (modified in-place).
Definition: apxx_abstract0.hh:637

apron::dimperm
Dimension permutation object (ap_dimperm_t wrapper).
Definition: apxx_dimension.hh:292

apron::abstract0::fold
abstract0 & fold(manager &m, size_t size, const ap_dim_t dim[])
Folds dimensions dim[0] to dim[size-1] in *this (modified in-place).
Definition: apxx_abstract0.hh:1093

apron::abstract0::operator<=
friend bool operator<=(const abstract0 &x, const abstract0 &y)
Whether x is included within y (set-wise).
Definition: apxx_abstract0.hh:422

apron::dimchange
Dimension change object (ap_dimchange_t wrapper).
Definition: apxx_dimension.hh:102

apron
Definition: apxx_abstract0.hh:27

apron::abstract0::set
abstract0 & set(manager &m, const abstract0 &x)
Replaces *this with a copy of x.
Definition: apxx_abstract0.hh:168

apron::abstract0::operator<<
friend std::ostream & operator<<(std::ostream &os, const abstract0 &s)
Prints in constraint form.
Definition: apxx_abstract0.hh:293

apron::abstract0::assign
abstract0 & assign(manager &m, ap_dim_t dim, const linexpr0 &l, const abstract0 &inter=null)
In-place assignment of linear expression.
Definition: apxx_abstract0.hh:700

apron::abstract0::print
void print(manager &m, char **name_of_dim=NULL, FILE *stream=stdout) const
Pretty-printing to a C stream.
Definition: apxx_abstract0.hh:275

apron::abstract0::operator>=
friend bool operator>=(const abstract0 &x, const abstract0 &y)
Whether x contains y (set-wise).
Definition: apxx_abstract0.hh:429

apron::abstract0::is_dimension_unconstrained
bool is_dimension_unconstrained(manager &m, ap_dim_t dim) const
Whether the points in *this are unbounded in the given dimension.
Definition: apxx_abstract0.hh:402

apron::abstract0::operator==
friend bool operator==(const abstract0 &x, const abstract0 &y)
Whether x and y represent the same set.
Definition: apxx_abstract0.hh:410

apron::abstract0::serialize
std::string * serialize(manager &m) const
Serializes an abstract element.
Definition: apxx_abstract0.hh:305

apron::abstract0::a
ap_abstract0_t * a
Pointer managed by APRON.
Definition: apxx_abstract0.hh:82

apron::interval_array
array of interval(s).
Definition: apxx_interval.hh:302

apxx_generator0.hh

apron::abstract0::expand
abstract0 & expand(manager &m, ap_dim_t dim, size_t n=1)
Duplicates dimension dim into n copies in *this (modified in-place).
Definition: apxx_abstract0.hh:1077

apron::abstract0
Level 0 abstract value (ap_abstract0_t* wrapper).
Definition: apxx_abstract0.hh:78

apron::generator0_array
Array of generators (ap_generator0_array_t wrapper).
Definition: apxx_generator0.hh:214

apron::abstract0::operator=
abstract0 & operator=(const interval_array &x)
Assigns a box to *this.
Definition: apxx_abstract0.hh:131

apxx_lincons0.hh

apron::abstract0::get_manager
manager get_manager() const
Returns the manager the abstract element was created with (with reference count incremented).
Definition: apxx_abstract0.hh:329

apron::abstract0::operator<
friend bool operator<(const abstract0 &x, const abstract0 &y)
Whether x is strictly included within y (set-wise).
Definition: apxx_abstract0.hh:439

apron::abstract0::is_eq
bool is_eq(manager &m, const abstract0 &x) const
Whether *this and x represent the same set.
Definition: apxx_abstract0.hh:367

apron::manager
Library manager (ap_manager_t wrapper).
Definition: apxx_manager.hh:137

apron::abstract0::forget
abstract0 & forget(manager &m, ap_dim_t dim, bool project=false)
Forgets about the value of dimension dim in *this.
Definition: apxx_abstract0.hh:963

apron::abstract0::bound
interval bound(manager &m, const linexpr0 &l) const
Returns some bounds for a linear expression evaluated in all points in the abstract element.
Definition: apxx_abstract0.hh:448

apron::abstract0::canonicalize
abstract0 & canonicalize(manager &m)
Puts the abstract element in canonical form (if such a notion exists).
Definition: apxx_abstract0.hh:257

apxx_linexpr0.hh

apron::abstract0::sat
bool sat(manager &m, const lincons0 &l) const
Whether all points in *this satisfy a linear constraint.
Definition: apxx_abstract0.hh:381

apron::abstract0::operator+=
abstract0 & operator+=(const abstract0 &y)
Replaces *this with the join of *this and the abstract element y.
Definition: apxx_abstract0.hh:665

apron::abstract0::deserialize
friend abstract0 & deserialize(manager &m, abstract0 &dst, const std::string &s, size_t *eaten)
Reconstruct an abstract element form a serialized byte-stream and put it into dst.
Definition: apxx_abstract0.hh:314

apron::abstract0::is_top
bool is_top(manager &m) const
Whether *this represents the full space.
Definition: apxx_abstract0.hh:360

apron::abstract0::get_dimension
ap_dimension_t get_dimension(manager &m) const
Returns the number of integer and real dimensions in the abstract element.
Definition: apxx_abstract0.hh:334

apron::abstract0::operator!=
friend bool operator!=(const abstract0 &x, const abstract0 &y)
Whether x and y represent different sets.
Definition: apxx_abstract0.hh:417

apron::abstract0::approximate
abstract0 & approximate(manager &m, int algorithm)
Simplifies the abstract element, potentially loosing precision.
Definition: apxx_abstract0.hh:264

apron::abstract0::join
abstract0 & join(manager &m, const abstract0 &y)
Replaces *this with the join of *this and the abstract element y.
Definition: apxx_abstract0.hh:554

apron::abstract0::minimize
abstract0 & minimize(manager &m)
Minimizes the size of the representation, to save memory.
Definition: apxx_abstract0.hh:250

apron::abstract0::remove_dimensions
abstract0 & remove_dimensions(manager &m, const dimchange &d)
Removes some dimensions from *this.
Definition: apxx_abstract0.hh:1022

apron::abstract0::is_leq
bool is_leq(manager &m, const abstract0 &x) const
Whether *this is included in x (set-wise).
Definition: apxx_abstract0.hh:374

apron::abstract0::substitute
abstract0 & substitute(manager &m, ap_dim_t dim, const linexpr0 &l, const abstract0 &inter=null)
In-place substitution (backward assignment) of linear expression.
Definition: apxx_abstract0.hh:831

apron::abstract0::dump
void dump(manager &m, FILE *stream=stdout) const
Raw printing to a C stream (mainly for debug purposes).
Definition: apxx_abstract0.hh:287

apron::abstract0::printdiff
friend void printdiff(manager &m, const abstract0 &x, const abstract0 &y, char **name_of_dim, FILE *stream)
Pretty-printing the difference between x and y to a C stream.
Definition: apxx_abstract0.hh:281

apron::abstract0::get_ap_abstract0_t
ap_abstract0_t * get_ap_abstract0_t()
Returns a pointer to the internal APRON object stored in *this.
Definition: apxx_abstract0.hh:1173

apron::texpr0
Level 0 arbitrary expression tree (ap_texpr0_t wrapper).
Definition: apxx_texpr0.hh:92

apron::bottom
Empty interval or domain, to simplify initialisations and assignments.
Definition: apxx_interval.hh:33

apron::abstract0::to_generator_array
generator0_array to_generator_array(manager &m) const
Returns a generator representation of (an over-approximation of) the set represented by the abstract ...
Definition: apxx_abstract0.hh:500

apron::abstract0::free
void free(manager &m)
Destroys the abstract element using the given manager.
Definition: apxx_abstract0.hh:90

apron::abstract0::~abstract0
~abstract0()
Destroys the abstract element.
Definition: apxx_abstract0.hh:84

apron::top
Full interval (]-oo,+oo[) or domain, to simplify initialisations and assignments.
Definition: apxx_interval.hh:27

apron::abstract0::permute_dimensions
abstract0 & permute_dimensions(manager &m, const dimperm &d)
Permutes some dimensions in *this.
Definition: apxx_abstract0.hh:1030

apron::abstract0::to_lincons_array
lincons0_array to_lincons_array(manager &m) const
Returns a linear constraint representation of (an over-approximation of) the set represented by the a...
Definition: apxx_abstract0.hh:484

apron::tcons0
Level 0 arbitrary constraint (ap_tcons0_t wrapper).
Definition: apxx_tcons0.hh:47

apron::abstract0::to_tcons_array
tcons0_array to_tcons_array(manager &m) const
Returns a constraint representation of (an over-approximation of) the set represented by the abstract...
Definition: apxx_abstract0.hh:492

apron::interval
Interval (ap_interval_t wrapper).
Definition: apxx_interval.hh:47

apron::use_malloc
Inherited by most wrappers to map new and delete to malloc and free.
Definition: apxx_scalar.hh:69

apron::abstract0::meet
abstract0 & meet(manager &m, const abstract0 &y)
Replaces *this with the meet of *this and the abstract element y.
Definition: apxx_abstract0.hh:512

apron::lincons0_array
Array of linear constraints (ap_lincons0_array_t wrapper).
Definition: apxx_lincons0.hh:341

apron::abstract0::abstract0
abstract0(ap_abstract0_t *x)
Internal use only. Wraps an abstract0 around the pointer x, taking ownership of the object.
Definition: apxx_abstract0.hh:28

apron::abstract0::operator>
friend bool operator>(const abstract0 &x, const abstract0 &y)
Whether x strictly contains y (set-wise).
Definition: apxx_abstract0.hh:434

apron::abstract0::size
size_t size(manager &m) const
Returns the (abstract) size of the abstract element.
Definition: apxx_abstract0.hh:341

apxx_manager.hh

apron::abstract0::operator *=
abstract0 & operator *=(const abstract0 &y)
Replaces *this with the meet of *this and the abstract element y.
Definition: apxx_abstract0.hh:658

apron::abstract0::add_dimensions
abstract0 & add_dimensions(manager &m, const dimchange &d, bool project=false)
Adds some dimensions to *this.
Definition: apxx_abstract0.hh:1012

apxx_abstract0_inline.hh

apron::abstract0::widening
friend abstract0 & widening(manager &m, abstract0 &dst, const abstract0 &x, const abstract0 &y)
Stores in dst the result of x widened with y.
Definition: apxx_abstract0.hh:1128

apron::abstract0::closure
abstract0 & closure(manager &m)
Replaces *this with its topological closure.
Definition: apxx_abstract0.hh:1152

apron::tcons0_array
Array of arbitrary constraints (ap_tcons0_array_t wrapper).
Definition: apxx_tcons0.hh:350

apron::lincons0
Level 0 linear constraint (ap_lincons0_t wrapper).
Definition: apxx_lincons0.hh:43

apron::dim
Represents a dimension (i.e., variable by index) in an expression tree.
Definition: apxx_texpr0.hh:33

apron::abstract0::operator=
abstract0 & operator=(const abstract0 &t)
Assigns a copy of t to *this.
Definition: apxx_abstract0.hh:100

apron::abstract0::to_box
interval_array to_box(manager &m) const
Returns a bounding box for the set represented by the abstract element.
Definition: apxx_abstract0.hh:476

apron::linexpr0
Level 0 linear expression (ap_linexpr0_t wrapper).
Definition: apxx_linexpr0.hh:44