Classes | |
struct | Compile_Time_Check< true > |
A class that is only defined if b evaluates to true . More... | |
struct | Bool |
A class holding a constant called value that evaluates to b . More... | |
struct | True |
A class holding a constant called value that evaluates to true . More... | |
struct | False |
A class holding a constant called value that evaluates to false . More... | |
struct | Is_Same |
A class holding a constant called value that evaluates to true if and only if T1 is the same type as T2 . More... | |
struct | Is_Same< T, T > |
A class holding a constant called value that evaluates to true if and only if T1 is the same type as T2 . More... | |
struct | Is_Same_Or_Derived |
A class holding a constant called value that evaluates to true if and only if Base is the same type as Derived or Derived is a class derived from Base . More... | |
struct | Enable_If |
A class that provides a type member called type equivalent to T if and only if b is true . More... | |
struct | Enable_If_Is |
struct | Enable_If< true, T > |
A class that provides a type member called type equivalent to T if and only if b is true . More... | |
struct | Is_Native |
struct | Is_Native< signed char > |
struct | Is_Native< signed short > |
struct | Is_Native< signed int > |
struct | Is_Native< signed long > |
struct | Is_Native< signed long long > |
struct | Is_Native< unsigned char > |
struct | Is_Native< unsigned short > |
struct | Is_Native< unsigned int > |
struct | Is_Native< unsigned long > |
struct | Is_Native< unsigned long long > |
struct | Is_Native< mpz_class > |
struct | Is_Native< mpq_class > |
struct | float_ieee754_single |
struct | float_ieee754_double |
struct | float_intel_double_extended |
struct | float_ieee754_quad |
class | Float |
struct | Checked_Number_Default_Policy |
struct | Extended_Number_Policy |
struct | WRD_Extended_Number_Policy |
struct | Check_Overflow_Policy |
A policy checking for overflows. More... | |
struct | Native_Checked_From_Wrapper< T, typename Enable_If< Is_Native< T >::value >::type > |
struct | Native_Checked_From_Wrapper< Checked_Number< T, P > > |
struct | Native_Checked_To_Wrapper< T, typename Enable_If< Is_Native< T >::value >::type > |
struct | Native_Checked_To_Wrapper< Checked_Number< T, P > > |
struct | Is_Checked |
struct | Is_Checked< Checked_Number< T, P > > |
struct | Is_Native_Or_Checked |
class | Checked_Number |
A wrapper for numeric types implementing a given policy. More... | |
struct | Slow_Copy< Checked_Number< T, P > > |
struct | FPU_Related< Checked_Number< T, Policy > > |
struct | Coefficient_traits_template< GMP_Integer > |
Coefficient traits specialization for unbounded integers. More... | |
struct | Coefficient_traits_template |
Coefficient traits. More... | |
struct | Minus_Infinity |
struct | Plus_Infinity |
struct | Not_A_Number |
struct | Is_Special |
struct | Is_Special< Minus_Infinity > |
struct | Is_Special< Plus_Infinity > |
struct | Is_Special< Not_A_Number > |
struct | Checked_Number_Transparent_Policy |
class | Init |
Class for initialization and finalization. More... | |
class | Throwable |
User objects the PPL can throw. More... | |
struct | From_Covering_Box |
A tag class. More... | |
struct | Recycle_Input |
A tag class. More... | |
struct | Fit |
struct | Fit< T, v, typename Enable_If< C_Integer< T >::value >::type > |
struct | TConstant |
struct | Constant_ |
struct | Constant_< T, v, prefer_signed, typename Enable_If<(Fit< typename C_Integer< T >::smaller_signed_type, v >::value &&(prefer_signed||!Fit< typename C_Integer< T >::smaller_unsigned_type, v >::value))>::type > |
struct | Constant_< T, v, prefer_signed, typename Enable_If<(Fit< typename C_Integer< T >::smaller_unsigned_type, v >::value &&(!prefer_signed||!Fit< typename C_Integer< T >::smaller_signed_type, v >::value))>::type > |
struct | Constant |
struct | Has_OK |
struct | Has_OK< T, typename Enable_If_Is< bool(T::*)() const,&T::OK >::type > |
struct | Rectilinear_Distance_Specialization |
struct | Euclidean_Distance_Specialization |
struct | L_Infinity_Distance_Specialization |
struct | maybe_assign_struct |
struct | maybe_assign_struct< Type, Type > |
class | stdiobuf |
class | Row_Impl_Handler |
The handler of the actual Row implementation. More... | |
class | Row |
A finite sequence of coefficients. More... | |
class | Matrix |
A 2-dimensional matrix of coefficients. More... | |
class | Linear_Row |
The base class for linear expressions, constraints and generators. More... | |
class | Linear_System |
The base class for systems of constraints and generators. More... | |
class | MIP_Problem |
A Mixed Integer (linear) Programming problem. More... | |
class | Bit_Row |
A row in a matrix of bits. More... | |
class | Bit_Matrix |
A matrix of bits. More... | |
class | Variable |
A dimension of the vector space. More... | |
class | Linear_Expression |
A linear expression. More... | |
class | Constraint |
A linear equality or inequality. More... | |
class | Congruence |
A linear congruence. More... | |
class | Generator |
A line, ray, point or closure point. More... | |
class | Grid_Generator |
A grid line, parameter or grid point. More... | |
class | Constraint_System |
A system of constraints. More... | |
class | Congruence_System |
A system of congruences. More... | |
class | Generator_System |
A system of generators. More... | |
class | Grid_Generator_System |
A system of grid generators. More... | |
class | Scalar_Products |
A class implementing various scalar product functions. More... | |
class | Topology_Adjusted_Scalar_Product_Sign |
Scalar product sign function object depending on topology. More... | |
class | Polyhedron |
The base class for convex polyhedra. More... | |
class | Grid |
A grid. More... | |
class | Poly_Con_Relation |
The relation between a polyhedron and a constraint. More... | |
class | Poly_Gen_Relation |
The relation between a polyhedron and a generator. More... | |
struct | Boundary_Value |
struct | Boundary_Value< T, typename Enable_If< Is_Same_Or_Derived< Interval_Base, T >::value >::type > |
class | Interval_Restriction_None_Base |
class | Interval_Restriction_None |
class | Interval_Restriction_Integer_Base |
class | Interval_Restriction_Integer |
class | Simple_Restriction_Integer |
struct | Restriction_Integer< From, Base, typename Enable_If< Is_Native_Or_Checked< From >::value >::type > |
struct | Restriction_Integer< From, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_None_Base, typename From::info_type >::value >::type > |
struct | Restriction_Integer< From, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_Integer_Base, typename From::info_type >::value >::type > |
class | Interval_Restriction_Integer_Modulo_Base |
class | Interval_Restriction_Integer_Modulo |
struct | Slow_Copy< Interval_Restriction_Integer_Modulo< T, Base > > |
struct | Restriction_Integer< From, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_Integer_Modulo_Base, typename From::info_type >::value >::type > |
struct | Simple_Restriction_Integer_Modulo |
struct | Restriction_Integer_Modulo< From, T, Base, typename Enable_If< Is_Native_Or_Checked< From >::value >::type > |
struct | Restriction_Integer_Modulo< From, T, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_None_Base, typename From::info_type >::value >::type > |
struct | Restriction_Integer_Modulo< From, T, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_Integer_Base, typename From::info_type >::value >::type > |
struct | Restriction_Integer_Modulo< From, T, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_Integer_Modulo_Base, typename From::info_type >::value >::type > |
class | Interval_Info_Null |
class | Interval_Info_Null_Open |
class | Interval_Info_Bitset |
struct | Interval_Base |
struct | Is_Singleton |
struct | Is_Interval |
class | Interval |
A generic, not necessarily closed, possibly restricted interval. More... | |
struct | Select_Temp_Boundary_Type |
struct | Select_Temp_Boundary_Type< float > |
struct | Select_Temp_Boundary_Type< signed char > |
struct | Select_Temp_Boundary_Type< unsigned char > |
struct | Select_Temp_Boundary_Type< signed short > |
struct | Select_Temp_Boundary_Type< unsigned short > |
struct | Select_Temp_Boundary_Type< signed int > |
struct | Select_Temp_Boundary_Type< unsigned int > |
struct | Select_Temp_Boundary_Type< signed long > |
struct | Select_Temp_Boundary_Type< unsigned long > |
struct | Select_Temp_Boundary_Type< unsigned long long > |
class | C_Polyhedron |
A closed convex polyhedron. More... | |
class | NNC_Polyhedron |
A not necessarily closed convex polyhedron. More... | |
class | Widening_Function |
Wraps a widening method into a function object. More... | |
class | Limited_Widening_Function |
Wraps a limited widening method into a function object. More... | |
class | BHRZ03_Certificate |
The convergence certificate for the BHRZ03 widening operator. More... | |
class | H79_Certificate |
A convergence certificate for the H79 widening operator. More... | |
class | Grid_Certificate |
The convergence certificate for the Grid widening operator. More... | |
class | Determinate |
Wraps a PPL class into a determinate constraint system interface. More... | |
class | iterator_to_const |
An iterator on a sequence of read-only objects. More... | |
class | const_iterator_to_const |
A const_iterator on a sequence of read-only objects. More... | |
class | Powerset |
The powerset construction on a base-level domain. More... | |
class | Pointset_Powerset |
The powerset construction instantiated on PPL pointset domains. More... | |
class | Smash_Reduction |
This class provides the reduction method for the Smash_Product domain. More... | |
class | Constraints_Reduction |
This class provides the reduction method for the Constraints_Product domain. More... | |
class | No_Reduction |
class | Partially_Reduced_Product |
The partially reduced product of two abstractions. More... | |
class | Domain_Product |
This class is temporary and will be removed when template typedefs will be supported in C++. More... | |
class | Box |
A not necessarily closed, iso-oriented hyperrectangle. More... | |
class | DB_Row_Impl_Handler |
The handler of the actual DB_Row implementation. More... | |
class | DB_Row |
The base class for the single rows of matrices. More... | |
class | DB_Matrix |
The base class for the square matrices. More... | |
class | BD_Shape |
A bounded difference shape. More... | |
class | OR_Matrix |
A matrix representing octagonal constraints. More... | |
class | Octagonal_Shape |
An octagonal shape. More... | |
class | GMP_Integer |
Unbounded integers as provided by the GMP library. More... | |
Namespaces | |
namespace | Checked |
Types and functions implementing checked numbers. | |
namespace | Implementation |
Implementation related data and functions. | |
namespace | Interfaces |
Data and functions related to foreign language interfaces. | |
namespace | Interval_NS |
namespace | IO_Operators |
All input/output operators are confined to this namespace. | |
Typedefs | |
typedef mpz_class | GMP_Integer |
typedef PPL_COEFFICIENT_TYPE | Coefficient |
An alias for easily naming the type of PPL coefficients. | |
typedef Coefficient_traits_template < Coefficient > | Coefficient_traits |
An alias for easily naming the coefficient traits. | |
typedef size_t | dimension_type |
An unsigned integral type for representing space dimensions. | |
typedef size_t | memory_size_type |
An unsigned integral type for representing memory size in bytes. | |
Enumerations | |
enum | Degenerate_Element { UNIVERSE, EMPTY } |
Kinds of degenerate abstract elements. More... | |
enum | Relation_Symbol { LESS_THAN, LESS_OR_EQUAL, EQUAL, GREATER_OR_EQUAL, GREATER_THAN, NOT_EQUAL } |
Relation symbols. More... | |
enum | Complexity_Class { POLYNOMIAL_COMPLEXITY, SIMPLEX_COMPLEXITY, ANY_COMPLEXITY } |
Complexity pseudo-classes. More... | |
enum | Optimization_Mode { MINIMIZATION, MAXIMIZATION } |
Possible optimization modes. More... | |
enum | Topology { NECESSARILY_CLOSED = 0, NOT_NECESSARILY_CLOSED = 1 } |
Kinds of polyhedra domains. More... | |
enum | MIP_Problem_Status { UNFEASIBLE_MIP_PROBLEM, UNBOUNDED_MIP_PROBLEM, OPTIMIZED_MIP_PROBLEM } |
Possible outcomes of the MIP_Problem solver. More... | |
enum | I_Result { I_EMPTY = 0, I_MAYBE_EMPTY = 1 << 12, I_SINGULARITIES = 1 << 13 } |
enum | Ternary { T_YES, T_NO, T_MAYBE } |
Functions | |
unsigned | version_major () |
Returns the major number of the PPL version. | |
unsigned | version_minor () |
Returns the minor number of the PPL version. | |
unsigned | version_revision () |
Returns the revision number of the PPL version. | |
unsigned | version_beta () |
Returns the beta number of the PPL version. | |
const char * | version () |
Returns a character string containing the PPL version. | |
const char * | banner () |
Returns a character string containing the PPL banner. | |
void | throw_result_exception (Result r) |
template<typename T> | |
T | plus_infinity () |
template<typename T> | |
T | minus_infinity () |
template<typename T> | |
T | not_a_number () |
template<typename T> | |
void | maybe_reset_fpu_inexact () |
template<typename T> | |
int | maybe_check_fpu_inexact () |
Rounding_Dir | rounding_dir (Rounding_Dir dir) |
Result | check_result (Result r, Rounding_Dir dir) |
COND (PPL_SUPPORTED_FLOAT, DEF_CTOR(float)) COND(PPL_SUPPORTED_DOUBLE | |
DEF_CTOR (double)) COND(PPL_SUPPORTED_LONG_DOUBLE | |
DEF_CTOR (long double)) template< typename T | |
template<typename To, typename From> | |
Enable_If < Is_Native_Or_Checked< To > ::value &&Is_Special< From > ::value, Result >::type | assign_r (To &to, const From &, Rounding_Dir dir) |
template<typename To, typename From> | |
Enable_If < Is_Native_Or_Checked< To > ::value &&Is_Special< From > ::value, Result >::type | construct (To &to, const From &, Rounding_Dir dir) |
template<typename T> | |
Enable_If < Is_Native_Or_Checked< T > ::value, bool >::type | is_minus_infinity (const T &x) |
template<typename T> | |
Enable_If < Is_Native_Or_Checked< T > ::value, bool >::type | is_plus_infinity (const T &x) |
template<typename T> | |
Enable_If < Is_Native_Or_Checked< T > ::value, int >::type | is_infinity (const T &x) |
template<typename T> | |
Enable_If < Is_Native_Or_Checked< T > ::value, bool >::type | is_not_a_number (const T &x) |
template<typename T> | |
Enable_If < Is_Native_Or_Checked< T > ::value, bool >::type | is_integer (const T &x) |
template<typename T, typename Policy> | |
bool | is_not_a_number (const Checked_Number< T, Policy > &x) |
template<typename T, typename Policy> | |
bool | is_minus_infinity (const Checked_Number< T, Policy > &x) |
template<typename T, typename Policy> | |
bool | is_plus_infinity (const Checked_Number< T, Policy > &x) |
template<typename T, typename Policy> | |
void | exact_div_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y, const Checked_Number< T, Policy > &z) |
void | neg_assign (GMP_Integer &x) |
void | neg_assign (GMP_Integer &x, const GMP_Integer &y) |
void | abs_assign (GMP_Integer &x) |
void | abs_assign (GMP_Integer &x, const GMP_Integer &y) |
void | gcd_assign (GMP_Integer &x, const GMP_Integer &y, const GMP_Integer &z) |
void | rem_assign (GMP_Integer &x, const GMP_Integer &y, const GMP_Integer &z) |
void | gcdext_assign (GMP_Integer &x, GMP_Integer &s, GMP_Integer &t, const GMP_Integer &y, const GMP_Integer &z) |
void | lcm_assign (GMP_Integer &x, const GMP_Integer &y, const GMP_Integer &z) |
void | add_mul_assign (GMP_Integer &x, const GMP_Integer &y, const GMP_Integer &z) |
void | sub_mul_assign (GMP_Integer &x, const GMP_Integer &y, const GMP_Integer &z) |
void | exact_div_assign (GMP_Integer &x, const GMP_Integer &y, const GMP_Integer &z) |
void | sqrt_assign (GMP_Integer &x, const GMP_Integer &y) |
int | cmp (const GMP_Integer &x, const GMP_Integer &y) |
const mpz_class & | raw_value (const GMP_Integer &x) |
mpz_class & | raw_value (GMP_Integer &x) |
void | Coefficient_constants_initialize () |
Initializes the Coefficient constants. | |
void | Coefficient_constants_finalize () |
Finalizes the Coefficient constants. | |
Coefficient_traits::const_reference | Coefficient_zero () |
Returns a const reference to a Coefficient with value 0. | |
Coefficient_traits::const_reference | Coefficient_one () |
Returns a const reference to a Coefficient with value 1. | |
unsigned | rational_sqrt_precision_parameter () |
Returns the precision parameter used for rational square root calculations. | |
void | set_rational_sqrt_precision_parameter (const unsigned p) |
Sets the precision parameter used for rational square root calculations. | |
void | set_rounding_for_PPL () |
Sets the FPU rounding mode so that the PPL abstractions based on floating point numbers work correctly. | |
void | restore_pre_PPL_rounding () |
Sets the FPU rounding mode as it was before initialization of the PPL. | |
void | initialize () |
Initializes the library. | |
void | finalize () |
Finalizes the library. | |
dimension_type | not_a_dimension () |
Returns a value that does not designate a valid dimension. | |
template<typename T> | |
Enable_If< Slow_Copy< T > ::value, void >::type | swap (T &, T &) |
Make sure swap() is specialized when needed. | |
dimension_type | compute_capacity (dimension_type requested_size, dimension_type maximum_size) |
Speculative allocation function. | |
dimension_type | compute_capacity (dimension_type requested_size) |
template<typename T> | |
Enable_If< Has_OK< T >::value, bool >::type | f_OK (const T &to) |
void | maybe_abandon () |
template<typename T, typename Policy> | |
void | numer_denom (const Checked_Number< T, Policy > &from, Coefficient &num, Coefficient &den) |
Extract the numerator and denominator components of from . | |
template<typename T, typename Policy> | |
void | div_round_up (Checked_Number< T, Policy > &to, Coefficient_traits::const_reference x, Coefficient_traits::const_reference y) |
Divides x by y into to , rounding the result towards plus infinity. | |
template<typename N> | |
void | min_assign (N &x, const N &y) |
Assigns to x the minimum between x and y . | |
template<typename N> | |
void | max_assign (N &x, const N &y) |
Assigns to x the maximum between x and y . | |
template<typename T, typename Policy> | |
bool | is_even (const Checked_Number< T, Policy > &x) |
Returns true if and only if x is an even number. | |
template<typename T, typename Policy> | |
bool | is_additive_inverse (const Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y) |
Returns true if and only if ![]() | |
void | normalize2 (Coefficient_traits::const_reference x, Coefficient_traits::const_reference y, Coefficient &nx, Coefficient &ny) |
If ![]() x and y , the values of x and y divided by ![]() nx and ny , respectively. | |
bool | is_canonical (const mpq_class &x) |
Returns true if and only if x is in canonical form. | |
template<typename T> | |
T | low_bits_mask (unsigned n) |
Returns a mask for the lowest n bits,. | |
template<typename To, typename From> | |
Result | maybe_assign (const To *&top, To &tmp, const From &from, Rounding_Dir dir) |
Assigns to top a pointer to a location that holds the conversion, according to dir , of from to type To . When necessary, and only when necessary, the variable tmp is used to hold the result of conversion. | |
bool | eq_restriction (const Interval_Restriction_None_Base &, const Interval_Restriction_None_Base) |
template<typename T> | |
bool | contains_restriction (const Interval_Restriction_None_Base &, const T &) |
template<typename T> | |
bool | assign_restriction (Interval_Restriction_None_Base &, const T &) |
template<typename T1, typename T2> | |
bool | join_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &) |
template<typename T1, typename T2> | |
bool | intersect_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &) |
template<typename T1, typename T2> | |
bool | diff_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &) |
template<typename T> | |
bool | neg_restriction (Interval_Restriction_None_Base &, const T &) |
template<typename T1, typename T2> | |
bool | add_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &) |
template<typename T1, typename T2> | |
bool | sub_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &) |
template<typename T1, typename T2> | |
bool | mul_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &) |
template<typename T1, typename T2> | |
bool | div_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &) |
void | output_restriction (std::ostream &, const Interval_Restriction_None_Base &) |
template<typename T1, typename T2> | |
Enable_If< Is_Same_Or_Derived < Interval_Restriction_Integer_Base, T1 >::value &&Is_Same_Or_Derived < Interval_Restriction_Integer_Base, T2 >::value, bool >::type | eq_restriction (const T1 &x, const T2 &y) |
template<typename T1, typename T2> | |
Enable_If< Is_Same_Or_Derived < Interval_Restriction_Integer_Base, T1 >::value &&Is_Same_Or_Derived < Interval_Restriction_Integer_Base, T2 >::value, bool >::type | contains_restriction (const T1 &x, const T2 &y) |
template<typename Base, typename From> | |
bool | assign_restriction (Interval_Restriction_Integer< Base > &to, const From &x) |
template<typename Base, typename From1, typename From2> | |
bool | join_restriction (Interval_Restriction_Integer< Base > &to, const From1 &x, const From2 &y) |
template<typename Base, typename From1, typename From2> | |
bool | intersect_restriction (Interval_Restriction_Integer< Base > &to, const From1 &x, const From2 &y) |
template<typename Base, typename From1, typename From2> | |
bool | diff_restriction (Interval_Restriction_Integer< Base > &to, const From1 &x, const From2 &) |
template<typename Base, typename From> | |
bool | neg_restriction (Interval_Restriction_Integer< Base > &to, const From &x) |
template<typename Base, typename From1, typename From2> | |
bool | add_restriction (Interval_Restriction_Integer< Base > &to, const From1 &x, const From2 &y) |
template<typename Base, typename From1, typename From2> | |
bool | sub_restriction (Interval_Restriction_Integer< Base > &to, const From1 &x, const From2 &y) |
template<typename Base, typename From1, typename From2> | |
bool | mul_restriction (Interval_Restriction_Integer< Base > &to, const From1 &x, const From2 &y) |
template<typename Base, typename From1, typename From2> | |
bool | div_restriction (Interval_Restriction_Integer< Base > &to, const From1 &, const From2 &) |
template<typename Base> | |
void | output_restriction (std::ostream &s, const Interval_Restriction_Integer< Base > &x) |
template<typename T, typename Base> | |
bool | set_unrestricted (Interval_Restriction_Integer_Modulo< T, Base > &to) |
template<typename T, typename Base> | |
bool | set_integer (Interval_Restriction_Integer_Modulo< T, Base > &to) |
template<typename T, typename Base, typename From> | |
bool | assign_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From &x) |
template<typename T, typename Base, typename From1, typename From2> | |
bool | join_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y) |
template<typename T, typename Base, typename From1, typename From2> | |
bool | intersect_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y) |
template<typename T, typename Base, typename From1, typename From2> | |
bool | diff_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y) |
template<typename T, typename Base, typename From> | |
bool | neg_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From &x) |
template<typename T> | |
void | addmod (T &to, const T &x, const T &y, const T &to_m, const T &y_m) |
template<typename M, typename T> | |
bool | assign_rem (M &rem, const T &n, const M &div) |
template<typename T, typename Base, typename From1, typename From2> | |
bool | add_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y) |
template<typename T> | |
void | submod (T &to, const T &x, const T &y, const T &to_m, const T &y_m) |
template<typename T, typename Base, typename From1, typename From2> | |
bool | sub_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y) |
template<typename T> | |
void | mulmod (T &to, const T &x, const T &y, const T &to_m) |
template<typename T, typename Base, typename From1, typename From2> | |
bool | mul_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y) |
template<typename T, typename Base, typename From1, typename From2> | |
bool | div_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y) |
template<typename T, typename Base> | |
void | output_restriction (std::ostream &s, const Interval_Restriction_Integer_Modulo< T, Base > &x) |
I_Result | combine (Result l, Result u) |
Result | lower (I_Result r) |
Result | upper (I_Result r) |
template<typename Info> | |
bool | unrepresentability_error (I_Result r, const Info &) |
template<typename Boundary, typename Info> | |
bool | f_is_empty (const Interval< Boundary, Info > &x) |
template<typename Boundary, typename Info> | |
bool | f_is_singleton (const Interval< Boundary, Info > &x) |
template<typename Boundary, typename Info> | |
int | is_infinity (const Interval< Boundary, Info > &x) |
bool | is_integer (const char *) |
bool | is_not_a_number (const char *) |
template<typename T> | |
Enable_If< Is_Singleton< T > ::value||Is_Interval< T > ::value, bool >::type | is_singleton_integer (const T &x) |
template<typename T1, typename T2> | |
bool | same_object (const T1 &, const T2 &) |
template<typename T> | |
bool | same_object (const T &x, const T &y) |
template<typename T> | |
Enable_If< Is_Singleton< T > ::value||Is_Interval< T > ::value, bool >::type | check_empty_arg (const T &x) |
template<typename Boundary, typename Info> | |
I_Result | check_empty_result (const Interval< Boundary, Info > &x, I_Result r) |
template<typename T1, typename T2> | |
Enable_If<((Is_Singleton< T1 > ::value||Is_Interval< T1 > ::value)&&(Is_Singleton< T2 > ::value||Is_Interval< T2 > ::value)&&(Is_Interval< T1 > ::value||Is_Interval< T2 > ::value)), bool >::type | operator== (const T1 &x, const T2 &y) |
template<typename T1, typename T2> | |
Enable_If<((Is_Singleton< T1 > ::value||Is_Interval< T1 > ::value)&&(Is_Singleton< T2 > ::value||Is_Interval< T2 > ::value)&&(Is_Interval< T1 > ::value||Is_Interval< T2 > ::value)), bool >::type | operator!= (const T1 &x, const T2 &y) |
template<typename B, typename Info, typename T> | |
Enable_If< Is_Singleton< T > ::value, Interval< B, Info > >::type | operator+ (const Interval< B, Info > &x, const T &y) |
template<typename B, typename Info, typename T> | |
Enable_If< Is_Singleton< T > ::value, Interval< B, Info > >::type | operator+ (const T &x, const Interval< B, Info > &y) |
template<typename B, typename Info> | |
Interval< B, Info > | operator+ (const Interval< B, Info > &x, const Interval< B, Info > &y) |
template<typename B, typename Info, typename T> | |
Enable_If< Is_Singleton< T > ::value, Interval< B, Info > >::type | operator- (const Interval< B, Info > &x, const T &y) |
template<typename B, typename Info, typename T> | |
Enable_If< Is_Singleton< T > ::value, Interval< B, Info > >::type | operator- (const T &x, const Interval< B, Info > &y) |
template<typename B, typename Info> | |
Interval< B, Info > | operator- (const Interval< B, Info > &x, const Interval< B, Info > &y) |
template<typename B, typename Info, typename T> | |
Enable_If< Is_Singleton< T > ::value, Interval< B, Info > >::type | operator* (const Interval< B, Info > &x, const T &y) |
template<typename B, typename Info, typename T> | |
Enable_If< Is_Singleton< T > ::value, Interval< B, Info > >::type | operator* (const T &x, const Interval< B, Info > &y) |
template<typename B, typename Info> | |
Interval< B, Info > | operator* (const Interval< B, Info > &x, const Interval< B, Info > &y) |
template<typename B, typename Info, typename T> | |
Enable_If< Is_Singleton< T > ::value, Interval< B, Info > >::type | operator/ (const Interval< B, Info > &x, const T &y) |
template<typename B, typename Info, typename T> | |
Enable_If< Is_Singleton< T > ::value, Interval< B, Info > >::type | operator/ (const T &x, const Interval< B, Info > &y) |
template<typename B, typename Info> | |
Interval< B, Info > | operator/ (const Interval< B, Info > &x, const Interval< B, Info > &y) |
template<typename Boundary, typename Info> | |
std::ostream & | operator<< (std::ostream &os, const Interval< Boundary, Info > &x) |
template<typename ITV> | |
Poly_Con_Relation | interval_relation (const ITV &i, const Constraint::Type constraint_type, Coefficient_traits::const_reference num, Coefficient_traits::const_reference den=1) |
Returns the relations holding between an interval and an interval constraint. | |
bool | extract_interval_congruence (const Congruence &cg, dimension_type cg_space_dim, dimension_type &cg_num_vars, dimension_type &cg_only_var) |
template<typename ITV> | |
bool | operator!= (const Box< ITV > &x, const Box< ITV > &y) |
template<typename ITV> | |
bool | operator== (const Box< ITV > &x, const Box< ITV > &y) |
bool | propagate_constraint_check_result (Result r, Ternary &open) |
unsigned long | isqrt (unsigned long x) |
Returns the integer square root of x . | |
Relational Operators and Comparison Functions | |
template<typename T1, typename T2> | |
Enable_If < Is_Native_Or_Checked< T1 > ::value &&Is_Native_Or_Checked < T2 >::value, bool >::type | equal (const T1 &x, const T2 &y) |
template<typename T1, typename T2> | |
Enable_If < Is_Native_Or_Checked< T1 > ::value &&Is_Native_Or_Checked < T2 >::value, bool >::type | not_equal (const T1 &x, const T2 &y) |
template<typename T1, typename T2> | |
Enable_If < Is_Native_Or_Checked< T1 > ::value &&Is_Native_Or_Checked < T2 >::value, bool >::type | greater_or_equal (const T1 &x, const T2 &y) |
template<typename T1, typename T2> | |
Enable_If < Is_Native_Or_Checked< T1 > ::value &&Is_Native_Or_Checked < T2 >::value, bool >::type | greater_than (const T1 &x, const T2 &y) |
template<typename T1, typename T2> | |
Enable_If < Is_Native_Or_Checked< T1 > ::value &&Is_Native_Or_Checked < T2 >::value, bool >::type | less_or_equal (const T1 &x, const T2 &y) |
template<typename T1, typename T2> | |
Enable_If < Is_Native_Or_Checked< T1 > ::value &&Is_Native_Or_Checked < T2 >::value, bool >::type | less_than (const T1 &x, const T2 &y) |
Input-Output Operators | |
template<typename T> | |
Enable_If < Is_Native_Or_Checked< T > ::value, void >::type | ascii_dump (std::ostream &s, const T &t) |
Ascii dump for native or checked. | |
template<typename T> | |
Enable_If < Is_Native_Or_Checked< T > ::value, bool >::type | ascii_load (std::ostream &s, T &t) |
Ascii load for native or checked. | |
Memory Size Inspection Functions | |
memory_size_type | total_memory_in_bytes (const GMP_Integer &x) |
memory_size_type | external_memory_in_bytes (const GMP_Integer &x) |
Memory Size Inspection Functions | |
template<typename T> | |
Enable_If< Is_Native< T > ::value, memory_size_type > ::type | total_memory_in_bytes (const T &) |
For native types, returns the total size in bytes of the memory occupied by the type of the (unused) parameter, i.e., 0. | |
template<typename T> | |
Enable_If< Is_Native< T > ::value, memory_size_type > ::type | external_memory_in_bytes (const T &) |
For native types, returns the size in bytes of the memory managed by the type of the (unused) parameter, i.e., 0. | |
memory_size_type | total_memory_in_bytes (const mpz_class &x) |
Returns the total size in bytes of the memory occupied by x . | |
memory_size_type | external_memory_in_bytes (const mpz_class &x) |
Returns the size in bytes of the memory managed by x . | |
memory_size_type | total_memory_in_bytes (const mpq_class &x) |
Returns the total size in bytes of the memory occupied by x . | |
memory_size_type | external_memory_in_bytes (const mpq_class &x) |
Returns the size in bytes of the memory managed by x . | |
Variables | |
const Throwable *volatile | abandon_expensive_computations = 0 |
A pointer to an exception object. |
typedef mpz_class Parma_Polyhedra_Library::GMP_Integer |
Definition at line 30 of file GMP_Integer.types.hh.
Definition at line 38 of file Interval.defs.hh.
00038 { 00039 I_EMPTY = 0, 00040 /* 00041 I_L_EQ = V_EQ, 00042 I_L_GT = V_GT, 00043 I_L_GE = V_GE, 00044 I_U_EQ = V_EQ << 6, 00045 I_U_LT = V_LT << 6, 00046 I_U_LE = V_LE << 6, 00047 */ 00048 I_MAYBE_EMPTY = 1 << 12, 00049 I_SINGULARITIES = 1 << 13 00050 };
void Parma_Polyhedra_Library::abs_assign | ( | GMP_Integer & | x, | |
const GMP_Integer & | y | |||
) | [related] |
void Parma_Polyhedra_Library::abs_assign | ( | GMP_Integer & | x | ) | [related] |
Definition at line 39 of file GMP_Integer.inlines.hh.
Referenced by Parma_Polyhedra_Library::MIP_Problem::compute_simplex_using_steepest_edge_float(), and Parma_Polyhedra_Library::MIP_Problem::get_exiting_base_index().
void Parma_Polyhedra_Library::add_mul_assign | ( | GMP_Integer & | x, | |
const GMP_Integer & | y, | |||
const GMP_Integer & | z | |||
) | [related] |
Definition at line 72 of file GMP_Integer.inlines.hh.
Referenced by Parma_Polyhedra_Library::Constraint_System::affine_preimage(), Parma_Polyhedra_Library::Congruence_System::affine_preimage(), Parma_Polyhedra_Library::Scalar_Products::assign(), Parma_Polyhedra_Library::Scalar_Products::homogeneous_assign(), Parma_Polyhedra_Library::Grid::reduce_pc_with_pc(), Parma_Polyhedra_Library::Scalar_Products::reduced_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::relation_with(), Parma_Polyhedra_Library::BD_Shape< T >::relation_with(), and Parma_Polyhedra_Library::MIP_Problem::steepest_edge_exact_entering_index().
bool Parma_Polyhedra_Library::add_restriction | ( | Interval_Restriction_Integer_Modulo< T, Base > & | to, | |
const From1 & | x, | |||
const From2 & | y | |||
) | [inline] |
Definition at line 673 of file Interval_Restriction.defs.hh.
References addmod(), assign_r(), assign_rem(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder, set_integer(), and set_unrestricted().
00673 { 00674 typedef Restriction_Integer_Modulo<From1, T, Base> Rx; 00675 const typename Rx::type& rx = Rx::get(x); 00676 if (rx.divisor == 0) 00677 return set_unrestricted(to); 00678 typedef Restriction_Integer_Modulo<From2, T, Base> Ry; 00679 const typename Ry::type& ry = Ry::get(y); 00680 if (ry.divisor == 0) 00681 return set_unrestricted(to); 00682 Result r; 00683 DIRTY_TEMP(T, rem); 00684 if (is_singleton(x)) { 00685 if (is_singleton(y)) 00686 return set_integer(to); 00687 if (!assign_rem(rem, f_lower(x), ry.divisor)) 00688 return set_integer(to); 00689 r = assign_r(to.divisor, ry.divisor, ROUND_NOT_NEEDED); 00690 assert(r == V_EQ); 00691 addmod(to.remainder, rem, ry.remainder, to.divisor, ry.divisor); 00692 } 00693 else if (is_singleton(y)) { 00694 if (!assign_rem(rem, f_lower(y), rx.divisor)) 00695 return set_integer(to); 00696 r = assign_r(to.divisor, rx.divisor, ROUND_NOT_NEEDED); 00697 assert(r == V_EQ); 00698 addmod(to.remainder, rx.remainder, rem, to.divisor, to.divisor); 00699 } 00700 else { 00701 r = gcd_assign_r(to.divisor, rx.divisor, ry.divisor, ROUND_NOT_NEEDED); 00702 assert(r == V_EQ); 00703 addmod(to.remainder, rx.remainder, ry.remainder, to.divisor, ry.divisor); 00704 } 00705 return true; 00706 }
bool Parma_Polyhedra_Library::add_restriction | ( | Interval_Restriction_Integer< Base > & | to, | |
const From1 & | x, | |||
const From2 & | y | |||
) | [inline] |
Definition at line 275 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().
00275 { 00276 to.set_integer(Restriction_Integer<From1, Base>::get(x).get_integer() 00277 && Restriction_Integer<From2, Base>::get(y).get_integer()); 00278 return true; 00279 }
bool Parma_Polyhedra_Library::add_restriction | ( | Interval_Restriction_None_Base & | , | |
const T1 & | , | |||
const T2 & | ||||
) | [inline] |
Definition at line 100 of file Interval_Restriction.defs.hh.
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign().
void Parma_Polyhedra_Library::addmod | ( | T & | to, | |
const T & | x, | |||
const T & | y, | |||
const T & | to_m, | |||
const T & | y_m | |||
) | [inline] |
Definition at line 627 of file Interval_Restriction.defs.hh.
Referenced by add_restriction().
00627 { 00628 Result r; 00629 if (std::numeric_limits<T>::is_bounded) { 00630 r = sub_assign_r(to, y_m, y, ROUND_NOT_NEEDED); 00631 assert(r == V_EQ); 00632 if (x <= to) { 00633 r = add_assign_r(to, x, y, ROUND_NOT_NEEDED); 00634 assert(r == V_EQ); 00635 } 00636 else { 00637 r = sub_assign_r(to, x, to, ROUND_NOT_NEEDED); 00638 assert(r == V_EQ); 00639 } 00640 } 00641 else { 00642 r = add_assign_r(to, x, y, ROUND_NOT_NEEDED); 00643 assert(r == V_EQ); 00644 } 00645 r = rem_assign_r(to, to, to_m, ROUND_NOT_NEEDED); 00646 assert(r == V_EQ); 00647 }
Enable_If<Is_Native_Or_Checked<T>::value, void>::type Parma_Polyhedra_Library::ascii_dump | ( | std::ostream & | s, | |
const T & | t | |||
) | [inline] |
Ascii dump for native or checked.
Referenced by Parma_Polyhedra_Library::Linear_Expression::ascii_dump(), Parma_Polyhedra_Library::Interval< Boundary, Info >::ascii_dump(), Parma_Polyhedra_Library::Generator::ascii_dump(), and Parma_Polyhedra_Library::Constraint::ascii_dump().
Enable_If<Is_Native_Or_Checked<T>::value, bool>::type Parma_Polyhedra_Library::ascii_load | ( | std::ostream & | s, | |
T & | t | |||
) | [inline] |
Ascii load for native or checked.
Referenced by Parma_Polyhedra_Library::Linear_Expression::ascii_load(), Parma_Polyhedra_Library::Interval< Boundary, Info >::ascii_load(), Parma_Polyhedra_Library::Generator::ascii_load(), and Parma_Polyhedra_Library::Constraint::ascii_load().
Enable_If<Is_Native_Or_Checked<To>::value && Is_Special<From>::value, Result>::type Parma_Polyhedra_Library::assign_r | ( | To & | to, | |
const From & | , | |||
Rounding_Dir | dir | |||
) | [related] |
Definition at line 211 of file Checked_Number.inlines.hh.
References check_result(), raw_value(), and rounding_dir().
Referenced by Parma_Polyhedra_Library::Box< ITV >::add_interval_constraint_no_check(), add_restriction(), Parma_Polyhedra_Library::Octagonal_Shape< T >::add_space_dimensions_and_project(), Parma_Polyhedra_Library::BD_Shape< T >::add_space_dimensions_and_project(), Parma_Polyhedra_Library::Octagonal_Shape< T >::affine_image(), Parma_Polyhedra_Library::BD_Shape< T >::affine_image(), assign_rem(), Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), Parma_Polyhedra_Library::Octagonal_Shape< T >::BHMZ05_widening_assign(), Parma_Polyhedra_Library::BD_Shape< T >::BHMZ05_widening_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::bounded_affine_image(), Parma_Polyhedra_Library::Box< ITV >::bounded_affine_image(), Parma_Polyhedra_Library::BD_Shape< T >::bounded_affine_image(), Parma_Polyhedra_Library::Box< ITV >::bounded_affine_preimage(), Parma_Polyhedra_Library::Box< ITV >::Box(), Parma_Polyhedra_Library::Octagonal_Shape< T >::CC76_extrapolation_assign(), Parma_Polyhedra_Library::BD_Shape< T >::CC76_extrapolation_assign(), Parma_Polyhedra_Library::Polyhedron::contains_integer_point(), Parma_Polyhedra_Library::Octagonal_Shape< T >::contains_integer_point(), Parma_Polyhedra_Library::BD_Shape< T >::contains_integer_point(), Parma_Polyhedra_Library::Octagonal_Shape< T >::deduce_minus_v_pm_u_bounds(), Parma_Polyhedra_Library::BD_Shape< T >::deduce_u_minus_v_bounds(), Parma_Polyhedra_Library::BD_Shape< T >::deduce_v_minus_u_bounds(), Parma_Polyhedra_Library::Octagonal_Shape< T >::deduce_v_pm_u_bounds(), div_round_up(), Parma_Polyhedra_Library::Octagonal_Shape< T >::euclidean_distance_assign(), Parma_Polyhedra_Library::BD_Shape< T >::euclidean_distance_assign(), Parma_Polyhedra_Library::BD_Shape< T >::forget_all_dbm_constraints(), Parma_Polyhedra_Library::Octagonal_Shape< T >::forget_all_octagonal_constraints(), Parma_Polyhedra_Library::BD_Shape< T >::forget_binary_dbm_constraints(), Parma_Polyhedra_Library::Octagonal_Shape< T >::forget_binary_octagonal_constraints(), Parma_Polyhedra_Library::maybe_assign_struct< To, From >::function(), Parma_Polyhedra_Library::Octagonal_Shape< T >::generalized_affine_image(), Parma_Polyhedra_Library::Box< ITV >::generalized_affine_image(), Parma_Polyhedra_Library::BD_Shape< T >::generalized_affine_image(), Parma_Polyhedra_Library::Box< ITV >::get_lower_bound(), Parma_Polyhedra_Library::Box< ITV >::get_upper_bound(), Parma_Polyhedra_Library::Octagonal_Shape< T >::incremental_strong_closure_assign(), interval_relation(), Parma_Polyhedra_Library::MIP_Problem::is_mip_satisfiable(), Parma_Polyhedra_Library::Octagonal_Shape< T >::is_strongly_reduced(), join_restriction(), Parma_Polyhedra_Library::Octagonal_Shape< T >::l_infinity_distance_assign(), Parma_Polyhedra_Library::BD_Shape< T >::l_infinity_distance_assign(), Parma_Polyhedra_Library::OR_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::Generator::l_m_distance_assign(), Parma_Polyhedra_Library::DB_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::Box< ITV >::l_m_distance_assign(), Parma_Polyhedra_Library::Polyhedron::max_min(), Parma_Polyhedra_Library::Octagonal_Shape< T >::max_min(), Parma_Polyhedra_Library::Box< ITV >::max_min(), Parma_Polyhedra_Library::BD_Shape< T >::max_min(), mul_restriction(), mulmod(), numer_denom(), Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape(), Parma_Polyhedra_Library::Box< ITV >::propagate_constraint_no_check(), Parma_Polyhedra_Library::Octagonal_Shape< T >::rectilinear_distance_assign(), Parma_Polyhedra_Library::BD_Shape< T >::rectilinear_distance_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::refine(), Parma_Polyhedra_Library::BD_Shape< T >::refine(), Parma_Polyhedra_Library::Octagonal_Shape< T >::relation_with(), Parma_Polyhedra_Library::Box< ITV >::relation_with(), Parma_Polyhedra_Library::BD_Shape< T >::relation_with(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::restrict(), Parma_Polyhedra_Library::BD_Shape< T >::shortest_path_closure_assign(), Parma_Polyhedra_Library::MIP_Problem::solve_mip(), Parma_Polyhedra_Library::MIP_Problem::steepest_edge_float_entering_index(), Parma_Polyhedra_Library::Octagonal_Shape< T >::strong_closure_assign(), and sub_restriction().
00211 { 00212 return check_result(Checked::assign_special<typename Native_Checked_To_Wrapper<To> 00213 ::Policy>(Native_Checked_To_Wrapper<To>::raw_value(to), 00214 From::code, 00215 rounding_dir(dir)), 00216 dir); 00217 }
bool Parma_Polyhedra_Library::assign_rem | ( | M & | rem, | |
const T & | n, | |||
const M & | div | |||
) | [inline] |
Definition at line 651 of file Interval_Restriction.defs.hh.
References assign_r().
Referenced by add_restriction(), and sub_restriction().
00651 { 00652 DIRTY_TEMP(T, divisor); 00653 DIRTY_TEMP(T, remainder); 00654 Result r; 00655 r = assign_r(divisor, div, ROUND_CHECK); 00656 if (r != V_EQ) 00657 return false; 00658 r = rem_assign_r(remainder, n, divisor, ROUND_CHECK); 00659 if (r != V_EQ) 00660 return false; 00661 if (sgn(remainder) < 0) { 00662 r = add_assign_r(remainder, remainder, divisor, ROUND_CHECK); 00663 if (r != V_EQ) 00664 return false; 00665 } 00666 r = assign_r(rem, remainder, ROUND_CHECK); 00667 return r == V_EQ; 00668 }
bool Parma_Polyhedra_Library::assign_restriction | ( | Interval_Restriction_Integer_Modulo< T, Base > & | to, | |
const From & | x | |||
) | [inline] |
Definition at line 515 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, and Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder.
00515 { 00516 to.remainder = Restriction_Integer_Modulo<From, T, Base>::get(x).remainder; 00517 to.divisor = Restriction_Integer_Modulo<From, T, Base>::get(x).divisor; 00518 return true; 00519 }
bool Parma_Polyhedra_Library::assign_restriction | ( | Interval_Restriction_Integer< Base > & | to, | |
const From & | x | |||
) | [inline] |
Definition at line 237 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().
00237 { 00238 to.set_integer(Restriction_Integer<From, Base>::get(x).get_integer()); 00239 return true; 00240 }
bool Parma_Polyhedra_Library::assign_restriction | ( | Interval_Restriction_None_Base & | , | |
const T & | ||||
) | [inline] |
const char * Parma_Polyhedra_Library::banner | ( | ) |
Returns a character string containing the PPL banner.
The banner provides information about the PPL version, the licensing, the lack of any warranty whatsoever, the C++ compiler used to build the library, where to report bugs and where to look for further information.
Definition at line 98 of file version.cc.
References banner_string.
00098 { 00099 return banner_string; 00100 }
Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, bool>::type Parma_Polyhedra_Library::check_empty_arg | ( | const T & | x | ) | [inline] |
Definition at line 172 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval_NS::f_info(), and f_is_empty().
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::contains(), Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::is_disjoint_from(), Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::neg_assign(), operator<<(), operator==(), Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_existential(), Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_universal(), Parma_Polyhedra_Library::Interval< Boundary, Info >::strictly_contains(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().
00172 { 00173 if (f_info(x).may_be_empty) 00174 return f_is_empty(x); 00175 else { 00176 assert(!f_is_empty(x)); 00177 return false; 00178 } 00179 }
I_Result Parma_Polyhedra_Library::check_empty_result | ( | const Interval< Boundary, Info > & | x, | |
I_Result | r | |||
) | [inline] |
Definition at line 183 of file Interval.inlines.hh.
References f_is_empty(), I_EMPTY, and I_MAYBE_EMPTY.
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_existential(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_universal().
00183 { 00184 if (Info::check_empty_result && f_is_empty(x)) 00185 return I_EMPTY; 00186 else 00187 return static_cast<I_Result>(r | I_MAYBE_EMPTY); 00188 }
Result Parma_Polyhedra_Library::check_result | ( | Result | r, | |
Rounding_Dir | dir | |||
) | [inline] |
Definition at line 45 of file Checked_Number.inlines.hh.
Referenced by Parma_Polyhedra_Library::Checked_Number< T, Policy >::assign_r(), assign_r(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number(), construct(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::input(), and Parma_Polyhedra_Library::Checked_Number< T, Policy >::output().
00045 { 00046 if (dir == ROUND_NOT_NEEDED && !is_special(r)) { 00047 #ifdef DEBUG_ROUND_NOT_NEEDED 00048 // FIXME: this is wrong. If an overflow happens the Result may be 00049 // V_LT or V_GT. What's the better way to cope with that? 00050 assert(r == V_EQ); 00051 #else 00052 return V_EQ; 00053 #endif 00054 } 00055 return r; 00056 }
int Parma_Polyhedra_Library::cmp | ( | const GMP_Integer & | x, | |
const GMP_Integer & | y | |||
) | [related] |
void Parma_Polyhedra_Library::Coefficient_constants_finalize | ( | ) |
void Parma_Polyhedra_Library::Coefficient_constants_initialize | ( | ) |
Coefficient_traits::const_reference Parma_Polyhedra_Library::Coefficient_one | ( | ) |
Returns a const reference to a Coefficient with value 1.
Referenced by Parma_Polyhedra_Library::Constraint::initialize().
Coefficient_traits::const_reference Parma_Polyhedra_Library::Coefficient_zero | ( | ) |
Returns a const reference to a Coefficient with value 0.
Referenced by Parma_Polyhedra_Library::Linear_Expression::coefficient(), Parma_Polyhedra_Library::Polyhedron::conversion(), Parma_Polyhedra_Library::Linear_Expression::initialize(), Parma_Polyhedra_Library::Constraint::operator<<(), and Parma_Polyhedra_Library::Congruence::operator<<().
I_Result Parma_Polyhedra_Library::combine | ( | Result | l, | |
Result | u | |||
) | [inline] |
Definition at line 55 of file Interval.defs.hh.
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::difference_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign(), Parma_Polyhedra_Library::OR_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::Generator::l_m_distance_assign(), Parma_Polyhedra_Library::DB_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::Box< ITV >::l_m_distance_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::neg_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::normalize(), Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_existential(), Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_universal(), Parma_Polyhedra_Library::Interval< Boundary, Info >::set_infinities(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().
00055 { 00056 return static_cast<I_Result>(l | (u << 6)); 00057 }
dimension_type Parma_Polyhedra_Library::compute_capacity | ( | dimension_type | requested_size | ) | [inline] |
Definition at line 62 of file globals.inlines.hh.
00062 { 00063 // Speculation factor 2. 00064 return 2*(requested_size + 1); 00065 // Speculation factor 1.5. 00066 // return requested_size + requested_size/2 + 1; 00067 }
dimension_type Parma_Polyhedra_Library::compute_capacity | ( | dimension_type | requested_size, | |
dimension_type | maximum_size | |||
) | [inline] |
Speculative allocation function.
requested_size | The number of elements we need. | |
maximum_size | The maximum number of elements to be allocated. It is assumed to be no less than requested_size . |
maximum_size
.
Definition at line 47 of file globals.inlines.hh.
Referenced by Parma_Polyhedra_Library::Linear_System::add_pending_row(), Parma_Polyhedra_Library::Matrix::add_recycled_row(), Parma_Polyhedra_Library::Bit_Matrix::add_row(), Parma_Polyhedra_Library::Matrix::add_zero_columns(), Parma_Polyhedra_Library::Matrix::add_zero_rows(), Parma_Polyhedra_Library::Matrix::add_zero_rows_and_columns(), Parma_Polyhedra_Library::DB_Row< T >::DB_Row(), Parma_Polyhedra_Library::DB_Matrix< T >::grow(), Parma_Polyhedra_Library::Linear_System::merge_rows_assign(), Parma_Polyhedra_Library::OR_Matrix< T >::operator=(), Parma_Polyhedra_Library::Matrix::operator=(), Parma_Polyhedra_Library::DB_Matrix< T >::operator=(), Parma_Polyhedra_Library::Bit_Matrix::resize(), Parma_Polyhedra_Library::Matrix::resize_no_copy(), Parma_Polyhedra_Library::DB_Matrix< T >::resize_no_copy(), Parma_Polyhedra_Library::Row::Row(), and Parma_Polyhedra_Library::Polyhedron::simplify().
00048 { 00049 assert(requested_size <= maximum_size); 00050 // Speculation factor 2. 00051 return (requested_size < maximum_size / 2) 00052 ? 2*(requested_size + 1) 00053 : maximum_size; 00054 // Speculation factor 1.5. 00055 // return (maximum_size - requested_size > requested_size/2) 00056 // ? requested_size + requested_size/2 + 1 00057 // : maximum_size; 00058 }
Parma_Polyhedra_Library::COND | ( | PPL_SUPPORTED_FLOAT | , | |
DEF_CTOR(float) | ||||
) |
Enable_If<Is_Native_Or_Checked<To>::value && Is_Special<From>::value, Result>::type Parma_Polyhedra_Library::construct | ( | To & | to, | |
const From & | , | |||
Rounding_Dir | dir | |||
) | [related] |
Definition at line 221 of file Checked_Number.inlines.hh.
References check_result(), raw_value(), and rounding_dir().
Referenced by Parma_Polyhedra_Library::Linear_System::add_pending_row(), Parma_Polyhedra_Library::Matrix::add_zero_rows(), Parma_Polyhedra_Library::Linear_Row::construct(), Parma_Polyhedra_Library::DB_Row_Impl_Handler< T >::Impl::construct_upward_approximation(), Parma_Polyhedra_Library::DB_Matrix< T >::DB_Matrix(), Parma_Polyhedra_Library::DB_Matrix< T >::grow(), Parma_Polyhedra_Library::Matrix::Matrix(), Parma_Polyhedra_Library::Matrix::resize_no_copy(), and Parma_Polyhedra_Library::DB_Matrix< T >::resize_no_copy().
00221 { 00222 return check_result(Checked::construct_special<typename Native_Checked_To_Wrapper<To> 00223 ::Policy>(Native_Checked_To_Wrapper<To>::raw_value(to), 00224 From::code, 00225 rounding_dir(dir)), 00226 dir); 00227 }
Enable_If< Is_Same_Or_Derived< Interval_Restriction_Integer_Modulo_Base, T1 >::value &&Is_Same_Or_Derived< Interval_Restriction_Integer_Modulo_Base, T2 >::value, bool >::type Parma_Polyhedra_Library::contains_restriction | ( | const T1 & | x, | |
const T2 & | y | |||
) | [inline] |
bool Parma_Polyhedra_Library::contains_restriction | ( | const Interval_Restriction_None_Base & | , | |
const T & | ||||
) | [inline] |
Definition at line 64 of file Interval_Restriction.defs.hh.
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::contains(), join_restriction(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::strictly_contains().
Parma_Polyhedra_Library::DEF_CTOR | ( | long | double | ) |
Parma_Polyhedra_Library::DEF_CTOR | ( | double | ) |
bool Parma_Polyhedra_Library::diff_restriction | ( | Interval_Restriction_Integer_Modulo< T, Base > & | to, | |
const From1 & | x, | |||
const From2 & | y | |||
) | [inline] |
bool Parma_Polyhedra_Library::diff_restriction | ( | Interval_Restriction_Integer< Base > & | to, | |
const From1 & | x, | |||
const From2 & | ||||
) | [inline] |
Definition at line 260 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().
00261 { 00262 to.set_integer(Restriction_Integer<From1, Base>::get(x).get_integer()); 00263 return true; 00264 }
bool Parma_Polyhedra_Library::diff_restriction | ( | Interval_Restriction_None_Base & | , | |
const T1 & | , | |||
const T2 & | ||||
) | [inline] |
bool Parma_Polyhedra_Library::div_restriction | ( | Interval_Restriction_Integer_Modulo< T, Base > & | to, | |
const From1 & | x, | |||
const From2 & | y | |||
) | [inline] |
Definition at line 847 of file Interval_Restriction.defs.hh.
References set_unrestricted().
00847 { 00848 if (is_singleton(y)) { 00849 if (is_singleton(x)) { 00850 // FIXME: to be written 00851 } 00852 } 00853 return set_unrestricted(to); 00854 }
bool Parma_Polyhedra_Library::div_restriction | ( | Interval_Restriction_Integer< Base > & | to, | |
const From1 & | , | |||
const From2 & | ||||
) | [inline] |
Definition at line 299 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().
bool Parma_Polyhedra_Library::div_restriction | ( | Interval_Restriction_None_Base & | , | |
const T1 & | , | |||
const T2 & | ||||
) | [inline] |
Definition at line 118 of file Interval_Restriction.defs.hh.
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign().
void Parma_Polyhedra_Library::div_round_up | ( | Checked_Number< T, Policy > & | to, | |
Coefficient_traits::const_reference | x, | |||
Coefficient_traits::const_reference | y | |||
) | [inline] |
Divides x
by y
into to
, rounding the result towards plus infinity.
Definition at line 64 of file math_utilities.inlines.hh.
References assign_r().
Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::add_constraint(), Parma_Polyhedra_Library::BD_Shape< T >::add_constraint(), Parma_Polyhedra_Library::BD_Shape< T >::add_dbm_constraint(), Parma_Polyhedra_Library::Octagonal_Shape< T >::add_octagonal_constraint(), Parma_Polyhedra_Library::Octagonal_Shape< T >::affine_image(), Parma_Polyhedra_Library::BD_Shape< T >::affine_image(), Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), Parma_Polyhedra_Library::BD_Shape< T >::bounded_affine_image(), Parma_Polyhedra_Library::Octagonal_Shape< T >::generalized_affine_image(), Parma_Polyhedra_Library::BD_Shape< T >::generalized_affine_image(), Parma_Polyhedra_Library::Octagonal_Shape< T >::get_limiting_octagon(), Parma_Polyhedra_Library::BD_Shape< T >::get_limiting_shape(), Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape(), Parma_Polyhedra_Library::Octagonal_Shape< T >::refine(), Parma_Polyhedra_Library::BD_Shape< T >::refine(), Parma_Polyhedra_Library::Octagonal_Shape< T >::refine_no_check(), and Parma_Polyhedra_Library::BD_Shape< T >::refine_no_check().
00066 { 00067 DIRTY_TEMP0(mpq_class, qx); 00068 DIRTY_TEMP0(mpq_class, qy); 00069 // Note: this code assumes that a Coefficient is always convertible 00070 // to an mpq_class without loss of precision. 00071 assign_r(qx, x, ROUND_NOT_NEEDED); 00072 assign_r(qy, y, ROUND_NOT_NEEDED); 00073 div_assign_r(qx, qx, qy, ROUND_NOT_NEEDED); 00074 assign_r(to, qx, ROUND_UP); 00075 }
Enable_If< Is_Same_Or_Derived< Interval_Restriction_Integer_Modulo_Base, T1 >::value &&Is_Same_Or_Derived< Interval_Restriction_Integer_Modulo_Base, T2 >::value, bool >::type Parma_Polyhedra_Library::eq_restriction | ( | const T1 & | x, | |
const T2 & | y | |||
) | [inline] |
bool Parma_Polyhedra_Library::eq_restriction | ( | const Interval_Restriction_None_Base & | , | |
const | Interval_Restriction_None_Base | |||
) | [inline] |
Definition at line 58 of file Interval_Restriction.defs.hh.
Referenced by operator==(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::strictly_contains().
Enable_If<Is_Native_Or_Checked<T1>::value && Is_Native_Or_Checked<T2>::value, bool>::type Parma_Polyhedra_Library::equal | ( | const T1 & | x, | |
const T2 & | y | |||
) | [inline] |
void Parma_Polyhedra_Library::exact_div_assign | ( | GMP_Integer & | x, | |
const GMP_Integer & | y, | |||
const GMP_Integer & | z | |||
) | [related] |
Definition at line 82 of file GMP_Integer.inlines.hh.
00082 { 00083 assert(y % z == 0); 00084 mpz_divexact(x.get_mpz_t(), y.get_mpz_t(), z.get_mpz_t()); 00085 }
void Parma_Polyhedra_Library::exact_div_assign | ( | Checked_Number< T, Policy > & | x, | |
const Checked_Number< T, Policy > & | y, | |||
const Checked_Number< T, Policy > & | z | |||
) | [related] |
Definition at line 700 of file Checked_Number.inlines.hh.
Referenced by Parma_Polyhedra_Library::MIP_Problem::compute_generator(), Parma_Polyhedra_Library::Grid::conversion(), Parma_Polyhedra_Library::Grid::get_covering_box(), Parma_Polyhedra_Library::MIP_Problem::get_exiting_base_index(), Parma_Polyhedra_Library::Grid::Grid(), Parma_Polyhedra_Library::Generator::is_matching_closure_point(), Parma_Polyhedra_Library::Grid::max_min(), Parma_Polyhedra_Library::Box< ITV >::max_min(), Parma_Polyhedra_Library::Row::normalize(), normalize2(), Parma_Polyhedra_Library::Congruence_System::normalize_moduli(), Parma_Polyhedra_Library::Grid::reduce_congruence_with_equality(), Parma_Polyhedra_Library::Grid::reduce_equality_with_equality(), Parma_Polyhedra_Library::Grid::reduce_line_with_line(), Parma_Polyhedra_Library::Grid::reduce_parameter_with_line(), Parma_Polyhedra_Library::Grid::reduce_pc_with_pc(), Parma_Polyhedra_Library::Grid_Generator::scale_to_divisor(), and Parma_Polyhedra_Library::MIP_Problem::steepest_edge_exact_entering_index().
memory_size_type Parma_Polyhedra_Library::external_memory_in_bytes | ( | const mpq_class & | x | ) | [inline] |
Returns the size in bytes of the memory managed by x
.
Definition at line 94 of file globals.inlines.hh.
References Parma_Polyhedra_Library::Checked_Number< T, Policy >::external_memory_in_bytes().
Referenced by Parma_Polyhedra_Library::Row_Impl_Handler::Impl::external_memory_in_bytes(), Parma_Polyhedra_Library::Pointset_Powerset< PS >::external_memory_in_bytes(), Parma_Polyhedra_Library::Linear_System::external_memory_in_bytes(), Parma_Polyhedra_Library::Linear_Expression::external_memory_in_bytes(), Parma_Polyhedra_Library::Grid_Generator_System::external_memory_in_bytes(), Parma_Polyhedra_Library::Grid_Generator::external_memory_in_bytes(), Parma_Polyhedra_Library::Generator_System::external_memory_in_bytes(), Parma_Polyhedra_Library::Generator::external_memory_in_bytes(), Parma_Polyhedra_Library::Constraint_System::external_memory_in_bytes(), Parma_Polyhedra_Library::Constraint::external_memory_in_bytes(), Parma_Polyhedra_Library::Congruence_System::external_memory_in_bytes(), and Parma_Polyhedra_Library::Congruence::external_memory_in_bytes().
00094 { 00095 return external_memory_in_bytes(x.get_num()) 00096 + external_memory_in_bytes(x.get_den()); 00097 }
memory_size_type Parma_Polyhedra_Library::external_memory_in_bytes | ( | const mpz_class & | x | ) | [inline] |
Returns the size in bytes of the memory managed by x
.
Definition at line 84 of file globals.inlines.hh.
Enable_If< Is_Native< T >::value, memory_size_type >::type Parma_Polyhedra_Library::external_memory_in_bytes | ( | const T & | ) | [inline] |
For native types, returns the size in bytes of the memory managed by the type of the (unused) parameter, i.e., 0.
Definition at line 72 of file globals.inlines.hh.
memory_size_type Parma_Polyhedra_Library::external_memory_in_bytes | ( | const GMP_Integer & | x | ) |
bool Parma_Polyhedra_Library::extract_interval_congruence | ( | const Congruence & | cg, | |
dimension_type | cg_space_dim, | |||
dimension_type & | cg_num_vars, | |||
dimension_type & | cg_only_var | |||
) |
Definition at line 54 of file Box.cc.
References Parma_Polyhedra_Library::Congruence::coefficient(), Parma_Polyhedra_Library::Congruence::is_equality(), and Parma_Polyhedra_Library::Congruence::space_dimension().
Referenced by Parma_Polyhedra_Library::Box< ITV >::add_congruence_no_check(), and Parma_Polyhedra_Library::Box< ITV >::refine_no_check().
00057 { 00058 // Check for preconditions. 00059 assert(cg.space_dimension() == cg_space_dim); 00060 assert(cg_num_vars == 0 && cg_only_var == 0); 00061 // Only equality congruences can be intervals. 00062 assert(cg.is_equality()); 00063 00064 // Collect the non-zero components of `cg'. 00065 for (dimension_type i = cg_space_dim; i-- > 0; ) 00066 if (cg.coefficient(Variable(i)) != 0) { 00067 if (cg_num_vars == 0) { 00068 cg_only_var = i; 00069 ++cg_num_vars; 00070 } 00071 else 00072 // Congruence `cg' is not an interval congruence. 00073 return false; 00074 } 00075 return true; 00076 }
bool Parma_Polyhedra_Library::f_is_empty | ( | const Interval< Boundary, Info > & | x | ) | [inline] |
Definition at line 51 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::is_empty().
Referenced by check_empty_arg(), check_empty_result(), and Parma_Polyhedra_Library::Interval_NS::f_is_singleton().
bool Parma_Polyhedra_Library::f_is_singleton | ( | const Interval< Boundary, Info > & | x | ) | [inline] |
Definition at line 56 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::is_singleton().
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_existential(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_universal().
Enable_If<Has_OK<T>::value, bool>::type Parma_Polyhedra_Library::f_OK | ( | const T & | to | ) | [inline] |
Definition at line 371 of file globals.defs.hh.
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::contains(), Parma_Polyhedra_Library::Interval< Boundary, Info >::difference_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::is_disjoint_from(), Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::neg_assign(), operator==(), Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_existential(), Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_universal(), Parma_Polyhedra_Library::Interval< Boundary, Info >::strictly_contains(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().
void Parma_Polyhedra_Library::finalize | ( | ) | [inline] |
Finalizes the library.
Definition at line 55 of file initializer.hh.
Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::Generator::l_m_distance_assign(), Parma_Polyhedra_Library::DB_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::Box< ITV >::l_m_distance_assign(), and Parma_Polyhedra_Library::Init::~Init().
00055 { 00056 #ifdef PPL_NO_AUTOMATIC_INITIALIZATION 00057 assert(Parma_Polyhedra_Library_initializer_p != 0); 00058 delete Parma_Polyhedra_Library_initializer_p; 00059 Parma_Polyhedra_Library_initializer_p = 0; 00060 #endif 00061 }
void Parma_Polyhedra_Library::gcd_assign | ( | GMP_Integer & | x, | |
const GMP_Integer & | y, | |||
const GMP_Integer & | z | |||
) | [related] |
Definition at line 49 of file GMP_Integer.inlines.hh.
Referenced by Parma_Polyhedra_Library::MIP_Problem::choose_branching_variable(), Parma_Polyhedra_Library::Polyhedron::contains_integer_point(), Parma_Polyhedra_Library::Grid::conversion(), Parma_Polyhedra_Library::Grid::get_covering_box(), Parma_Polyhedra_Library::Grid::Grid(), Parma_Polyhedra_Library::Generator::is_matching_closure_point(), Parma_Polyhedra_Library::MIP_Problem::is_mip_satisfiable(), Parma_Polyhedra_Library::Grid::max_min(), Parma_Polyhedra_Library::Row::normalize(), normalize2(), Parma_Polyhedra_Library::MIP_Problem::OK(), Parma_Polyhedra_Library::Grid::reduce_congruence_with_equality(), Parma_Polyhedra_Library::Grid::reduce_equality_with_equality(), Parma_Polyhedra_Library::Grid::reduce_line_with_line(), Parma_Polyhedra_Library::Grid::reduce_parameter_with_line(), Parma_Polyhedra_Library::Grid::relation_with(), and Parma_Polyhedra_Library::MIP_Problem::solve_mip().
void Parma_Polyhedra_Library::gcdext_assign | ( | GMP_Integer & | x, | |
GMP_Integer & | s, | |||
GMP_Integer & | t, | |||
const GMP_Integer & | y, | |||
const GMP_Integer & | z | |||
) | [related] |
Definition at line 59 of file GMP_Integer.inlines.hh.
Referenced by Parma_Polyhedra_Library::Grid::reduce_pc_with_pc().
00060 { 00061 mpz_gcdext(x.get_mpz_t(), 00062 s.get_mpz_t(), t.get_mpz_t(), 00063 y.get_mpz_t(), z.get_mpz_t()); 00064 }
Enable_If<Is_Native_Or_Checked<T1>::value && Is_Native_Or_Checked<T2>::value, bool>::type Parma_Polyhedra_Library::greater_or_equal | ( | const T1 & | x, | |
const T2 & | y | |||
) | [inline] |
Enable_If<Is_Native_Or_Checked<T1>::value && Is_Native_Or_Checked<T2>::value, bool>::type Parma_Polyhedra_Library::greater_than | ( | const T1 & | x, | |
const T2 & | y | |||
) | [inline] |
void Parma_Polyhedra_Library::initialize | ( | ) | [inline] |
Initializes the library.
Definition at line 46 of file initializer.hh.
Referenced by Parma_Polyhedra_Library::Init::Init().
00046 { 00047 #ifdef PPL_NO_AUTOMATIC_INITIALIZATION 00048 if (Parma_Polyhedra_Library_initializer_p == 0) 00049 Parma_Polyhedra_Library_initializer_p = new Init(); 00050 #endif 00051 }
bool Parma_Polyhedra_Library::intersect_restriction | ( | Interval_Restriction_Integer_Modulo< T, Base > & | to, | |
const From1 & | x, | |||
const From2 & | y | |||
) | [inline] |
Definition at line 574 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder, and set_integer().
00574 { 00575 typedef Restriction_Integer_Modulo<From1, T, Base> Rx; 00576 const typename Rx::type& rx = Rx::get(x); 00577 typedef Restriction_Integer_Modulo<From2, T, Base> Ry; 00578 const typename Ry::type& ry = Ry::get(y); 00579 if (rx.divisor == 0) { 00580 to.remainder = ry.remainder; 00581 to.divisor = ry.divisor; 00582 return true; 00583 } 00584 if (ry.divisor == 0) { 00585 to.remainder = rx.remainder; 00586 to.divisor = rx.divisor; 00587 return true; 00588 } 00589 DIRTY_TEMP(T, g); 00590 Result r; 00591 r = gcd_assign_r(g, rx.divisor, ry.divisor, ROUND_DIRECT); 00592 if (r != V_EQ) 00593 return set_integer(to); 00594 DIRTY_TEMP(T, d); 00595 if (rx.remainder > ry.remainder) 00596 r = sub_assign_r(d, rx.remainder, ry.remainder, ROUND_DIRECT); 00597 else 00598 r = sub_assign_r(d, ry.remainder, rx.remainder, ROUND_DIRECT); 00599 if (r != V_EQ) 00600 return set_integer(to); 00601 r = div_assign_r(d, d, g, ROUND_DIRECT); 00602 if (r != V_EQ) 00603 return false; 00604 r = lcm_assign_r(to.divisor, rx.divisor, ry.divisor, ROUND_DIRECT); 00605 if (r != V_EQ) 00606 return set_integer(to); 00607 // FIXME: to be completed 00608 return true; 00609 }
bool Parma_Polyhedra_Library::intersect_restriction | ( | Interval_Restriction_Integer< Base > & | to, | |
const From1 & | x, | |||
const From2 & | y | |||
) | [inline] |
Definition at line 252 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().
00252 { 00253 to.set_integer(Restriction_Integer<From1, Base>::get(x).get_integer() 00254 || Restriction_Integer<From2, Base>::get(y).get_integer()); 00255 return true; 00256 }
bool Parma_Polyhedra_Library::intersect_restriction | ( | Interval_Restriction_None_Base & | , | |
const T1 & | , | |||
const T2 & | ||||
) | [inline] |
Definition at line 82 of file Interval_Restriction.defs.hh.
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign().
Poly_Con_Relation Parma_Polyhedra_Library::interval_relation | ( | const ITV & | i, | |
const Constraint::Type | constraint_type, | |||
Coefficient_traits::const_reference | num, | |||
Coefficient_traits::const_reference | den = 1 | |||
) | [inline] |
Returns the relations holding between an interval and an interval constraint.
i | The interval; | |
constraint_type | The constraint type; | |
num | The numerator of the constraint bound; | |
den | The denominator of the constraint bound |
den * Variable(0) relsym num
where relsym is ==
, >
or >=
depending on the constraint_type
.
Definition at line 613 of file Box.templates.hh.
References assign_r(), Parma_Polyhedra_Library::Constraint::EQUALITY, Parma_Polyhedra_Library::Poly_Con_Relation::is_disjoint(), Parma_Polyhedra_Library::Poly_Con_Relation::is_included(), Parma_Polyhedra_Library::Constraint::NONSTRICT_INEQUALITY, Parma_Polyhedra_Library::Poly_Con_Relation::saturates(), Parma_Polyhedra_Library::Constraint::STRICT_INEQUALITY, and Parma_Polyhedra_Library::Poly_Con_Relation::strictly_intersects().
Referenced by Parma_Polyhedra_Library::Box< ITV >::relation_with().
00616 { 00617 00618 if (i.is_universe()) 00619 return Poly_Con_Relation::strictly_intersects(); 00620 00621 DIRTY_TEMP0(mpq_class, bound); 00622 assign_r(bound.get_num(), num, ROUND_NOT_NEEDED); 00623 assign_r(bound.get_den(), den, ROUND_NOT_NEEDED); 00624 bound.canonicalize(); 00625 neg_assign_r(bound, bound, ROUND_NOT_NEEDED); 00626 const bool is_lower_bound = (den > 0); 00627 00628 DIRTY_TEMP0(mpq_class, bound_diff); 00629 if (constraint_type == Constraint::EQUALITY) { 00630 if (i.lower_is_unbounded()) { 00631 assert(!i.upper_is_unbounded()); 00632 assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED); 00633 sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED); 00634 switch (sgn(bound_diff)) { 00635 case 1: 00636 return Poly_Con_Relation::strictly_intersects(); 00637 case 0: 00638 return i.upper_is_open() 00639 ? Poly_Con_Relation::is_disjoint() 00640 : Poly_Con_Relation::strictly_intersects(); 00641 case -1: 00642 return Poly_Con_Relation::is_disjoint(); 00643 } 00644 } 00645 else { 00646 assign_r(bound_diff, i.lower(), ROUND_NOT_NEEDED); 00647 sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED); 00648 switch (sgn(bound_diff)) { 00649 case 1: 00650 return Poly_Con_Relation::is_disjoint(); 00651 case 0: 00652 if (i.lower_is_open()) 00653 return Poly_Con_Relation::is_disjoint(); 00654 if (i.is_singleton()) 00655 return Poly_Con_Relation::is_included() 00656 && Poly_Con_Relation::saturates(); 00657 return Poly_Con_Relation::strictly_intersects(); 00658 case -1: 00659 if (i.upper_is_unbounded()) 00660 return Poly_Con_Relation::strictly_intersects(); 00661 else { 00662 assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED); 00663 sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED); 00664 switch (sgn(bound_diff)) { 00665 case 1: 00666 return Poly_Con_Relation::strictly_intersects(); 00667 case 0: 00668 if (i.upper_is_open()) 00669 return Poly_Con_Relation::is_disjoint(); 00670 else 00671 return Poly_Con_Relation::strictly_intersects(); 00672 case -1: 00673 return Poly_Con_Relation::is_disjoint(); 00674 } 00675 } 00676 } 00677 } 00678 } 00679 00680 assert(constraint_type != Constraint::EQUALITY); 00681 if (is_lower_bound) { 00682 if (i.lower_is_unbounded()) { 00683 assert(!i.upper_is_unbounded()); 00684 assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED); 00685 sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED); 00686 switch (sgn(bound_diff)) { 00687 case 1: 00688 return Poly_Con_Relation::strictly_intersects(); 00689 case 0: 00690 if (constraint_type == Constraint::STRICT_INEQUALITY 00691 || i.upper_is_open()) 00692 return Poly_Con_Relation::is_disjoint(); 00693 else 00694 return Poly_Con_Relation::strictly_intersects(); 00695 case -1: 00696 return Poly_Con_Relation::is_disjoint(); 00697 } 00698 } 00699 else { 00700 assign_r(bound_diff, i.lower(), ROUND_NOT_NEEDED); 00701 sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED); 00702 switch (sgn(bound_diff)) { 00703 case 1: 00704 return Poly_Con_Relation::is_included(); 00705 case 0: 00706 if (constraint_type == Constraint::NONSTRICT_INEQUALITY 00707 || i.lower_is_open()) { 00708 Poly_Con_Relation result = Poly_Con_Relation::is_included(); 00709 if (i.is_singleton()) 00710 result = result && Poly_Con_Relation::saturates(); 00711 return result; 00712 } 00713 else { 00714 assert(constraint_type == Constraint::STRICT_INEQUALITY 00715 && !i.lower_is_open()); 00716 if (i.is_singleton()) 00717 return Poly_Con_Relation::is_disjoint() 00718 && Poly_Con_Relation::saturates(); 00719 else 00720 return Poly_Con_Relation::strictly_intersects(); 00721 } 00722 case -1: 00723 if (i.upper_is_unbounded()) 00724 return Poly_Con_Relation::strictly_intersects(); 00725 else { 00726 assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED); 00727 sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED); 00728 switch (sgn(bound_diff)) { 00729 case 1: 00730 return Poly_Con_Relation::strictly_intersects(); 00731 case 0: 00732 if (constraint_type == Constraint::STRICT_INEQUALITY 00733 || i.upper_is_open()) 00734 return Poly_Con_Relation::is_disjoint(); 00735 else 00736 return Poly_Con_Relation::strictly_intersects(); 00737 case -1: 00738 return Poly_Con_Relation::is_disjoint(); 00739 } 00740 } 00741 } 00742 } 00743 } 00744 else { 00745 // `c' is an upper bound. 00746 if (i.upper_is_unbounded()) 00747 return Poly_Con_Relation::strictly_intersects(); 00748 else { 00749 assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED); 00750 sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED); 00751 switch (sgn(bound_diff)) { 00752 case -1: 00753 return Poly_Con_Relation::is_included(); 00754 case 0: 00755 if (constraint_type == Constraint::NONSTRICT_INEQUALITY 00756 || i.upper_is_open()) { 00757 Poly_Con_Relation result = Poly_Con_Relation::is_included(); 00758 if (i.is_singleton()) 00759 result = result && Poly_Con_Relation::saturates(); 00760 return result; 00761 } 00762 else { 00763 assert(constraint_type == Constraint::STRICT_INEQUALITY 00764 && !i.upper_is_open()); 00765 if (i.is_singleton()) 00766 return Poly_Con_Relation::is_disjoint() 00767 && Poly_Con_Relation::saturates(); 00768 else 00769 return Poly_Con_Relation::strictly_intersects(); 00770 } 00771 case 1: 00772 if (i.lower_is_unbounded()) 00773 return Poly_Con_Relation::strictly_intersects(); 00774 else { 00775 assign_r(bound_diff, i.lower(), ROUND_NOT_NEEDED); 00776 sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED); 00777 switch (sgn(bound_diff)) { 00778 case -1: 00779 return Poly_Con_Relation::strictly_intersects(); 00780 case 0: 00781 if (constraint_type == Constraint::STRICT_INEQUALITY 00782 || i.lower_is_open()) 00783 return Poly_Con_Relation::is_disjoint(); 00784 else 00785 return Poly_Con_Relation::strictly_intersects(); 00786 case 1: 00787 return Poly_Con_Relation::is_disjoint(); 00788 } 00789 } 00790 } 00791 } 00792 } 00793 00794 // Quiet a compiler warning: this program point is unreachable. 00795 throw std::runtime_error("PPL internal error"); 00796 }
bool Parma_Polyhedra_Library::is_additive_inverse | ( | const Checked_Number< T, Policy > & | x, | |
const Checked_Number< T, Policy > & | y | |||
) | [inline] |
Returns true
if and only if .
Definition at line 101 of file math_utilities.inlines.hh.
Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::compute_leaders(), Parma_Polyhedra_Library::BD_Shape< T >::compute_predecessors(), Parma_Polyhedra_Library::Octagonal_Shape< T >::compute_successors(), Parma_Polyhedra_Library::Octagonal_Shape< T >::constraints(), Parma_Polyhedra_Library::BD_Shape< T >::constraints(), Parma_Polyhedra_Library::BD_Shape< T >::is_shortest_path_reduced(), Parma_Polyhedra_Library::Octagonal_Shape< T >::minimized_congruences(), Parma_Polyhedra_Library::Octagonal_Shape< T >::relation_with(), Parma_Polyhedra_Library::BD_Shape< T >::relation_with(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::tight_coherence_would_make_empty().
00102 { 00103 Checked_Number<T, Policy> negated_x; 00104 return neg_assign_r(negated_x, x, ROUND_DIRECT) == V_EQ 00105 && negated_x == y; 00106 }
bool Parma_Polyhedra_Library::is_canonical | ( | const mpq_class & | x | ) | [inline] |
Returns true
if and only if x
is in canonical form.
Definition at line 109 of file math_utilities.inlines.hh.
Referenced by Parma_Polyhedra_Library::Box< ITV >::Box(), Parma_Polyhedra_Library::Polyhedron::contains_integer_point(), Parma_Polyhedra_Library::Box< ITV >::max_min(), and Parma_Polyhedra_Library::MIP_Problem::solve_mip().
00109 { 00110 if (x.get_den() <= 0) 00111 return false; 00112 DIRTY_TEMP0(mpq_class, temp); 00113 temp = x; 00114 temp.canonicalize(); 00115 return temp.get_num() == x.get_num(); 00116 }
bool Parma_Polyhedra_Library::is_even | ( | const Checked_Number< T, Policy > & | x | ) | [inline] |
Returns true
if and only if x
is an even number.
Definition at line 93 of file math_utilities.inlines.hh.
References is_integer().
Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::tight_coherence_would_make_empty().
00093 { 00094 Checked_Number<T, Policy> half_x; 00095 return div2exp_assign_r(half_x, x, 1, ROUND_DIRECT) == V_EQ 00096 && is_integer(half_x); 00097 }
int Parma_Polyhedra_Library::is_infinity | ( | const Interval< Boundary, Info > & | x | ) | [inline] |
Definition at line 61 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::is_infinity().
Enable_If<Is_Native_Or_Checked<T>::value, int>::type Parma_Polyhedra_Library::is_infinity | ( | const T & | x | ) | [related] |
Definition at line 245 of file Checked_Number.inlines.hh.
References Parma_Polyhedra_Library::Checked_Number< T, Policy >::is_minus_infinity(), and Parma_Polyhedra_Library::Checked_Number< T, Policy >::is_plus_infinity().
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().
00245 { 00246 return is_minus_infinity(x) ? -1 : is_plus_infinity(x) ? 1 : 0; 00247 }
bool Parma_Polyhedra_Library::is_integer | ( | const char * | ) | [inline] |
Enable_If<Is_Native_Or_Checked<T>::value, bool>::type Parma_Polyhedra_Library::is_integer | ( | const T & | x | ) | [related] |
Definition at line 258 of file Checked_Number.inlines.hh.
References raw_value().
Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::contains_integer_point(), Parma_Polyhedra_Library::BD_Shape< T >::contains_integer_point(), Parma_Polyhedra_Library::Restriction_Integer_Modulo< From, T, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_None_Base, typename From::info_type >::value >::type >::get(), Parma_Polyhedra_Library::Restriction_Integer_Modulo< From, T, Base, typename Enable_If< Is_Native_Or_Checked< From >::value >::type >::get(), Parma_Polyhedra_Library::Restriction_Integer< From, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_None_Base, typename From::info_type >::value >::type >::get(), Parma_Polyhedra_Library::Restriction_Integer< From, Base, typename Enable_If< Is_Native_Or_Checked< From >::value >::type >::get(), is_even(), is_singleton_integer(), and Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::restrict().
00258 { 00259 return Checked::is_int<typename Native_Checked_From_Wrapper<T> 00260 ::Policy>(Native_Checked_From_Wrapper<T>::raw_value(x)); 00261 }
bool Parma_Polyhedra_Library::is_minus_infinity | ( | const Checked_Number< T, Policy > & | x | ) | [inline] |
Definition at line 316 of file Checked_Number.inlines.hh.
References Parma_Polyhedra_Library::Checked_Number< T, Policy >::raw_value().
Enable_If<Is_Native_Or_Checked<T>::value, bool>::type Parma_Polyhedra_Library::is_minus_infinity | ( | const T & | x | ) | [related] |
Definition at line 231 of file Checked_Number.inlines.hh.
References raw_value().
Referenced by numer_denom(), Parma_Polyhedra_Library::Octagonal_Shape< T >::OK(), Parma_Polyhedra_Library::Interval< Boundary, Info >::OK(), and Parma_Polyhedra_Library::BD_Shape< T >::OK().
00231 { 00232 return Checked::is_minf<typename Native_Checked_From_Wrapper<T> 00233 ::Policy>(Native_Checked_From_Wrapper<T>::raw_value(x)); 00234 }
bool Parma_Polyhedra_Library::is_not_a_number | ( | const char * | ) | [inline] |
bool Parma_Polyhedra_Library::is_not_a_number | ( | const Checked_Number< T, Policy > & | x | ) | [inline] |
Definition at line 310 of file Checked_Number.inlines.hh.
References Parma_Polyhedra_Library::Checked_Number< T, Policy >::raw_value().
Enable_If<Is_Native_Or_Checked<T>::value, bool>::type Parma_Polyhedra_Library::is_not_a_number | ( | const T & | x | ) | [related] |
Definition at line 251 of file Checked_Number.inlines.hh.
References raw_value().
Referenced by Parma_Polyhedra_Library::Interval_NS::f_is_empty(), numer_denom(), Parma_Polyhedra_Library::Interval< Boundary, Info >::OK(), and Parma_Polyhedra_Library::DB_Row< T >::OK().
00251 { 00252 return Checked::is_nan<typename Native_Checked_From_Wrapper<T> 00253 ::Policy>(Native_Checked_From_Wrapper<T>::raw_value(x)); 00254 }
bool Parma_Polyhedra_Library::is_plus_infinity | ( | const Checked_Number< T, Policy > & | x | ) | [inline] |
Definition at line 322 of file Checked_Number.inlines.hh.
References Parma_Polyhedra_Library::Checked_Number< T, Policy >::raw_value().
Enable_If<Is_Native_Or_Checked<T>::value, bool>::type Parma_Polyhedra_Library::is_plus_infinity | ( | const T & | x | ) | [related] |
Definition at line 238 of file Checked_Number.inlines.hh.
References raw_value().
Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::affine_image(), Parma_Polyhedra_Library::BD_Shape< T >::affine_image(), Parma_Polyhedra_Library::Octagonal_Shape< T >::bounded_affine_image(), Parma_Polyhedra_Library::BD_Shape< T >::bounded_affine_image(), Parma_Polyhedra_Library::Octagonal_Shape< T >::bounds(), Parma_Polyhedra_Library::BD_Shape< T >::bounds(), Parma_Polyhedra_Library::Box< ITV >::Box(), Parma_Polyhedra_Library::Octagonal_Shape< T >::CC76_narrowing_assign(), Parma_Polyhedra_Library::BD_Shape< T >::CC76_narrowing_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::constrains(), Parma_Polyhedra_Library::BD_Shape< T >::constrains(), Parma_Polyhedra_Library::Octagonal_Shape< T >::constraints(), Parma_Polyhedra_Library::BD_Shape< T >::constraints(), Parma_Polyhedra_Library::Octagonal_Shape< T >::contains_integer_point(), Parma_Polyhedra_Library::BD_Shape< T >::contains_integer_point(), Parma_Polyhedra_Library::Octagonal_Shape< T >::deduce_minus_v_pm_u_bounds(), Parma_Polyhedra_Library::BD_Shape< T >::deduce_u_minus_v_bounds(), Parma_Polyhedra_Library::BD_Shape< T >::deduce_v_minus_u_bounds(), Parma_Polyhedra_Library::Octagonal_Shape< T >::deduce_v_pm_u_bounds(), Parma_Polyhedra_Library::Octagonal_Shape< T >::generalized_affine_image(), Parma_Polyhedra_Library::BD_Shape< T >::generalized_affine_image(), Parma_Polyhedra_Library::Octagonal_Shape< T >::incremental_strong_closure_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::is_bounded(), Parma_Polyhedra_Library::BD_Shape< T >::is_bounded(), Parma_Polyhedra_Library::BD_Shape< T >::is_shortest_path_reduced(), Parma_Polyhedra_Library::Octagonal_Shape< T >::is_strong_coherent(), Parma_Polyhedra_Library::Octagonal_Shape< T >::is_strongly_reduced(), Parma_Polyhedra_Library::Octagonal_Shape< T >::is_universe(), Parma_Polyhedra_Library::BD_Shape< T >::is_universe(), Parma_Polyhedra_Library::OR_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::DB_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::max_min(), Parma_Polyhedra_Library::BD_Shape< T >::max_min(), Parma_Polyhedra_Library::BD_Shape< T >::minimized_congruences(), Parma_Polyhedra_Library::BD_Shape< T >::minimized_constraints(), numer_denom(), Parma_Polyhedra_Library::Octagonal_Shape< T >::OK(), Parma_Polyhedra_Library::Interval< Boundary, Info >::OK(), Parma_Polyhedra_Library::BD_Shape< T >::OK(), Parma_Polyhedra_Library::Octagonal_Shape< T >::refine(), Parma_Polyhedra_Library::BD_Shape< T >::refine(), Parma_Polyhedra_Library::Octagonal_Shape< T >::relation_with(), Parma_Polyhedra_Library::BD_Shape< T >::relation_with(), Parma_Polyhedra_Library::BD_Shape< T >::shortest_path_closure_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::strong_closure_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::strong_coherence_assign(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::tight_coherence_would_make_empty().
00238 { 00239 return Checked::is_pinf<typename Native_Checked_From_Wrapper<T> 00240 ::Policy>(Native_Checked_From_Wrapper<T>::raw_value(x)); 00241 }
Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, bool>::type Parma_Polyhedra_Library::is_singleton_integer | ( | const T & | x | ) | [inline] |
Definition at line 154 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval_NS::f_lower(), is_integer(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::is_singleton().
00154 { 00155 return is_singleton(x) && is_integer(f_lower(x)); 00156 }
unsigned long Parma_Polyhedra_Library::isqrt | ( | unsigned long | x | ) | [inline] |
Returns the integer square root of x
.
Definition at line 405 of file OR_Matrix.inlines.hh.
Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::max_num_rows().
00405 { 00406 unsigned long r = 0; 00407 for (unsigned long t = 0x40000000; t; t >>= 2) { 00408 unsigned long s = r + t; 00409 if (s <= x) { 00410 x -= s; 00411 r = s + t; 00412 } 00413 r >>= 1; 00414 } 00415 return r; 00416 }
bool Parma_Polyhedra_Library::join_restriction | ( | Interval_Restriction_Integer_Modulo< T, Base > & | to, | |
const From1 & | x, | |||
const From2 & | y | |||
) | [inline] |
Definition at line 523 of file Interval_Restriction.defs.hh.
References assign_r(), contains_restriction(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder, set_integer(), and set_unrestricted().
00523 { 00524 typedef Restriction_Integer_Modulo<From1, T, Base> Rx; 00525 const typename Rx::type& rx = Rx::get(x); 00526 if (rx.divisor == 0) 00527 return set_unrestricted(to); 00528 typedef Restriction_Integer_Modulo<From2, T, Base> Ry; 00529 const typename Ry::type& ry = Ry::get(y); 00530 if (ry.divisor == 0) 00531 return set_unrestricted(to); 00532 else if (rx.divisor == 1 && ry.divisor == 1 00533 && is_singleton(x) && is_singleton(y)) { 00534 DIRTY_TEMP(typename Boundary_Value<From1>::type, a); 00535 DIRTY_TEMP(typename Boundary_Value<From2>::type, b); 00536 Result r; 00537 r = abs_assign_r(a, f_lower(x), ROUND_CHECK); 00538 if (r != V_EQ) 00539 return set_integer(to); 00540 r = abs_assign_r(b, f_lower(y), ROUND_CHECK); 00541 if (r != V_EQ) 00542 return set_integer(to); 00543 if (a > b) 00544 r = sub_assign_r(a, a, b, ROUND_CHECK); 00545 else 00546 r = sub_assign_r(a, b, a, ROUND_CHECK); 00547 if (r != V_EQ) 00548 return set_integer(to); 00549 r = assign_r(to.divisor, a, ROUND_CHECK); 00550 if (r != V_EQ) 00551 return set_integer(to); 00552 r = rem_assign_r(b, b, a, ROUND_CHECK); 00553 if (r != V_EQ) 00554 return set_integer(to); 00555 r = assign_r(to.remainder, b, ROUND_CHECK); 00556 if (r != V_EQ) 00557 return set_integer(to); 00558 } 00559 else if (contains_restriction(rx, ry)) { 00560 to.remainder = rx.remainder; 00561 to.divisor = rx.divisor; 00562 } 00563 else if (contains_restriction(ry, rx)) { 00564 to.remainder = ry.remainder; 00565 to.divisor = ry.divisor; 00566 } 00567 else 00568 return set_integer(to); 00569 return true; 00570 }
bool Parma_Polyhedra_Library::join_restriction | ( | Interval_Restriction_Integer< Base > & | to, | |
const From1 & | x, | |||
const From2 & | y | |||
) | [inline] |
Definition at line 244 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().
00244 { 00245 to.set_integer(Restriction_Integer<From1, Base>::get(x).get_integer() 00246 && Restriction_Integer<From2, Base>::get(y).get_integer()); 00247 return true; 00248 }
bool Parma_Polyhedra_Library::join_restriction | ( | Interval_Restriction_None_Base & | , | |
const T1 & | , | |||
const T2 & | ||||
) | [inline] |
Definition at line 76 of file Interval_Restriction.defs.hh.
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign().
void Parma_Polyhedra_Library::lcm_assign | ( | GMP_Integer & | x, | |
const GMP_Integer & | y, | |||
const GMP_Integer & | z | |||
) | [related] |
Definition at line 67 of file GMP_Integer.inlines.hh.
Referenced by Parma_Polyhedra_Library::MIP_Problem::compute_generator(), Parma_Polyhedra_Library::Grid::conversion(), Parma_Polyhedra_Library::MIP_Problem::get_exiting_base_index(), Parma_Polyhedra_Library::Box< ITV >::max_min(), Parma_Polyhedra_Library::Grid::normalize_divisors(), Parma_Polyhedra_Library::Congruence_System::normalize_moduli(), and Parma_Polyhedra_Library::MIP_Problem::steepest_edge_exact_entering_index().
Enable_If<Is_Native_Or_Checked<T1>::value && Is_Native_Or_Checked<T2>::value, bool>::type Parma_Polyhedra_Library::less_or_equal | ( | const T1 & | x, | |
const T2 & | y | |||
) | [inline] |
Enable_If<Is_Native_Or_Checked<T1>::value && Is_Native_Or_Checked<T2>::value, bool>::type Parma_Polyhedra_Library::less_than | ( | const T1 & | x, | |
const T2 & | y | |||
) | [inline] |
T Parma_Polyhedra_Library::low_bits_mask | ( | unsigned | n | ) | [inline] |
Returns a mask for the lowest n
bits,.
Definition at line 44 of file math_utilities.inlines.hh.
00044 { 00045 assert(n < unsigned(std::numeric_limits<T>::digits)); 00046 return n == 0 ? 0 : ~(~(T(0u)) << n); 00047 }
Result Parma_Polyhedra_Library::lower | ( | I_Result | r | ) | [inline] |
Definition at line 60 of file Interval.defs.hh.
Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::relation_with(), Parma_Polyhedra_Library::Box< ITV >::relation_with(), Parma_Polyhedra_Library::BD_Shape< T >::relation_with(), and unrepresentability_error().
void Parma_Polyhedra_Library::max_assign | ( | N & | x, | |
const N & | y | |||
) | [inline] |
Assigns to x
the maximum between x
and y
.
Definition at line 86 of file math_utilities.inlines.hh.
Referenced by Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), Parma_Polyhedra_Library::Octagonal_Shape< T >::fold_space_dimensions(), Parma_Polyhedra_Library::BD_Shape< T >::fold_space_dimensions(), Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::upper_bound_assign().
void Parma_Polyhedra_Library::maybe_abandon | ( | ) | [related] |
Definition at line 41 of file globals.inlines.hh.
References abandon_expensive_computations.
Referenced by Parma_Polyhedra_Library::MIP_Problem::compute_simplex_using_exact_pricing(), Parma_Polyhedra_Library::MIP_Problem::compute_simplex_using_steepest_edge_float(), Parma_Polyhedra_Library::Polyhedron::conversion(), and Parma_Polyhedra_Library::Box< ITV >::propagate_constraints_no_check().
00041 { 00042 if (const Throwable* p = abandon_expensive_computations) 00043 p->throw_me(); 00044 }
Result Parma_Polyhedra_Library::maybe_assign | ( | const To *& | top, | |
To & | tmp, | |||
const From & | from, | |||
Rounding_Dir | dir | |||
) | [inline] |
Assigns to top
a pointer to a location that holds the conversion, according to dir
, of from
to type To
. When necessary, and only when necessary, the variable tmp
is used to hold the result of conversion.
Definition at line 63 of file distances.inlines.hh.
Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::Generator::l_m_distance_assign(), Parma_Polyhedra_Library::DB_Matrix< T >::l_m_distance_assign(), and Parma_Polyhedra_Library::Box< ITV >::l_m_distance_assign().
int Parma_Polyhedra_Library::maybe_check_fpu_inexact | ( | ) | [inline] |
Definition at line 825 of file Checked_Number.inlines.hh.
00825 { 00826 if (FPU_Related<T>::value) 00827 return fpu_check_inexact(); 00828 else 00829 return 0; 00830 }
void Parma_Polyhedra_Library::maybe_reset_fpu_inexact | ( | ) | [inline] |
void Parma_Polyhedra_Library::min_assign | ( | N & | x, | |
const N & | y | |||
) | [inline] |
Assigns to x
the minimum between x
and y
.
Definition at line 79 of file math_utilities.inlines.hh.
Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::incremental_strong_closure_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign(), Parma_Polyhedra_Library::BD_Shape< T >::shortest_path_closure_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::strong_closure_assign(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::strong_coherence_assign().
T Parma_Polyhedra_Library::minus_infinity | ( | ) | [inline] |
Definition at line 798 of file Checked_Number.inlines.hh.
References MINUS_INFINITY.
00798 { 00799 return MINUS_INFINITY; 00800 }
bool Parma_Polyhedra_Library::mul_restriction | ( | Interval_Restriction_Integer_Modulo< T, Base > & | to, | |
const From1 & | x, | |||
const From2 & | y | |||
) | [inline] |
Definition at line 794 of file Interval_Restriction.defs.hh.
References assign_r(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, Parma_Polyhedra_Library::Interval_NS::f_lower(), mulmod(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder, set_integer(), and set_unrestricted().
00794 { 00795 typedef Restriction_Integer_Modulo<From1, T, Base> Rx; 00796 const typename Rx::type& rx = Rx::get(x); 00797 if (rx.divisor == 0) 00798 return set_unrestricted(to); 00799 typedef Restriction_Integer_Modulo<From2, T, Base> Ry; 00800 const typename Ry::type& ry = Ry::get(y); 00801 if (ry.divisor == 0) 00802 return set_unrestricted(to); 00803 Result r; 00804 DIRTY_TEMP(T, mul); 00805 if (is_singleton(x)) { 00806 if (is_singleton(y)) 00807 return set_integer(to); 00808 DIRTY_TEMP(typename Boundary_Value<From1>::type, n); 00809 r = abs_assign_r(n, f_lower(x), ROUND_CHECK); 00810 if (r != V_EQ) 00811 return set_integer(to); 00812 r = assign_r(mul, n, ROUND_CHECK); 00813 if (r != V_EQ) 00814 return set_integer(to); 00815 r = mul_assign_r(to.remainder, mul, ry.remainder, ROUND_NOT_NEEDED); 00816 if (r != V_EQ) 00817 return set_integer(to); 00818 r = mul_assign_r(to.divisor, mul, ry.divisor, ROUND_NOT_NEEDED); 00819 if (r != V_EQ) 00820 return set_integer(to); 00821 } 00822 else if (is_singleton(y)) { 00823 DIRTY_TEMP(typename Boundary_Value<From2>::type, n); 00824 r = abs_assign_r(n, f_lower(y), ROUND_CHECK); 00825 if (r != V_EQ) 00826 return set_integer(to); 00827 r = assign_r(mul, n, ROUND_CHECK); 00828 if (r != V_EQ) 00829 return set_integer(to); 00830 r = mul_assign_r(to.remainder, rx.remainder, mul, ROUND_NOT_NEEDED); 00831 if (r != V_EQ) 00832 return set_integer(to); 00833 r = mul_assign_r(to.divisor, rx.divisor, mul, ROUND_NOT_NEEDED); 00834 if (r != V_EQ) 00835 return set_integer(to); 00836 } 00837 else { 00838 r = gcd_assign_r(to.divisor, rx.divisor, ry.divisor, ROUND_NOT_NEEDED); 00839 assert(r == V_EQ); 00840 mulmod(to.remainder, rx.remainder, ry.remainder, to.divisor); 00841 } 00842 return true; 00843 }
bool Parma_Polyhedra_Library::mul_restriction | ( | Interval_Restriction_Integer< Base > & | to, | |
const From1 & | x, | |||
const From2 & | y | |||
) | [inline] |
Definition at line 291 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().
00291 { 00292 to.set_integer(Restriction_Integer<From1, Base>::get(x).get_integer() 00293 && Restriction_Integer<From2, Base>::get(y).get_integer()); 00294 return true; 00295 }
bool Parma_Polyhedra_Library::mul_restriction | ( | Interval_Restriction_None_Base & | , | |
const T1 & | , | |||
const T2 & | ||||
) | [inline] |
Definition at line 112 of file Interval_Restriction.defs.hh.
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign().
void Parma_Polyhedra_Library::mulmod | ( | T & | to, | |
const T & | x, | |||
const T & | y, | |||
const T & | to_m | |||
) | [inline] |
Definition at line 765 of file Interval_Restriction.defs.hh.
References assign_r().
Referenced by mul_restriction().
00765 { 00766 Result r; 00767 if (std::numeric_limits<T>::is_bounded) { 00768 DIRTY_TEMP0(mpz_class, a); 00769 DIRTY_TEMP0(mpz_class, b); 00770 r = assign_r(a, x, ROUND_NOT_NEEDED); 00771 assert(r == V_EQ); 00772 r = assign_r(b, y, ROUND_NOT_NEEDED); 00773 assert(r == V_EQ); 00774 r = mul_assign_r(a, a, b, ROUND_NOT_NEEDED); 00775 assert(r == V_EQ); 00776 r = assign_r(b, to_m, ROUND_NOT_NEEDED); 00777 assert(r == V_EQ); 00778 r = rem_assign_r(a, a, b, ROUND_NOT_NEEDED); 00779 assert(r == V_EQ); 00780 r = assign_r(to, a, ROUND_NOT_NEEDED); 00781 assert(r == V_EQ); 00782 } 00783 else { 00784 r = mul_assign_r(to, x, y, ROUND_NOT_NEEDED); 00785 assert(r == V_EQ); 00786 r = rem_assign_r(to, to, to_m, ROUND_NOT_NEEDED); 00787 assert(r == V_EQ); 00788 } 00789 }
void Parma_Polyhedra_Library::neg_assign | ( | GMP_Integer & | x, | |
const GMP_Integer & | y | |||
) | [related] |
Definition at line 34 of file GMP_Integer.inlines.hh.
Referenced by Parma_Polyhedra_Library::Linear_System::back_substitute(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::neg_assign().
void Parma_Polyhedra_Library::neg_assign | ( | GMP_Integer & | x | ) | [related] |
Definition at line 29 of file GMP_Integer.inlines.hh.
Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::add_constraint(), Parma_Polyhedra_Library::BD_Shape< T >::add_constraint(), Parma_Polyhedra_Library::Polyhedron::affine_image(), Parma_Polyhedra_Library::Grid::affine_image(), Parma_Polyhedra_Library::BD_Shape< T >::affine_image(), Parma_Polyhedra_Library::Polyhedron::affine_preimage(), Parma_Polyhedra_Library::Octagonal_Shape< T >::affine_preimage(), Parma_Polyhedra_Library::Grid::affine_preimage(), Parma_Polyhedra_Library::BD_Shape< T >::bounded_affine_image(), Parma_Polyhedra_Library::Octagonal_Shape< T >::bounded_affine_preimage(), Parma_Polyhedra_Library::Box< ITV >::bounded_affine_preimage(), Parma_Polyhedra_Library::BD_Shape< T >::bounded_affine_preimage(), Parma_Polyhedra_Library::MIP_Problem::compute_generator(), Parma_Polyhedra_Library::MIP_Problem::compute_simplex_using_steepest_edge_float(), Parma_Polyhedra_Library::Polyhedron::conversion(), Parma_Polyhedra_Library::Octagonal_Shape< T >::deduce_minus_v_pm_u_bounds(), Parma_Polyhedra_Library::Octagonal_Shape< T >::deduce_v_pm_u_bounds(), Parma_Polyhedra_Library::Octagonal_Shape< T >::generalized_affine_image(), Parma_Polyhedra_Library::Grid::generalized_affine_image(), Parma_Polyhedra_Library::BD_Shape< T >::generalized_affine_image(), Parma_Polyhedra_Library::Polyhedron::generalized_affine_preimage(), Parma_Polyhedra_Library::Octagonal_Shape< T >::generalized_affine_preimage(), Parma_Polyhedra_Library::Grid::generalized_affine_preimage(), Parma_Polyhedra_Library::Box< ITV >::generalized_affine_preimage(), Parma_Polyhedra_Library::BD_Shape< T >::generalized_affine_preimage(), Parma_Polyhedra_Library::Octagonal_Shape< T >::get_limiting_octagon(), Parma_Polyhedra_Library::BD_Shape< T >::get_limiting_shape(), Parma_Polyhedra_Library::Grid::Grid(), Parma_Polyhedra_Library::Octagonal_Shape< T >::max_min(), Parma_Polyhedra_Library::BD_Shape< T >::max_min(), Parma_Polyhedra_Library::Grid_Generator::negate(), Parma_Polyhedra_Library::Congruence::negate(), Parma_Polyhedra_Library::Row::normalize(), Parma_Polyhedra_Library::Grid_Generator::operator<<(), Parma_Polyhedra_Library::Constraint::operator<<(), Parma_Polyhedra_Library::Congruence::operator<<(), Parma_Polyhedra_Library::MIP_Problem::process_pending_constraints(), Parma_Polyhedra_Library::Grid::reduce_congruence_with_equality(), Parma_Polyhedra_Library::Grid::reduce_parameter_with_line(), Parma_Polyhedra_Library::Octagonal_Shape< T >::refine(), Parma_Polyhedra_Library::BD_Shape< T >::refine(), Parma_Polyhedra_Library::Octagonal_Shape< T >::refine_no_check(), Parma_Polyhedra_Library::BD_Shape< T >::refine_no_check(), Parma_Polyhedra_Library::Octagonal_Shape< T >::relation_with(), Parma_Polyhedra_Library::BD_Shape< T >::relation_with(), Parma_Polyhedra_Library::MIP_Problem::second_phase(), Parma_Polyhedra_Library::Linear_Row::sign_normalize(), and Parma_Polyhedra_Library::Congruence::sign_normalize().
bool Parma_Polyhedra_Library::neg_restriction | ( | Interval_Restriction_Integer_Modulo< T, Base > & | to, | |
const From & | x | |||
) | [inline] |
Definition at line 621 of file Interval_Restriction.defs.hh.
References assign_restriction().
00621 { 00622 return assign_restriction(to, x); 00623 }
bool Parma_Polyhedra_Library::neg_restriction | ( | Interval_Restriction_Integer< Base > & | to, | |
const From & | x | |||
) | [inline] |
Definition at line 268 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().
00268 { 00269 to.set_integer(Restriction_Integer<From, Base>::get(x).get_integer()); 00270 return true; 00271 }
bool Parma_Polyhedra_Library::neg_restriction | ( | Interval_Restriction_None_Base & | , | |
const T & | ||||
) | [inline] |
Definition at line 94 of file Interval_Restriction.defs.hh.
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::neg_assign().
void Parma_Polyhedra_Library::normalize2 | ( | Coefficient_traits::const_reference | x, | |
Coefficient_traits::const_reference | y, | |||
Coefficient & | nx, | |||
Coefficient & | ny | |||
) | [inline] |
If is the GCD of
x
and y
, the values of x
and y
divided by are assigned to
nx
and ny
, respectively.
x
and nx
may be the same object and likewise for y
and ny
. Any other aliasing results in undefined behavior. Definition at line 33 of file math_utilities.inlines.hh.
References exact_div_assign(), gcd_assign(), and TEMP_INTEGER.
Referenced by Parma_Polyhedra_Library::Polyhedron::conversion(), Parma_Polyhedra_Library::MIP_Problem::evaluate_objective_function(), Parma_Polyhedra_Library::MIP_Problem::linear_combine(), and Parma_Polyhedra_Library::Linear_Row::linear_combine().
00035 { 00036 TEMP_INTEGER(gcd); 00037 gcd_assign(gcd, x, y); 00038 exact_div_assign(nx, x, gcd); 00039 exact_div_assign(ny, y, gcd); 00040 }
dimension_type Parma_Polyhedra_Library::not_a_dimension | ( | ) | [inline] |
Returns a value that does not designate a valid dimension.
Definition at line 32 of file globals.inlines.hh.
Referenced by Parma_Polyhedra_Library::Polyhedron::map_space_dimensions(), Parma_Polyhedra_Library::Grid::map_space_dimensions(), and Parma_Polyhedra_Library::Variable::max_space_dimension().
T Parma_Polyhedra_Library::not_a_number | ( | ) | [inline] |
Definition at line 804 of file Checked_Number.inlines.hh.
References NOT_A_NUMBER.
00804 { 00805 return NOT_A_NUMBER; 00806 }
Enable_If<Is_Native_Or_Checked<T1>::value && Is_Native_Or_Checked<T2>::value, bool>::type Parma_Polyhedra_Library::not_equal | ( | const T1 & | x, | |
const T2 & | y | |||
) | [inline] |
void Parma_Polyhedra_Library::numer_denom | ( | const Checked_Number< T, Policy > & | from, | |
Coefficient & | num, | |||
Coefficient & | den | |||
) | [inline] |
Extract the numerator and denominator components of from
.
Definition at line 51 of file math_utilities.inlines.hh.
References assign_r(), is_minus_infinity(), is_not_a_number(), and is_plus_infinity().
Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::constraints(), Parma_Polyhedra_Library::BD_Shape< T >::constraints(), Parma_Polyhedra_Library::Octagonal_Shape< T >::max_min(), Parma_Polyhedra_Library::BD_Shape< T >::max_min(), Parma_Polyhedra_Library::Octagonal_Shape< T >::minimized_congruences(), Parma_Polyhedra_Library::BD_Shape< T >::minimized_congruences(), Parma_Polyhedra_Library::BD_Shape< T >::minimized_constraints(), Parma_Polyhedra_Library::Octagonal_Shape< T >::relation_with(), and Parma_Polyhedra_Library::BD_Shape< T >::relation_with().
00052 { 00053 assert(!is_not_a_number(from) 00054 && !is_minus_infinity(from) 00055 && !is_plus_infinity(from)); 00056 DIRTY_TEMP0(mpq_class, q); 00057 assign_r(q, from, ROUND_NOT_NEEDED); 00058 num = q.get_num(); 00059 den = q.get_den(); 00060 }
bool Parma_Polyhedra_Library::operator!= | ( | const Box< ITV > & | x, | |
const Box< ITV > & | y | |||
) | [related] |
Definition at line 260 of file Box.inlines.hh.
Referenced by Parma_Polyhedra_Library::Grid_Generator_System::const_iterator::operator!=().
Enable_If<((Is_Singleton<T1>::value || Is_Interval<T1>::value) && (Is_Singleton<T2>::value || Is_Interval<T2>::value) && (Is_Interval<T1>::value || Is_Interval<T2>::value)), bool>::type Parma_Polyhedra_Library::operator!= | ( | const T1 & | x, | |
const T2 & | y | |||
) | [related] |
Interval<B, Info> Parma_Polyhedra_Library::operator* | ( | const Interval< B, Info > & | x, | |
const Interval< B, Info > & | y | |||
) | [inline] |
Definition at line 1109 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign().
Referenced by Parma_Polyhedra_Library::Grid_Generator_System::const_iterator::operator*().
Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator* | ( | const T & | x, | |
const Interval< B, Info > & | y | |||
) | [inline] |
Definition at line 1101 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign().
Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator* | ( | const Interval< B, Info > & | x, | |
const T & | y | |||
) | [inline] |
Definition at line 1093 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign().
Interval<B, Info> Parma_Polyhedra_Library::operator+ | ( | const Interval< B, Info > & | x, | |
const Interval< B, Info > & | y | |||
) | [inline] |
Definition at line 1061 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign().
Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator+ | ( | const T & | x, | |
const Interval< B, Info > & | y | |||
) | [inline] |
Definition at line 1053 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign().
Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator+ | ( | const Interval< B, Info > & | x, | |
const T & | y | |||
) | [inline] |
Definition at line 1045 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign().
Interval<B, Info> Parma_Polyhedra_Library::operator- | ( | const Interval< B, Info > & | x, | |
const Interval< B, Info > & | y | |||
) | [inline] |
Definition at line 1085 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().
Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator- | ( | const T & | x, | |
const Interval< B, Info > & | y | |||
) | [inline] |
Definition at line 1077 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().
Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator- | ( | const Interval< B, Info > & | x, | |
const T & | y | |||
) | [inline] |
Definition at line 1069 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().
Interval<B, Info> Parma_Polyhedra_Library::operator/ | ( | const Interval< B, Info > & | x, | |
const Interval< B, Info > & | y | |||
) | [inline] |
Definition at line 1133 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign().
Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator/ | ( | const T & | x, | |
const Interval< B, Info > & | y | |||
) | [inline] |
Definition at line 1125 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign().
Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator/ | ( | const Interval< B, Info > & | x, | |
const T & | y | |||
) | [inline] |
Definition at line 1117 of file Interval.inlines.hh.
References Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign().
std::ostream& Parma_Polyhedra_Library::operator<< | ( | std::ostream & | os, | |
const Interval< Boundary, Info > & | x | |||
) | [inline] |
Definition at line 1141 of file Interval.inlines.hh.
References check_empty_arg(), and output_restriction().
01141 { 01142 // assert(x.OK()); 01143 if (check_empty_arg(x)) 01144 return os << "[]"; 01145 if (x.is_singleton()) { 01146 output(os, x.lower(), Numeric_Format(), ROUND_NOT_NEEDED); 01147 return os; 01148 } 01149 os << (x.lower_is_open() ? "(" : "["); 01150 if (x.info().get_boundary_property(LOWER, SPECIAL)) 01151 os << "-inf"; 01152 else 01153 output(os, x.lower(), Numeric_Format(), ROUND_NOT_NEEDED); 01154 os << ", "; 01155 if (x.info().get_boundary_property(UPPER, SPECIAL)) 01156 os << "+inf"; 01157 else 01158 output(os, x.upper(), Numeric_Format(), ROUND_NOT_NEEDED); 01159 os << (x.upper_is_open() ? ")" : "]"); 01160 output_restriction(os, x.info()); 01161 return os; 01162 }
bool Parma_Polyhedra_Library::operator== | ( | const Box< ITV > & | x, | |
const Box< ITV > & | y | |||
) | [inline] |
Definition at line 562 of file Box.templates.hh.
References Parma_Polyhedra_Library::Box< ITV >::is_empty(), Parma_Polyhedra_Library::Box< ITV >::seq, and Parma_Polyhedra_Library::Box< ITV >::space_dimension().
Referenced by Parma_Polyhedra_Library::Grid_Generator_System::const_iterator::operator==().
00562 { 00563 const dimension_type x_space_dim = x.space_dimension(); 00564 if (x_space_dim != y.space_dimension()) 00565 return false; 00566 00567 if (x.is_empty()) 00568 return y.is_empty(); 00569 00570 if (y.is_empty()) 00571 return x.is_empty(); 00572 00573 for (dimension_type k = x_space_dim; k-- > 0; ) 00574 if (x.seq[k] != y.seq[k]) 00575 return false; 00576 return true; 00577 }
Enable_If<((Is_Singleton<T1>::value || Is_Interval<T1>::value) && (Is_Singleton<T2>::value || Is_Interval<T2>::value) && (Is_Interval<T1>::value || Is_Interval<T2>::value)), bool>::type Parma_Polyhedra_Library::operator== | ( | const T1 & | x, | |
const T2 & | y | |||
) | [related] |
Definition at line 195 of file Interval.inlines.hh.
References check_empty_arg(), Parma_Polyhedra_Library::Checked::eq(), eq_restriction(), Parma_Polyhedra_Library::Interval_NS::f_info(), Parma_Polyhedra_Library::Interval_NS::f_lower(), f_OK(), and Parma_Polyhedra_Library::Interval_NS::f_upper().
00195 { 00196 assert(f_OK(x)); 00197 assert(f_OK(y)); 00198 if (check_empty_arg(x)) 00199 return check_empty_arg(y); 00200 else if (check_empty_arg(y)) 00201 return false; 00202 return eq_restriction(f_info(x), f_info(y)) 00203 && eq(LOWER, f_lower(x), f_info(x), LOWER, f_lower(y), f_info(y)) 00204 && eq(UPPER, f_upper(x), f_info(x), UPPER, f_upper(y), f_info(y)); 00205 }
void Parma_Polyhedra_Library::output_restriction | ( | std::ostream & | s, | |
const Interval_Restriction_Integer_Modulo< T, Base > & | x | |||
) | [inline] |
Definition at line 858 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, and Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder.
00858 { 00859 if (x.divisor == 1) 00860 s << "i"; 00861 else if (x.divisor != 0) 00862 s << "{" << x.remainder << "%" << x.divisor << "}"; 00863 }
void Parma_Polyhedra_Library::output_restriction | ( | std::ostream & | s, | |
const Interval_Restriction_Integer< Base > & | x | |||
) | [inline] |
Definition at line 306 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::get_integer().
void Parma_Polyhedra_Library::output_restriction | ( | std::ostream & | , | |
const Interval_Restriction_None_Base & | ||||
) | [inline] |
T Parma_Polyhedra_Library::plus_infinity | ( | ) | [inline] |
Definition at line 792 of file Checked_Number.inlines.hh.
References PLUS_INFINITY.
00792 { 00793 return PLUS_INFINITY; 00794 }
bool Parma_Polyhedra_Library::@202::propagate_constraint_check_result | ( | Result | r, | |
Ternary & | open | |||
) | [inline, static] |
Definition at line 1932 of file Box.templates.hh.
References T_MAYBE, T_NO, and T_YES.
Referenced by Parma_Polyhedra_Library::Box< ITV >::propagate_constraint_no_check().
01932 { 01933 switch (r) { 01934 case V_NEG_OVERFLOW: 01935 case V_POS_OVERFLOW: 01936 case V_UNKNOWN_NEG_OVERFLOW: 01937 case V_UNKNOWN_POS_OVERFLOW: 01938 return true; 01939 case V_LT: 01940 case V_GT: 01941 open = T_YES; 01942 return false; 01943 case V_LE: 01944 case V_GE: 01945 if (open == T_NO) 01946 open = T_MAYBE; 01947 return false; 01948 case V_EQ: 01949 return false; 01950 default: 01951 assert(false); 01952 return true; 01953 } 01954 }
unsigned Parma_Polyhedra_Library::rational_sqrt_precision_parameter | ( | ) | [inline] |
Returns the precision parameter used for rational square root calculations.
Definition at line 454 of file checked_mpq.inlines.hh.
References Parma_Polyhedra_Library::Checked::rational_sqrt_precision_parameter.
00454 { 00455 return Checked::rational_sqrt_precision_parameter; 00456 }
mpz_class& Parma_Polyhedra_Library::raw_value | ( | GMP_Integer & | x | ) | [related] |
Definition at line 103 of file GMP_Integer.inlines.hh.
Referenced by Parma_Polyhedra_Library::Checked_Number< T, Policy >::assign_r(), assign_r(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::cmp(), construct(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::input(), is_integer(), is_minus_infinity(), is_not_a_number(), is_plus_infinity(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::output(), and Parma_Polyhedra_Library::Checked_Number< T, Policy >::sgn().
const mpz_class& Parma_Polyhedra_Library::raw_value | ( | const GMP_Integer & | x | ) | [related] |
void Parma_Polyhedra_Library::rem_assign | ( | GMP_Integer & | x, | |
const GMP_Integer & | y, | |||
const GMP_Integer & | z | |||
) | [related] |
Definition at line 54 of file GMP_Integer.inlines.hh.
Referenced by Parma_Polyhedra_Library::Pointset_Powerset< PS >::approximate_partition_aux().
void Parma_Polyhedra_Library::restore_pre_PPL_rounding | ( | ) | [inline] |
Sets the FPU rounding mode as it was before initialization of the PPL.
After calling this function it is absolutely necessary to call set_rounding_for_PPL() before using any PPL abstractions based on floating point numbers. This is performed automatically at finalization-time.
Definition at line 39 of file Init.inlines.hh.
References Parma_Polyhedra_Library::Init::old_rounding_direction.
00039 { 00040 #if PPL_CAN_CONTROL_FPU 00041 fpu_set_rounding_direction(Init::old_rounding_direction); 00042 #endif 00043 }
Rounding_Dir Parma_Polyhedra_Library::rounding_dir | ( | Rounding_Dir | dir | ) | [inline] |
Definition at line 33 of file Checked_Number.inlines.hh.
Referenced by Parma_Polyhedra_Library::Checked_Number< T, Policy >::assign_r(), assign_r(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number(), construct(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::input(), and Parma_Polyhedra_Library::Checked_Number< T, Policy >::output().
00033 { 00034 if (dir == ROUND_NOT_NEEDED) { 00035 #ifdef DEBUG_ROUND_NOT_NEEDED 00036 return ROUND_DIRECT & ROUND_FPU_CHECK_INEXACT; 00037 #else 00038 return ROUND_IGNORE; 00039 #endif 00040 } 00041 return dir; 00042 }
bool Parma_Polyhedra_Library::same_object | ( | const T & | x, | |
const T & | y | |||
) | [inline] |
bool Parma_Polyhedra_Library::same_object | ( | const T1 & | , | |
const T2 & | ||||
) | [inline] |
bool Parma_Polyhedra_Library::set_integer | ( | Interval_Restriction_Integer_Modulo< T, Base > & | to | ) | [inline] |
Definition at line 507 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, and Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder.
Referenced by add_restriction(), intersect_restriction(), join_restriction(), mul_restriction(), and sub_restriction().
void Parma_Polyhedra_Library::set_rational_sqrt_precision_parameter | ( | const unsigned | p | ) | [inline] |
Sets the precision parameter used for rational square root calculations.
If p
is less than or equal to INT_MAX
, sets the precision parameter used for rational square root calculations to p
.
std::invalid_argument | Thrown if p is greater than INT_MAX . |
Definition at line 467 of file checked_mpq.inlines.hh.
References Parma_Polyhedra_Library::Checked::rational_sqrt_precision_parameter.
Referenced by Parma_Polyhedra_Library::Init::Init().
00467 { 00468 if (p <= INT_MAX) 00469 Checked::rational_sqrt_precision_parameter = p; 00470 else 00471 throw std::invalid_argument("PPL::set_rational_sqrt_precision_parameter(p)" 00472 " with p > INT_MAX"); 00473 }
void Parma_Polyhedra_Library::set_rounding_for_PPL | ( | ) | [inline] |
Sets the FPU rounding mode so that the PPL abstractions based on floating point numbers work correctly.
This is performed automatically at initialization-time. Calling this function is needed only if restore_pre_PPL_rounding() has been previously called.
Definition at line 32 of file Init.inlines.hh.
00032 { 00033 #if PPL_CAN_CONTROL_FPU 00034 fpu_set_rounding_direction(round_fpu_dir(ROUND_DIRECT)); 00035 #endif 00036 }
bool Parma_Polyhedra_Library::set_unrestricted | ( | Interval_Restriction_Integer_Modulo< T, Base > & | to | ) | [inline] |
Definition at line 499 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, and Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder.
Referenced by add_restriction(), div_restriction(), join_restriction(), mul_restriction(), and sub_restriction().
void Parma_Polyhedra_Library::sqrt_assign | ( | GMP_Integer & | x, | |
const GMP_Integer & | y | |||
) | [related] |
void Parma_Polyhedra_Library::sub_mul_assign | ( | GMP_Integer & | x, | |
const GMP_Integer & | y, | |||
const GMP_Integer & | z | |||
) | [related] |
Definition at line 77 of file GMP_Integer.inlines.hh.
Referenced by Parma_Polyhedra_Library::Polyhedron::BHRZ03_evolving_rays(), Parma_Polyhedra_Library::MIP_Problem::compute_generator(), Parma_Polyhedra_Library::Grid::conversion(), Parma_Polyhedra_Library::Polyhedron::conversion(), Parma_Polyhedra_Library::MIP_Problem::linear_combine(), Parma_Polyhedra_Library::Linear_Row::linear_combine(), Parma_Polyhedra_Library::Grid::reduce_congruence_with_equality(), Parma_Polyhedra_Library::Grid::reduce_equality_with_equality(), Parma_Polyhedra_Library::Grid::reduce_line_with_line(), Parma_Polyhedra_Library::Grid::reduce_parameter_with_line(), and Parma_Polyhedra_Library::Grid::reduce_pc_with_pc().
bool Parma_Polyhedra_Library::sub_restriction | ( | Interval_Restriction_Integer_Modulo< T, Base > & | to, | |
const From1 & | x, | |||
const From2 & | y | |||
) | [inline] |
Definition at line 728 of file Interval_Restriction.defs.hh.
References assign_r(), assign_rem(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder, set_integer(), set_unrestricted(), and submod().
00728 { 00729 typedef Restriction_Integer_Modulo<From1, T, Base> Rx; 00730 const typename Rx::type& rx = Rx::get(x); 00731 if (rx.divisor == 0) 00732 return set_unrestricted(to); 00733 typedef Restriction_Integer_Modulo<From2, T, Base> Ry; 00734 const typename Ry::type& ry = Ry::get(y); 00735 if (ry.divisor == 0) 00736 return set_unrestricted(to); 00737 Result r; 00738 DIRTY_TEMP(T, rem); 00739 if (is_singleton(x)) { 00740 if (is_singleton(y)) 00741 return set_integer(to); 00742 if (!assign_rem(rem, f_lower(x), ry.divisor)) 00743 return set_integer(to); 00744 r = assign_r(to.divisor, ry.divisor, ROUND_NOT_NEEDED); 00745 assert(r == V_EQ); 00746 submod(to.remainder, rem, ry.remainder, to.divisor, ry.divisor); 00747 } 00748 else if (is_singleton(y)) { 00749 if (!assign_rem(rem, f_lower(y), rx.divisor)) 00750 return set_integer(to); 00751 r = assign_r(to.divisor, rx.divisor, ROUND_NOT_NEEDED); 00752 assert(r == V_EQ); 00753 submod(to.remainder, rx.remainder, rem, to.divisor, to.divisor); 00754 } 00755 else { 00756 r = gcd_assign_r(to.divisor, rx.divisor, ry.divisor, ROUND_NOT_NEEDED); 00757 assert(r == V_EQ); 00758 submod(to.remainder, rx.remainder, ry.remainder, to.divisor, ry.divisor); 00759 } 00760 return true; 00761 }
bool Parma_Polyhedra_Library::sub_restriction | ( | Interval_Restriction_Integer< Base > & | to, | |
const From1 & | x, | |||
const From2 & | y | |||
) | [inline] |
Definition at line 283 of file Interval_Restriction.defs.hh.
References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().
00283 { 00284 to.set_integer(Restriction_Integer<From1, Base>::get(x).get_integer() 00285 && Restriction_Integer<From2, Base>::get(y).get_integer()); 00286 return true; 00287 }
bool Parma_Polyhedra_Library::sub_restriction | ( | Interval_Restriction_None_Base & | , | |
const T1 & | , | |||
const T2 & | ||||
) | [inline] |
Definition at line 106 of file Interval_Restriction.defs.hh.
Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().
void Parma_Polyhedra_Library::submod | ( | T & | to, | |
const T & | x, | |||
const T & | y, | |||
const T & | to_m, | |||
const T & | y_m | |||
) | [inline] |
Definition at line 710 of file Interval_Restriction.defs.hh.
Referenced by sub_restriction().
00710 { 00711 Result r; 00712 if (x >= y) { 00713 r = sub_assign_r(to, x, y, ROUND_NOT_NEEDED); 00714 assert(r == V_EQ); 00715 } 00716 else { 00717 r = sub_assign_r(to, y_m, y, ROUND_NOT_NEEDED); 00718 assert(r == V_EQ); 00719 r = add_assign_r(to, x, to, ROUND_NOT_NEEDED); 00720 assert(r == V_EQ); 00721 } 00722 r = rem_assign_r(to, to, to_m, ROUND_NOT_NEEDED); 00723 assert(r == V_EQ); 00724 }
Enable_If<Slow_Copy<T>::value, void>::type Parma_Polyhedra_Library::swap | ( | T & | , | |
T & | ||||
) | [inline] |
Make sure swap() is specialized when needed.
This will cause a compile-time error whenever a specialization for T
is beneficial but missing.
Definition at line 50 of file globals.defs.hh.
References COMPILE_TIME_CHECK.
Referenced by Parma_Polyhedra_Library::Linear_System::add_pending_row(), Parma_Polyhedra_Library::Linear_System::add_pending_rows(), Parma_Polyhedra_Library::Polyhedron::add_recycled_constraints(), Parma_Polyhedra_Library::Polyhedron::add_recycled_generators(), Parma_Polyhedra_Library::Polyhedron::add_recycled_generators_and_minimize(), Parma_Polyhedra_Library::Grid::add_recycled_grid_generators(), Parma_Polyhedra_Library::Grid::add_recycled_grid_generators_and_minimize(), Parma_Polyhedra_Library::Matrix::add_recycled_row(), Parma_Polyhedra_Library::Bit_Matrix::add_row(), Parma_Polyhedra_Library::Linear_System::add_rows_and_columns(), Parma_Polyhedra_Library::Polyhedron::add_space_dimensions(), Parma_Polyhedra_Library::Polyhedron::add_space_dimensions_and_embed(), Parma_Polyhedra_Library::Polyhedron::add_space_dimensions_and_project(), Parma_Polyhedra_Library::Congruence_System::add_unit_rows_and_columns(), Parma_Polyhedra_Library::Matrix::add_zero_columns(), Parma_Polyhedra_Library::Matrix::add_zero_rows(), Parma_Polyhedra_Library::Matrix::add_zero_rows_and_columns(), Parma_Polyhedra_Library::Generator_System::adjust_topology_and_space_dimension(), Parma_Polyhedra_Library::Constraint_System::adjust_topology_and_space_dimension(), Parma_Polyhedra_Library::Octagonal_Shape< T >::affine_image(), Parma_Polyhedra_Library::Grid_Generator_System::affine_image(), Parma_Polyhedra_Library::Generator_System::affine_image(), Parma_Polyhedra_Library::BD_Shape< T >::affine_image(), Parma_Polyhedra_Library::Pointset_Powerset< PS >::BGP99_heuristics_assign(), Parma_Polyhedra_Library::Polyhedron::BHRZ03_combining_constraints(), Parma_Polyhedra_Library::Polyhedron::BHRZ03_evolving_points(), Parma_Polyhedra_Library::Polyhedron::BHRZ03_evolving_rays(), Parma_Polyhedra_Library::Polyhedron::BHRZ03_widening_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PS >::BHZ03_widening_assign(), Parma_Polyhedra_Library::Grid_Generator::coefficient_swap(), Parma_Polyhedra_Library::Congruence_System::concatenate(), Parma_Polyhedra_Library::Polyhedron::concatenate_assign(), Parma_Polyhedra_Library::Congruence::Congruence(), Parma_Polyhedra_Library::Grid::congruence_widening_assign(), Parma_Polyhedra_Library::Constraint::Constraint(), Parma_Polyhedra_Library::Grid::construct(), Parma_Polyhedra_Library::Polyhedron::conversion(), Parma_Polyhedra_Library::Pointset_Powerset< PS >::difference_assign(), Parma_Polyhedra_Library::Linear_System::gauss(), Parma_Polyhedra_Library::Generator::Generator(), Parma_Polyhedra_Library::Grid::generator_widening_assign(), Parma_Polyhedra_Library::Grid_Generator::Grid_Generator(), Parma_Polyhedra_Library::DB_Matrix< T >::grow(), Parma_Polyhedra_Library::Polyhedron::H79_widening_assign(), Parma_Polyhedra_Library::Linear_System::insert(), Parma_Polyhedra_Library::Grid_Generator_System::insert(), Parma_Polyhedra_Library::Congruence_System::insert(), Parma_Polyhedra_Library::Linear_System::insert_pending(), Parma_Polyhedra_Library::Congruence_System::insert_verbatim(), Parma_Polyhedra_Library::Polyhedron::map_space_dimensions(), Parma_Polyhedra_Library::Octagonal_Shape< T >::map_space_dimensions(), Parma_Polyhedra_Library::Grid::map_space_dimensions(), Parma_Polyhedra_Library::BD_Shape< T >::map_space_dimensions(), Parma_Polyhedra_Library::Linear_System::merge_rows_assign(), Parma_Polyhedra_Library::Grid::OK(), Parma_Polyhedra_Library::Powerset< D >::pairwise_apply_assign(), Parma_Polyhedra_Library::Pointset_Powerset< PS >::pairwise_reduce(), Parma_Polyhedra_Library::Matrix::permute_columns(), Parma_Polyhedra_Library::Polyhedron::Polyhedron(), Parma_Polyhedra_Library::Smash_Reduction< D1, D2 >::product_reduce(), Parma_Polyhedra_Library::Constraints_Reduction< D1, D2 >::product_reduce(), Parma_Polyhedra_Library::Congruence_System::recycling_insert(), Parma_Polyhedra_Library::Grid::remove_higher_space_dimensions(), Parma_Polyhedra_Library::Generator_System::remove_invalid_lines_and_rays(), Parma_Polyhedra_Library::BD_Shape< T >::remove_space_dimensions(), Parma_Polyhedra_Library::Bit_Matrix::resize(), Parma_Polyhedra_Library::Matrix::resize_no_copy(), Parma_Polyhedra_Library::DB_Matrix< T >::resize_no_copy(), Parma_Polyhedra_Library::Polyhedron::select_H79_constraints(), Parma_Polyhedra_Library::BD_Shape< T >::shortest_path_reduction_assign(), Parma_Polyhedra_Library::Polyhedron::simplify(), Parma_Polyhedra_Library::Linear_System::simplify(), Parma_Polyhedra_Library::Grid::simplify(), Parma_Polyhedra_Library::Linear_System::sort_and_remove_with_sat(), Parma_Polyhedra_Library::Linear_System::sort_pending_and_remove_duplicates(), Parma_Polyhedra_Library::MIP_Problem::steepest_edge_exact_entering_index(), Parma_Polyhedra_Library::Octagonal_Shape< T >::strong_reduction_assign(), Parma_Polyhedra_Library::Polyhedron::strongly_minimize_constraints(), Parma_Polyhedra_Library::Polyhedron::strongly_minimize_generators(), Parma_Polyhedra_Library::Row::swap(), Parma_Polyhedra_Library::Powerset< D >::swap(), Parma_Polyhedra_Library::Polyhedron::swap(), Parma_Polyhedra_Library::Pointset_Powerset< PS >::swap(), Parma_Polyhedra_Library::Partially_Reduced_Product< D1, D2, R >::swap(), Parma_Polyhedra_Library::OR_Matrix< T >::swap(), Parma_Polyhedra_Library::Octagonal_Shape< T >::swap(), Parma_Polyhedra_Library::MIP_Problem::swap(), Parma_Polyhedra_Library::Matrix::swap(), Parma_Polyhedra_Library::Linear_System::swap(), Parma_Polyhedra_Library::Linear_Expression::swap(), Parma_Polyhedra_Library::Interval_Info_Bitset< T, Policy >::swap(), Parma_Polyhedra_Library::Interval< Boundary, Info >::swap(), Parma_Polyhedra_Library::Grid_Generator_System::swap(), Parma_Polyhedra_Library::Grid_Generator::swap(), Parma_Polyhedra_Library::Grid::swap(), Parma_Polyhedra_Library::Generator_System::swap(), Parma_Polyhedra_Library::Generator::swap(), Parma_Polyhedra_Library::Determinate< PS >::swap(), Parma_Polyhedra_Library::DB_Row< T >::swap(), Parma_Polyhedra_Library::DB_Matrix< T >::swap(), Parma_Polyhedra_Library::Constraint_System::swap(), Parma_Polyhedra_Library::Constraint::swap(), Parma_Polyhedra_Library::Congruence_System::swap(), Parma_Polyhedra_Library::Congruence::swap(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::swap(), Parma_Polyhedra_Library::Box< ITV >::swap(), Parma_Polyhedra_Library::Bit_Matrix::swap(), Parma_Polyhedra_Library::BD_Shape< T >::swap(), Parma_Polyhedra_Library::Matrix::swap_columns(), Parma_Polyhedra_Library::Polyhedron::time_elapse_assign(), and Parma_Polyhedra_Library::Partially_Reduced_Product< D1, D2, R >::upper_bound_assign_if_exact().
00050 { 00051 COMPILE_TIME_CHECK(!Slow_Copy<T>::value, "missing swap specialization"); 00052 }
void Parma_Polyhedra_Library::throw_result_exception | ( | Result | r | ) |
Definition at line 29 of file Checked_Number.cc.
Referenced by Parma_Polyhedra_Library::WRD_Extended_Number_Policy::handle_result(), Parma_Polyhedra_Library::Extended_Number_Policy::handle_result(), and Parma_Polyhedra_Library::Checked_Number_Default_Policy::handle_result().
00029 { 00030 switch (r) { 00031 case V_LT: 00032 throw std::logic_error("Exact result is less than computed one."); 00033 case V_LE: 00034 throw std::logic_error("Exact result is less than or equal to " 00035 "computed one."); 00036 case V_GT: 00037 throw std::logic_error("Exact result is greater than computed one."); 00038 case V_GE: 00039 throw std::logic_error("Exact result is greater than or equal to " 00040 "computed one."); 00041 case V_NE: 00042 throw std::logic_error("Exact result is less than or greater than " 00043 "computed one."); 00044 case V_LGE: 00045 throw std::logic_error("Exact result is less than, greater than or " 00046 "equal to computed one."); 00047 case VC_MINUS_INFINITY: 00048 throw std::overflow_error("Minus infinity."); 00049 case V_NEG_OVERFLOW: 00050 throw std::overflow_error("Negative overflow."); 00051 case V_UNKNOWN_NEG_OVERFLOW: 00052 throw std::overflow_error("Unknown result due to negative overflow."); 00053 case VC_PLUS_INFINITY: 00054 throw std::overflow_error("Plus infinity."); 00055 case V_POS_OVERFLOW: 00056 throw std::overflow_error("Positive overflow."); 00057 case V_UNKNOWN_POS_OVERFLOW: 00058 throw std::overflow_error("Unknown result due to positive overflow."); 00059 case V_CVT_STR_UNK: 00060 throw std::domain_error("Invalid numeric string."); 00061 case V_DIV_ZERO: 00062 throw std::domain_error("Division by zero."); 00063 case V_INF_ADD_INF: 00064 throw std::domain_error("Infinities addition."); 00065 case V_INF_DIV_INF: 00066 throw std::domain_error("Infinities division."); 00067 case V_INF_MOD: 00068 throw std::domain_error("Remainder of division of infinity."); 00069 case V_INF_MUL_ZERO: 00070 throw std::domain_error("Multiplication of infinity and zero."); 00071 case V_INF_SUB_INF: 00072 throw std::domain_error("Subtraction of infinities."); 00073 case V_MOD_ZERO: 00074 throw std::domain_error("Remainder of division by zero."); 00075 case V_SQRT_NEG: 00076 throw std::domain_error("Square root of negative number."); 00077 case V_UNORD_COMP: 00078 throw std::domain_error("Unordered comparison."); 00079 default: 00080 throw std::logic_error("Unexpected result."); 00081 } 00082 }
memory_size_type Parma_Polyhedra_Library::total_memory_in_bytes | ( | const mpq_class & | x | ) | [inline] |
Returns the total size in bytes of the memory occupied by x
.
Definition at line 100 of file globals.inlines.hh.
References Parma_Polyhedra_Library::Checked_Number< T, Policy >::external_memory_in_bytes().
Referenced by Parma_Polyhedra_Library::Linear_Expression::total_memory_in_bytes(), Parma_Polyhedra_Library::Grid_Generator_System::total_memory_in_bytes(), Parma_Polyhedra_Library::Grid_Generator::total_memory_in_bytes(), Parma_Polyhedra_Library::Generator_System::total_memory_in_bytes(), Parma_Polyhedra_Library::Generator::total_memory_in_bytes(), Parma_Polyhedra_Library::Constraint_System::total_memory_in_bytes(), Parma_Polyhedra_Library::Constraint::total_memory_in_bytes(), Parma_Polyhedra_Library::Congruence_System::total_memory_in_bytes(), and Parma_Polyhedra_Library::Congruence::total_memory_in_bytes().
00100 { 00101 return sizeof(x) + external_memory_in_bytes(x); 00102 }
memory_size_type Parma_Polyhedra_Library::total_memory_in_bytes | ( | const mpz_class & | x | ) | [inline] |
Returns the total size in bytes of the memory occupied by x
.
Definition at line 89 of file globals.inlines.hh.
References Parma_Polyhedra_Library::Checked_Number< T, Policy >::external_memory_in_bytes().
00089 { 00090 return sizeof(x) + external_memory_in_bytes(x); 00091 }
Enable_If< Is_Native< T >::value, memory_size_type >::type Parma_Polyhedra_Library::total_memory_in_bytes | ( | const T & | ) | [inline] |
For native types, returns the total size in bytes of the memory occupied by the type of the (unused) parameter, i.e., 0.
Definition at line 79 of file globals.inlines.hh.
memory_size_type Parma_Polyhedra_Library::total_memory_in_bytes | ( | const GMP_Integer & | x | ) |
bool Parma_Polyhedra_Library::unrepresentability_error | ( | I_Result | r, | |
const Info & | ||||
) | [inline] |
Result Parma_Polyhedra_Library::upper | ( | I_Result | r | ) | [inline] |
const char * Parma_Polyhedra_Library::version | ( | ) |
Returns a character string containing the PPL version.
Definition at line 93 of file version.cc.
References version_string.
00093 { 00094 return version_string; 00095 }
unsigned Parma_Polyhedra_Library::version_beta | ( | ) |
Returns the beta number of the PPL version.
Definition at line 88 of file version.cc.
References PPL_VERSION_BETA.
00088 { 00089 return PPL_VERSION_BETA; 00090 }
unsigned Parma_Polyhedra_Library::version_major | ( | ) |
Returns the major number of the PPL version.
Definition at line 73 of file version.cc.
References PPL_VERSION_MAJOR.
00073 { 00074 return PPL_VERSION_MAJOR; 00075 }
unsigned Parma_Polyhedra_Library::version_minor | ( | ) |
Returns the minor number of the PPL version.
Definition at line 78 of file version.cc.
References PPL_VERSION_MINOR.
00078 { 00079 return PPL_VERSION_MINOR; 00080 }
unsigned Parma_Polyhedra_Library::version_revision | ( | ) |
Returns the revision number of the PPL version.
Definition at line 83 of file version.cc.
References PPL_VERSION_REVISION.
00083 { 00084 return PPL_VERSION_REVISION; 00085 }