PPL: Parma_Polyhedra_Library::Concrete_Expression< Target > Class Template Reference

PPL 1.2

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes

- Class List
- Class Hierarchy
- Class Members

Related Functions | List of all members
Parma_Polyhedra_Library::Concrete_Expression< Target > Class Template Reference

The base class of all concrete expressions. More...

`#include <ppl.hh>`

## Related Functions
(Note that these are not member functions.)
template<typename Target , typename FP_Interval_Type >
static bool | add_linearize (const Binary_Operator< Target > &bop_expr, const FP_Oracle< Target, FP_Interval_Type > &oracle, const std::map< dimension_type, Linear_Form< FP_Interval_Type > > &lf_store, Linear_Form< FP_Interval_Type > &result)
template<typename Target , typename FP_Interval_Type >
static bool | sub_linearize (const Binary_Operator< Target > &bop_expr, const FP_Oracle< Target, FP_Interval_Type > &oracle, const std::map< dimension_type, Linear_Form< FP_Interval_Type > > &lf_store, Linear_Form< FP_Interval_Type > &result)
template<typename Target , typename FP_Interval_Type >
static bool | mul_linearize (const Binary_Operator< Target > &bop_expr, const FP_Oracle< Target, FP_Interval_Type > &oracle, const std::map< dimension_type, Linear_Form< FP_Interval_Type > > &lf_store, Linear_Form< FP_Interval_Type > &result)
template<typename Target , typename FP_Interval_Type >
static bool | div_linearize (const Binary_Operator< Target > &bop_expr, const FP_Oracle< Target, FP_Interval_Type > &oracle, const std::map< dimension_type, Linear_Form< FP_Interval_Type > > &lf_store, Linear_Form< FP_Interval_Type > &result)
template<typename Target , typename FP_Interval_Type >
static bool | cast_linearize (const Cast_Operator< Target > &cast_expr, const FP_Oracle< Target, FP_Interval_Type > &oracle, const std::map< dimension_type, Linear_Form< FP_Interval_Type > > &lf_store, Linear_Form< FP_Interval_Type > &result)
template<typename Target , typename FP_Interval_Type >
bool | linearize (const Concrete_Expression< Target > &expr, const FP_Oracle< Target, FP_Interval_Type > &oracle, const std::map< dimension_type, Linear_Form< FP_Interval_Type > > &lf_store, Linear_Form< FP_Interval_Type > &result)
| Linearizes a floating point expression. More...

## Detailed Description

### template<typename Target>
class Parma_Polyhedra_Library::Concrete_Expression< Target >

The base class of all concrete expressions.

## Friends And Related Function Documentation

template<typename Target , typename FP_Interval_Type >

static bool add_linearize | ( | const Binary_Operator< Target > & | bop_expr,
|  | const FP_Oracle< Target, FP_Interval_Type > & | oracle,
|  | const std::map< dimension_type, Linear_Form< FP_Interval_Type > > & | lf_store,
|  | Linear_Form< FP_Interval_Type > & | result
| ) |  |
| related

Helper function used by `linearize` to linearize a sum of floating point expressions.

Makes `result` become the linearization of `*this` in the given composite abstract store.

Template Parameters

  Target | A type template parameter specifying the instantiation of Concrete_Expression to be used.
  FP_Interval_Type | A type template parameter for the intervals used in the abstract domain. The interval bounds should have a floating point type.

Returns
  `true` if the linearization succeeded, `false` otherwise.

Parameters

  bop_expr | The binary operator concrete expression to linearize. Its binary operator type must be `ADD`.
  oracle | The FP_Oracle to be queried.
  lf_store | The linear form abstract store.
  result | The modified linear form.

Linearization of sum floating-point expressions

Let and be two linear forms and a sound abstract operator on linear forms such that:

Given an expression and a composite abstract store , we construct the interval linear form as follows:

where is the relative error associated to (see method `relative_error` of class Linear_Form) and is a rounding error computed by function `compute_absolute_error`.

template<typename Target , typename FP_Interval_Type >

static bool sub_linearize | ( | const Binary_Operator< Target > & | bop_expr,
|  | const FP_Oracle< Target, FP_Interval_Type > & | oracle,
|  | const std::map< dimension_type, Linear_Form< FP_Interval_Type > > & | lf_store,
|  | Linear_Form< FP_Interval_Type > & | result
| ) |  |
| related

Helper function used by `linearize` to linearize a difference of floating point expressions.

Makes `result` become the linearization of `*this` in the given composite abstract store.

Template Parameters

  Target | A type template parameter specifying the instantiation of Concrete_Expression to be used.
  FP_Interval_Type | A type template parameter for the intervals used in the abstract domain. The interval bounds should have a floating point type.

Returns
  `true` if the linearization succeeded, `false` otherwise.

Parameters

  bop_expr | The binary operator concrete expression to linearize. Its binary operator type must be `SUB`.
  oracle | The FP_Oracle to be queried.
  lf_store | The linear form abstract store.
  result | The modified linear form.

Linearization of difference floating-point expressions

Let and be two linear forms, and two sound abstract operators on linear form such that:

Given an expression and a composite abstract store , we construct the interval linear form on as follows:

where is the relative error associated to (see method `relative_error` of class Linear_Form) and is a rounding error computed by function `compute_absolute_error`.

template<typename Target , typename FP_Interval_Type >

static bool mul_linearize | ( | const Binary_Operator< Target > & | bop_expr,
|  | const FP_Oracle< Target, FP_Interval_Type > & | oracle,
|  | const std::map< dimension_type, Linear_Form< FP_Interval_Type > > & | lf_store,
|  | Linear_Form< FP_Interval_Type > & | result
| ) |  |
| related

Helper function used by `linearize` to linearize a product of floating point expressions.

Makes `result` become the linearization of `*this` in the given composite abstract store.

Template Parameters

  Target | A type template parameter specifying the instantiation of Concrete_Expression to be used.
  FP_Interval_Type | A type template parameter for the intervals used in the abstract domain. The interval bounds should have a floating point type.

Returns
  `true` if the linearization succeeded, `false` otherwise.

Parameters

  bop_expr | The binary operator concrete expression to linearize. Its binary operator type must be `MUL`.
  oracle | The FP_Oracle to be queried.
  lf_store | The linear form abstract store.
  result | The modified linear form.

Linearization of multiplication floating-point expressions

Let and be two linear forms, and two sound abstract operators on linear forms such that:

Given an expression and a composite abstract store , we construct the interval linear form as follows:

.

Given an expression and a composite abstract store , we construct the interval linear form as follows:

Given an expression and a composite abstract store , we construct the interval linear form as follows:

where is the relative error associated to (see method `relative_error` of class Linear_Form), is the intervalization of (see method `intervalize` of class Linear_Form), and is a rounding error computed by function `compute_absolute_error`.

Even though we intervalize the first operand in the above example, the actual implementation utilizes an heuristics for choosing which of the two operands must be intervalized in order to obtain the most precise result.

template<typename Target , typename FP_Interval_Type >

static bool div_linearize | ( | const Binary_Operator< Target > & | bop_expr,
|  | const FP_Oracle< Target, FP_Interval_Type > & | oracle,
|  | const std::map< dimension_type, Linear_Form< FP_Interval_Type > > & | lf_store,
|  | Linear_Form< FP_Interval_Type > & | result
| ) |  |
| related

Helper function used by `linearize` to linearize a division of floating point expressions.

Makes `result` become the linearization of `*this` in the given composite abstract store.

Template Parameters

  Target | A type template parameter specifying the instantiation of Concrete_Expression to be used.
  FP_Interval_Type | A type template parameter for the intervals used in the abstract domain. The interval bounds should have a floating point type.

Returns
  `true` if the linearization succeeded, `false` otherwise.

Parameters

  bop_expr | The binary operator concrete expression to linearize. Its binary operator type must be `DIV`.
  oracle | The FP_Oracle to be queried.
  lf_store | The linear form abstract store.
  result | The modified linear form.

Linearization of division floating-point expressions

Let and be two linear forms, and two sound abstract operator on linear forms such that:

Given an expression and a composite abstract store , we construct the interval linear form as follows:

given an expression and a composite abstract store , we construct the interval linear form as follows:

where is the relative error associated to (see method `relative_error` of class Linear_Form), is the intervalization of (see method `intervalize` of class Linear_Form), and is a rounding error computed by function `compute_absolute_error`.

template<typename Target , typename FP_Interval_Type >

static bool cast_linearize | ( | const Cast_Operator< Target > & | cast_expr,
|  | const FP_Oracle< Target, FP_Interval_Type > & | oracle,
|  | const std::map< dimension_type, Linear_Form< FP_Interval_Type > > & | lf_store,
|  | Linear_Form< FP_Interval_Type > & | result
| ) |  |
| related

Helper function used by `linearize` to linearize a cast floating point expression.

Makes `result` become the linearization of `*this` in the given composite abstract store.

Template Parameters

  Target | A type template parameter specifying the instantiation of Concrete_Expression to be used.
  FP_Interval_Type | A type template parameter for the intervals used in the abstract domain. The interval bounds should have a floating point type.

Returns
  `true` if the linearization succeeded, `false` otherwise.

Parameters

  cast_expr | The cast operator concrete expression to linearize.
  oracle | The FP_Oracle to be queried.
  lf_store | The linear form abstract store.
  result | The modified linear form.

template<typename Target , typename FP_Interval_Type >

bool linearize | ( | const Concrete_Expression< Target > & | expr,
|  | const FP_Oracle< Target, FP_Interval_Type > & | oracle,
|  | const std::map< dimension_type, Linear_Form< FP_Interval_Type > > & | lf_store,
|  | Linear_Form< FP_Interval_Type > & | result
| ) |  |
| related

Linearizes a floating point expression.

Makes `result` become a linear form that correctly approximates the value of `expr` in the given composite abstract store.

Template Parameters

  Target | A type template parameter specifying the instantiation of Concrete_Expression to be used.
  FP_Interval_Type | A type template parameter for the intervals used in the abstract domain. The interval bounds should have a floating point type.

Returns
  `true` if the linearization succeeded, `false` otherwise.

Parameters

  expr | The concrete expression to linearize.
  oracle | The FP_Oracle to be queried.
  lf_store | The linear form abstract store.
  result | Becomes the linearized expression.

Formally, if `expr` represents the expression and `lf_store` represents the linear form abstract store , then `result` will become if the linearization succeeds.

The documentation for this class was generated from the following file:

- ppl.hh