Parma_Polyhedra_Library Namespace Reference
[C++ Language Interface]

The entire library is confined to this namespace. More...


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>
plus_infinity ()
template<typename T>
minus_infinity ()
template<typename 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 $x = -y$.
void normalize2 (Coefficient_traits::const_reference x, Coefficient_traits::const_reference y, Coefficient &nx, Coefficient &ny)
 If $g$ is the GCD of x and y, the values of x and y divided by $g$ are assigned to 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>
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.


Detailed Description

The entire library is confined to this namespace.


Typedef Documentation

Definition at line 30 of file GMP_Integer.types.hh.


Enumeration Type Documentation

Enumerator:
I_EMPTY 
I_MAYBE_EMPTY 
I_SINGULARITIES 

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

Enumerator:
T_YES 
T_NO 
T_MAYBE 

Definition at line 52 of file Interval.defs.hh.

00052 { T_YES, T_NO, T_MAYBE };


Function Documentation

void Parma_Polyhedra_Library::abs_assign ( GMP_Integer &  x,
const GMP_Integer &  y 
) [related]

Definition at line 44 of file GMP_Integer.inlines.hh.

00044                                                  {
00045   mpz_abs(x.get_mpz_t(), y.get_mpz_t());
00046 }

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().

00039                            {
00040   mpz_abs(x.get_mpz_t(), x.get_mpz_t());
00041 }

void Parma_Polyhedra_Library::add_mul_assign ( GMP_Integer &  x,
const GMP_Integer &  y,
const GMP_Integer &  z 
) [related]

template<typename T, typename Base, typename From1, typename From2>
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 }

template<typename Base, typename From1, typename From2>
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 }

template<typename T1, typename T2>
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().

00100                                                                        {
00101   return true;
00102 }

template<typename T>
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 }

template<typename T>
Enable_If<Is_Native_Or_Checked<T>::value, void>::type Parma_Polyhedra_Library::ascii_dump ( std::ostream &  s,
const T &  t 
) [inline]

template<typename T>
Enable_If<Is_Native_Or_Checked<T>::value, bool>::type Parma_Polyhedra_Library::ascii_load ( std::ostream &  s,
T &  t 
) [inline]

template<typename To, typename From>
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 }

template<typename M, typename T>
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 }

template<typename T, typename Base, typename From>
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 }

template<typename Base, typename From>
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 }

template<typename T>
bool Parma_Polyhedra_Library::assign_restriction ( Interval_Restriction_None_Base &  ,
const T &   
) [inline]

Definition at line 70 of file Interval_Restriction.defs.hh.

Referenced by neg_restriction().

00070                                                               {
00071   return true;
00072 }

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 }

template<typename T>
Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, bool>::type Parma_Polyhedra_Library::check_empty_arg ( const T &  x  )  [inline]

template<typename Boundary, typename Info>
I_Result Parma_Polyhedra_Library::check_empty_result ( const Interval< Boundary, Info > &  x,
I_Result  r 
) [inline]

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

Finalizes the Coefficient constants.

Referenced by Parma_Polyhedra_Library::Init::~Init().

void Parma_Polyhedra_Library::Coefficient_constants_initialize (  ) 

Initializes the Coefficient constants.

Referenced by Parma_Polyhedra_Library::Init::Init().

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

I_Result Parma_Polyhedra_Library::combine ( Result  l,
Result  u 
) [inline]

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.

Returns:
The actual capacity to be allocated.
Parameters:
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.
Computes a capacity given a requested size. Allows for speculative allocation aimed at reducing the number of reallocations enough to guarantee amortized constant insertion time for our vector-like data structures. In all cases, the speculative allocation will not exceed 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)   
)

template<typename To, typename From>
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]

template<typename T1, typename T2>
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]

Definition at line 231 of file Interval_Restriction.defs.hh.

00231                                                {
00232   return !x.get_integer() || y.get_integer();
00233 }

template<typename T>
bool Parma_Polyhedra_Library::contains_restriction ( const Interval_Restriction_None_Base &  ,
const T &   
) [inline]

Parma_Polyhedra_Library::DEF_CTOR ( long  double  ) 

Parma_Polyhedra_Library::DEF_CTOR ( double   ) 

template<typename T, typename Base, typename From1, typename From2>
bool Parma_Polyhedra_Library::diff_restriction ( Interval_Restriction_Integer_Modulo< T, Base > &  to,
const From1 &  x,
const From2 &  y 
) [inline]

Definition at line 613 of file Interval_Restriction.defs.hh.

00614                                                  {
00615   // FIXME: to be written
00616   return true;
00617 }

template<typename Base, typename From1, typename From2>
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 }

template<typename T1, typename T2>
bool Parma_Polyhedra_Library::diff_restriction ( Interval_Restriction_None_Base &  ,
const T1 &  ,
const T2 &   
) [inline]

Definition at line 88 of file Interval_Restriction.defs.hh.

00088                                                                         {
00089   return true;
00090 }

template<typename T, typename Base, typename From1, typename From2>
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 }

template<typename Base, typename From1, typename From2>
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().

00299                                                                                     {
00300   to.set_integer(false);
00301   return true;
00302 }

template<typename T1, typename T2>
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().

00118                                                                        {
00119   return true;
00120 }

template<typename T, typename Policy>
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 }

template<typename T1, typename T2>
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]

Definition at line 225 of file Interval_Restriction.defs.hh.

00225                                          {
00226   return x.get_integer() == y.get_integer();
00227 }

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().

00058                                                                                             {
00059   return true;
00060 }

template<typename T1, typename T2>
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 }

template<typename T, typename Policy>
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]

memory_size_type Parma_Polyhedra_Library::external_memory_in_bytes ( const mpq_class &  x  )  [inline]

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.

00084                                              {
00085   return x.get_mpz_t()[0]._mp_alloc * PPL_SIZEOF_MP_LIMB_T;
00086 }

template<typename T>
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.

00072                                    {
00073   return 0;
00074 }

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 }

template<typename Boundary, typename Info>
bool Parma_Polyhedra_Library::f_is_empty ( const Interval< Boundary, Info > &  x  )  [inline]

template<typename Boundary, typename Info>
bool Parma_Polyhedra_Library::f_is_singleton ( const Interval< Boundary, Info > &  x  )  [inline]

template<typename T>
Enable_If<Has_OK<T>::value, bool>::type Parma_Polyhedra_Library::f_OK ( const T &  to  )  [inline]

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]

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 }

template<typename T1, typename T2>
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]

template<typename T1, typename T2>
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 }

template<typename T, typename Base, typename From1, typename From2>
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 }

template<typename Base, typename From1, typename From2>
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 }

template<typename T1, typename T2>
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().

00082                                                                              {
00083   return true;
00084 }

template<typename ITV>
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.

Parameters:
i The interval;
constraint_type The constraint type;
num The numerator of the constraint bound;
den The denominator of the constraint bound
The interval constraint has the form 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 }

template<typename T, typename Policy>
bool Parma_Polyhedra_Library::is_additive_inverse ( const Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y 
) [inline]

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 }

template<typename T, typename Policy>
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 }

template<typename Boundary, typename Info>
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().

00061                                                {
00062   return x.is_infinity();
00063 }

template<typename T>
Enable_If<Is_Native_Or_Checked<T>::value, int>::type Parma_Polyhedra_Library::is_infinity ( const T &  x  )  [related]

bool Parma_Polyhedra_Library::is_integer ( const char *   )  [inline]

template<typename T>
Enable_If<Is_Native_Or_Checked<T>::value, bool>::type Parma_Polyhedra_Library::is_integer ( const T &  x  )  [related]

template<typename T, typename Policy>
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().

00316                                                       {
00317   return Checked::is_minf<Policy>(x.raw_value());
00318 }

template<typename T>
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]

Definition at line 147 of file Interval.inlines.hh.

00147                              {
00148   // FIXME:
00149   return false;
00150 }

template<typename T, typename Policy>
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().

00310                                                     {
00311   return Checked::is_nan<Policy>(x.raw_value());
00312 }

template<typename T>
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 }

template<typename T, typename Policy>
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().

00322                                                      {
00323   return Checked::is_pinf<Policy>(x.raw_value());
00324 }

template<typename T>
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 }

template<typename T>
Enable_If<Is_Singleton<T>::value || Is_Interval<T>::value, bool>::type Parma_Polyhedra_Library::is_singleton_integer ( const T &  x  )  [inline]

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 }

template<typename T, typename Base, typename From1, typename From2>
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 }

template<typename Base, typename From1, typename From2>
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 }

template<typename T1, typename T2>
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().

00076                                                                         {
00077   return true;
00078 }

void Parma_Polyhedra_Library::lcm_assign ( GMP_Integer &  x,
const GMP_Integer &  y,
const GMP_Integer &  z 
) [related]

template<typename T1, typename T2>
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]

template<typename T1, typename T2>
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]

template<typename T>
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]

template<typename N>
void Parma_Polyhedra_Library::max_assign ( N &  x,
const N &  y 
) [inline]

void Parma_Polyhedra_Library::maybe_abandon (  )  [related]

template<typename To, typename From>
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().

00063                                                                           {
00064   return maybe_assign_struct<To, From>::function(top, tmp, from, dir);
00065 }

template<typename T>
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 }

template<typename T>
void Parma_Polyhedra_Library::maybe_reset_fpu_inexact (  )  [inline]

Definition at line 818 of file Checked_Number.inlines.hh.

00818                           {
00819   if (FPU_Related<T>::value)
00820     return fpu_reset_inexact();
00821 }

template<typename N>
void Parma_Polyhedra_Library::min_assign ( N &  x,
const N &  y 
) [inline]

template<typename T>
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 }

template<typename T, typename Base, typename From1, typename From2>
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 }

template<typename Base, typename From1, typename From2>
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 }

template<typename T1, typename T2>
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().

00112                                                                        {
00113   return true;
00114 }

template<typename T>
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().

00034                                                  {
00035   mpz_neg(x.get_mpz_t(), y.get_mpz_t());
00036 }

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().

00029                            {
00030   mpz_neg(x.get_mpz_t(), x.get_mpz_t());
00031 }

template<typename T, typename Base, typename From>
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 }

template<typename Base, typename From>
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 }

template<typename T>
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().

00094                                                            {
00095   return true;
00096 }

void Parma_Polyhedra_Library::normalize2 ( Coefficient_traits::const_reference  x,
Coefficient_traits::const_reference  y,
Coefficient &  nx,
Coefficient &  ny 
) [inline]

If $g$ is the GCD of x and y, the values of x and y divided by $g$ are assigned to nx and ny, respectively.

Note:
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().

00032                   {
00033   return std::numeric_limits<dimension_type>::max();
00034 }

template<typename T>
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 }

template<typename T1, typename T2>
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]

template<typename T, typename Policy>
void Parma_Polyhedra_Library::numer_denom ( const Checked_Number< T, Policy > &  from,
Coefficient &  num,
Coefficient &  den 
) [inline]

template<typename ITV>
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!=().

00260                                                  {
00261   return !(x == y);
00262 }

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 Parma_Polyhedra_Library::operator!= ( const T1 &  x,
const T2 &  y 
) [related]

Definition at line 212 of file Interval.inlines.hh.

00212                                      {
00213   return !(x == y);
00214 }

template<typename B, typename Info>
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*().

01109                                                                   {
01110   Interval<B, Info> z;
01111   z.mul_assign(x, y);
01112   return z;
01113 }

template<typename B, typename Info, typename T>
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().

01101                                                   {
01102   Interval<B, Info> z;
01103   z.mul_assign(x, y);
01104   return z;
01105 }

template<typename B, typename Info, typename T>
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().

01093                                                   {
01094   Interval<B, Info> z;
01095   z.mul_assign(x, y);
01096   return z;
01097 }

template<typename B, typename Info>
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().

01061                                                                   {
01062   Interval<B, Info> z;
01063   z.add_assign(x, y);
01064   return z;
01065 }

template<typename B, typename Info, typename T>
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().

01053                                                   {
01054   Interval<B, Info> z;
01055   z.add_assign(x, y);
01056   return z;
01057 }

template<typename B, typename Info, typename T>
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().

01045                                                   {
01046   Interval<B, Info> z;
01047   z.add_assign(x, y);
01048   return z;
01049 }

template<typename B, typename Info>
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().

01085                                                                   {
01086   Interval<B, Info> z;
01087   z.sub_assign(x, y);
01088   return z;
01089 }

template<typename B, typename Info, typename T>
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().

01077                                                   {
01078   Interval<B, Info> z;
01079   z.sub_assign(x, y);
01080   return z;
01081 }

template<typename B, typename Info, typename T>
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().

01069                                                   {
01070   Interval<B, Info> z;
01071   z.sub_assign(x, y);
01072   return z;
01073 }

template<typename B, typename Info>
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().

01133                                                                   {
01134   Interval<B, Info> z;
01135   z.div_assign(x, y);
01136   return z;
01137 }

template<typename B, typename Info, typename T>
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().

01125                                                   {
01126   Interval<B, Info> z;
01127   z.div_assign(x, y);
01128   return z;
01129 }

template<typename B, typename Info, typename T>
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().

01117                                                   {
01118   Interval<B, Info> z;
01119   z.div_assign(x, y);
01120   return z;
01121 }

template<typename Boundary, typename Info>
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 }

template<typename ITV>
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 }

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 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 }

template<typename T, typename Base>
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 }

template<typename Base>
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().

00306                                                                                {
00307   if (x.get_integer())
00308     s << "i";
00309 }

void Parma_Polyhedra_Library::output_restriction ( std::ostream &  ,
const Interval_Restriction_None_Base &   
) [inline]

Definition at line 123 of file Interval_Restriction.defs.hh.

Referenced by operator<<().

00123                                                                        {
00124 }

template<typename T>
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]

const mpz_class& Parma_Polyhedra_Library::raw_value ( const GMP_Integer &  x  )  [related]

Definition at line 98 of file GMP_Integer.inlines.hh.

Referenced by assign().

00098                                 {
00099   return x;
00100 }

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().

00054                                                                        {
00055   mpz_tdiv_r(x.get_mpz_t(), y.get_mpz_t(), z.get_mpz_t());
00056 }

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 }

template<typename T>
bool Parma_Polyhedra_Library::same_object ( const T &  x,
const T &  y 
) [inline]

Definition at line 166 of file Interval.inlines.hh.

00166                                     {
00167   return &x == &y;
00168 }

template<typename T1, typename T2>
bool Parma_Polyhedra_Library::same_object ( const T1 &  ,
const T2 &   
) [inline]

Definition at line 160 of file Interval.inlines.hh.

00160                                   {
00161   return false;
00162 }

template<typename T, typename Base>
bool Parma_Polyhedra_Library::set_integer ( Interval_Restriction_Integer_Modulo< T, Base > &  to  )  [inline]

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.

Exceptions:
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 }

template<typename T, typename Base>
bool Parma_Polyhedra_Library::set_unrestricted ( Interval_Restriction_Integer_Modulo< T, Base > &  to  )  [inline]

void Parma_Polyhedra_Library::sqrt_assign ( GMP_Integer &  x,
const GMP_Integer &  y 
) [related]

Definition at line 88 of file GMP_Integer.inlines.hh.

00088                                                   {
00089   mpz_sqrt(x.get_mpz_t(), y.get_mpz_t());
00090 }

void Parma_Polyhedra_Library::sub_mul_assign ( GMP_Integer &  x,
const GMP_Integer &  y,
const GMP_Integer &  z 
) [related]

template<typename T, typename Base, typename From1, typename From2>
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 }

template<typename Base, typename From1, typename From2>
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 }

template<typename T1, typename T2>
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().

00106                                                                        {
00107   return true;
00108 }

template<typename T>
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 }

template<typename T>
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]

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 }

template<typename T>
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.

00079                                 {
00080   return sizeof(T);
00081 }

memory_size_type Parma_Polyhedra_Library::total_memory_in_bytes ( const GMP_Integer &  x  ) 

template<typename Info>
bool Parma_Polyhedra_Library::unrepresentability_error ( I_Result  r,
const Info &   
) [inline]

Definition at line 71 of file Interval.defs.hh.

References lower(), and upper().

00071                                                   {
00072   return !Info::store_special
00073     && (is_special(lower(r)) || is_special(upper(r)));
00074 }

Result Parma_Polyhedra_Library::upper ( I_Result  r  )  [inline]

Definition at line 65 of file Interval.defs.hh.

Referenced by unrepresentability_error().

00065                   {
00066   return static_cast<Result>((r >> 6) & 63);
00067 }

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 }


Generated on Sat Oct 11 10:40:59 2008 for PPL by  doxygen 1.5.6