| PPL
    1.2
    | 
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... | |
The base class of all concrete expressions.
| 
 | 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.
| 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. | 
true if the linearization succeeded, false otherwise.| 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. | 
Let  and
 and  be two linear forms and
 be two linear forms and  a sound abstract operator on linear forms such that:
 a sound abstract operator on linear forms such that:
![\[ \left(i + \sum_{v \in \cV}i_{v}v \right) \aslf \left(i' + \sum_{v \in \cV}i'_{v}v \right) = \left(i \asifp i'\right) + \sum_{v \in \cV}\left(i_{v} \asifp i'_{v} \right)v. \]](form_815.png) 
Given an expression  and a composite abstract store
 and a composite abstract store  , we construct the interval linear form
, we construct the interval linear form  as follows:
 as follows: 
![\[ \linexprenv{e_{1} \oplus e_{2}}{\rho^{\#}}{\rho^{\#}_l} = \linexprenv{e_{1}}{\rho^{\#}}{\rho^{\#}_l} \aslf \linexprenv{e_{2}}{\rho^{\#}}{\rho^{\#}_l} \aslf \varepsilon_{\mathbf{f}}\left(\linexprenv{e_{1}}{\rho^{\#}}{\rho^{\#}_l} \right) \aslf \varepsilon_{\mathbf{f}}\left(\linexprenv{e_{2}}{\rho^{\#}}{\rho^{\#}_l} \right) \aslf mf_{\mathbf{f}}[-1, 1] \]](form_818.png) 
 where  is the relative error associated to
 is the relative error associated to  (see method
 (see method relative_error of class Linear_Form) and  is a rounding error computed by function
 is a rounding error computed by function compute_absolute_error. 
| 
 | 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.
| 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. | 
true if the linearization succeeded, false otherwise.| 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. | 
Let  and
 and  be two linear forms,
 be two linear forms,  and
 and  two sound abstract operators on linear form such that:
 two sound abstract operators on linear form such that: 
![\[ \left(i + \sum_{v \in \cV}i_{v}v\right) \aslf \left(i' + \sum_{v \in \cV}i'_{v}v\right) = \left(i \asifp i'\right) + \sum_{v \in \cV}\left(i_{v} \asifp i'_{v}\right)v, \]](form_822.png) 
![\[ \left(i + \sum_{v \in \cV}i_{v}v\right) \adlf \left(i' + \sum_{v \in \cV}i'_{v}v\right) = \left(i \adifp i'\right) + \sum_{v \in \cV}\left(i_{v} \adifp i'_{v}\right)v. \]](form_823.png) 
 Given an expression  and a composite abstract store
 and a composite abstract store  , we construct the interval linear form
, we construct the interval linear form  on
 on  as follows:
 as follows: 
![\[ \linexprenv{e_{1} \ominus e_{2}}{\rho^{\#}}{\rho^{\#}_l} = \linexprenv{e_{1}}{\rho^{\#}}{\rho^{\#}_l} \adlf \linexprenv{e_{2}}{\rho^{\#}}{\rho^{\#}_l} \aslf \varepsilon_{\mathbf{f}}\left(\linexprenv{e_{1}}{\rho^{\#}}{\rho^{\#}_l} \right) \aslf \varepsilon_{\mathbf{f}}\left(\linexprenv{e_{2}}{\rho^{\#}}{\rho^{\#}_l} \right) \aslf mf_{\mathbf{f}}[-1, 1] \]](form_826.png) 
 where  is the relative error associated to
 is the relative error associated to  (see method
 (see method relative_error of class Linear_Form) and  is a rounding error computed by function
 is a rounding error computed by function compute_absolute_error. 
| 
 | 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.
| 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. | 
true if the linearization succeeded, false otherwise.| 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. | 
Let  and
 and  be two linear forms,
 be two linear forms,  and
 and  two sound abstract operators on linear forms such that:
 two sound abstract operators on linear forms such that: 
![\[ \left(i + \sum_{v \in \cV}i_{v}v\right) \aslf \left(i' + \sum_{v \in \cV}i'_{v}v\right) = \left(i \asifp i'\right) + \sum_{v \in \cV}\left(i_{v} \asifp i'_{v}\right)v, \]](form_822.png) 
![\[ i \amlf \left(i' + \sum_{v \in \cV}i'_{v}v\right) = \left(i \amifp i'\right) + \sum_{v \in \cV}\left(i \amifp i'_{v}\right)v. \]](form_828.png) 
 Given an expression ![$[a, b] \otimes e_{2}$](form_829.png) and a composite abstract store
 and a composite abstract store  , we construct the interval linear form
, we construct the interval linear form ![$\linexprenv{[a, b] \otimes e_{2}}{\rho^{\#}}{\rho^{\#}_l}$](form_830.png) as follows:
 as follows: 
![\[ \linexprenv{[a, b] \otimes e_{2}}{\rho^{\#}}{\rho^{\#}_l} = \left([a, b] \amlf \linexprenv{e_{2}}{\rho^{\#}}{\rho^{\#}_l}\right) \aslf \left([a, b] \amlf \varepsilon_{\mathbf{f}}\left(\linexprenv{e_{2}}{\rho^{\#}}{\rho^{\#}_l} \right)\right) \aslf mf_{\mathbf{f}}[-1, 1]. \]](form_831.png) 
.
Given an expression ![$e_{1} \otimes [a, b]$](form_832.png) and a composite abstract store
 and a composite abstract store  , we construct the interval linear form
, we construct the interval linear form ![$\linexprenv{e_{1} \otimes [a, b]}{\rho^{\#}}{\rho^{\#}_l}$](form_833.png) as follows:
 as follows: 
![\[ \linexprenv{e_{1} \otimes [a, b]}{\rho^{\#}}{\rho^{\#}_l} = \linexprenv{[a, b] \otimes e_{1}}{\rho^{\#}}{\rho^{\#}_l}. \]](form_834.png) 
Given an expression  and a composite abstract store
 and a composite abstract store  , we construct the interval linear form
, we construct the interval linear form  as follows:
 as follows: 
![\[ \linexprenv{e_{1} \otimes e_{2}}{\rho^{\#}}{\rho^{\#}_l} = \linexprenv{\iota\left(\linexprenv{e_{1}}{\rho^{\#}}{\rho^{\#}_l} \right)\rho^{\#} \otimes e_{2}}{\rho^{\#}}{\rho^{\#}_l}, \]](form_837.png) 
 where  is the relative error associated to
 is the relative error associated to  (see method
 (see method relative_error of class Linear_Form),  is the intervalization of
 is the intervalization of  (see method
 (see method intervalize of class Linear_Form), and  is a rounding error computed by function
 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.
| 
 | 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.
| 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. | 
true if the linearization succeeded, false otherwise.| 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. | 
Let  and
 and  be two linear forms,
 be two linear forms,  and
 and  two sound abstract operator on linear forms such that:
 two sound abstract operator on linear forms such that: 
![\[ \left(i + \sum_{v \in \cV}i_{v}v\right) \aslf \left(i' + \sum_{v \in \cV}i'_{v}v\right) = \left(i \asifp i'\right) + \sum_{v \in \cV}\left(i_{v} \asifp i'_{v}\right)v, \]](form_822.png) 
![\[ \left(i + \sum_{v \in \cV}i_{v}v\right) \adivlf i' = \left(i \adivifp i'\right) + \sum_{v \in \cV}\left(i_{v} \adivifp i'\right)v. \]](form_840.png) 
 Given an expression ![$e_{1} \oslash [a, b]$](form_841.png) and a composite abstract store
 and a composite abstract store  , we construct the interval linear form
, we construct the interval linear form ![$ \linexprenv{e_{1} \oslash [a, b]}{\rho^{\#}}{\rho^{\#}_l} $](form_842.png) as follows:
 as follows: 
![\[ \linexprenv{e_{1} \oslash [a, b]}{\rho^{\#}}{\rho^{\#}_l} = \left(\linexprenv{e_{1}}{\rho^{\#}}{\rho^{\#}_l} \adivlf [a, b]\right) \aslf \left(\varepsilon_{\mathbf{f}}\left( \linexprenv{e_{1}}{\rho^{\#}}{\rho^{\#}_l} \right) \adivlf [a, b]\right) \aslf mf_{\mathbf{f}}[-1, 1], \]](form_843.png) 
 given an expression  and a composite abstract store
 and a composite abstract store  , we construct the interval linear form
, we construct the interval linear form  as follows:
 as follows: 
![\[ \linexprenv{e_{1} \oslash e_{2}}{\rho^{\#}}{\rho^{\#}_l} = \linexprenv{e_{1} \oslash \iota\left( \linexprenv{e_{2}}{\rho^{\#}}{\rho^{\#}_l} \right)\rho^{\#}}{\rho^{\#}}{\rho^{\#}_l}, \]](form_846.png) 
 where  is the relative error associated to
 is the relative error associated to  (see method
 (see method relative_error of class Linear_Form),  is the intervalization of
 is the intervalization of  (see method
 (see method intervalize of class Linear_Form), and  is a rounding error computed by function
 is a rounding error computed by function compute_absolute_error. 
| 
 | 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.
| 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. | 
true if the linearization succeeded, false otherwise.| 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. | 
| 
 | 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.
| 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. | 
true if the linearization succeeded, false otherwise.| 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
 and lf_store represents the linear form abstract store  , then
, then result will become  if the linearization succeeds.
 if the linearization succeeds.