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

Namespaces
namespace	Boundary_NS
namespace	Checked
	Types and functions implementing checked numbers.
namespace	Implementation
	Implementation related data and functions.
namespace	Interfaces
	Data and functions related to language interfaces.
namespace	Interval_NS
namespace	IO_Operators
	All input/output operators are confined to this namespace.

Classes
class	Affine_Space
	An affine space. More...
class	Any_Pointset
	Any PPL pointset. More...
class	Ask_Tell_Pair
	A pair of ask and tell descriptions. More...
class	Ask_Tell
	The ask and tell construction on a base-level domain. More...
class	BD_Shape_Helpers
class	BD_Shape
	A bounded difference shape. More...
class	BHRZ03_Certificate
	The convergence certificate for the BHRZ03 widening operator. More...
class	Bit_Matrix
	A matrix of bits. More...
class	Bit_Row
	A row in a matrix of bits. More...
class	Box
	A not necessarily closed, iso-oriented hyperrectangle. More...
class	Box_Helpers
struct	C_Integer
struct	C_Integer< char >
struct	C_Integer< signed char >
struct	C_Integer< signed short >
struct	C_Integer< signed int >
struct	C_Integer< signed long >
struct	C_Integer< signed long long >
struct	C_Integer< unsigned char >
struct	C_Integer< unsigned short >
struct	C_Integer< unsigned int >
struct	C_Integer< unsigned long >
struct	C_Integer< unsigned long long >
class	C_Polyhedron
	A closed convex polyhedron. More...
class	c_streambuf
class	Cast_Floating_Point_Expression
	A generic Cast Floating Point Expression. 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
struct	FPU_Related
struct	FPU_Related< float >
struct	FPU_Related< double >
struct	FPU_Related< long double >
struct	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 > >
class	CO_Tree
	A cache-oblivious binary search tree of pairs. More...
struct	Coefficient_traits_template
	Coefficient traits. More...
struct	Suppress_Uninitialized_Warnings_Type
class	Concrete_Expression_Type
	The type of a concrete expression. More...
class	Concrete_Expression_Common
	Base class for all concrete expressions. More...
class	Binary_Operator_Common
	Base class for binary operator applied to two concrete expressions. More...
class	Unary_Operator_Common
	Base class for unary operator applied to one concrete expression. More...
class	Cast_Operator_Common
	Base class for cast operator concrete expressions. More...
class	Integer_Constant_Common
	Base class for integer constant concrete expressions. More...
class	Floating_Point_Constant_Common
	Base class for floating-point constant concrete expression. More...
class	Approximable_Reference_Common
	Base class for references to some approximable. More...
class	Congruence
	A linear congruence. More...
class	Congruence_System
	A system of congruences. More...
class	Constant_Floating_Point_Expression
	A generic Constant Floating Point Expression. More...
class	Constraint
	A linear equality or inequality. More...
class	Constraint_System
	A system of constraints. More...
class	Constraint_System_const_iterator
	An iterator over a system of constraints. More...
class	DB_Matrix
	The base class for the square matrices. 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	Dense_Row
	A finite sequence of coefficients. More...
class	Determinate
	A wrapper for PPL pointsets, providing them with a determinate constraint system interface, as defined in [Bag98]. More...
class	Difference_Floating_Point_Expression
	A generic Difference Floating Point Expression. More...
struct	Rectilinear_Distance_Specialization
struct	Euclidean_Distance_Specialization
struct	L_Infinity_Distance_Specialization
struct	maybe_assign_struct
struct	maybe_assign_struct< Type, Type >
class	Division_Floating_Point_Expression
	A generic Division Floating Point Expression. More...
class	Expression_Hide_Inhomo
class	Expression_Hide_Last
struct	float_ieee754_half
struct	float_ieee754_single
struct	float_ieee754_double
struct	float_ibm_single
struct	float_ibm_double
struct	float_intel_double_extended
struct	float_ieee754_quad
class	Float
class	FP_Oracle
	An abstract class to be implemented by an external analyzer such as ECLAIR in order to provide to the PPL the necessary information for performing the analysis of floating point computations. More...
class	Floating_Point_Expression
	A floating point expression on a given format. More...
struct	ia32_fenv_t
class	Generator
	A line, ray, point or closure point. More...
class	Generator_System
	A system of generators. More...
class	Generator_System_const_iterator
	An iterator over a system of generators. More...
struct	Weightwatch_Traits
	Traits class for the deterministic timeout mechanism. More...
class	In_Assert
class	Throwable
	User objects the PPL can throw. 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	Coefficient_traits_template< GMP_Integer >
	Coefficient traits specialization for unbounded integers. More...
class	Grid
	A grid. More...
class	Grid_Certificate
	The convergence certificate for the Grid widening operator. More...
class	Grid_Generator
	A grid line, parameter or grid point. More...
class	Grid_Generator_System
	A system of grid generators. More...
class	H79_Certificate
	A convergence certificate for the H79 widening operator. More...
struct	Has_Assign_Or_Swap
struct	Has_Assign_Or_Swap< T, typename Enable_If_Is< void(T::*)(T &x),&T::assign_or_swap >::type >
class	Init
	Class for initialization and finalization. More...
struct	Integer_Interval_Info_Policy
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< char >
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	Interval_Info_Null
class	Interval_Info_Null_Open
class	Interval_Info_Bitset
struct	Use_By_Ref< Use_Slow_Copy, T >
struct	Use_By_Ref< By_Value, T >
struct	Use_By_Ref< By_Ref, T >
class	Val_Or_Ref< T, Criteria, typename Enable_If<!Use_By_Ref< Criteria, T >::value >::type >
class	Val_Or_Ref< T, Criteria, typename Enable_If< Use_By_Ref< Criteria, T >::value >::type >
class	I_Constraint_Base
class	I_Constraint_Common
struct	I_Constraint_Rel
class	I_Constraint
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	Linear_Expression
	A linear expression. More...
class	Linear_Expression_Impl
	A linear expression. More...
class	Linear_Expression_Interface
	A linear expression. More...
class	Linear_Form
	A linear form with interval coefficients. More...
class	Linear_System
	The base class for systems of constraints and generators. More...
class	Matrix
	A sparse matrix of Coefficient. More...
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< char >
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 >
class	MIP_Problem
	A Mixed Integer (linear) Programming problem. More...
class	Multiplication_Floating_Point_Expression
	A generic Multiplication Floating Point Expression. More...
class	NNC_Polyhedron
	A not necessarily closed convex polyhedron. More...
class	Numeric_Format
class	Octagonal_Shape_Helper
class	Octagonal_Shape
	An octagonal shape. More...
class	Opposite_Floating_Point_Expression
	A generic Opposite Floating Point Expression. More...
class	OR_Matrix
	A matrix representing octagonal constraints. More...
class	Partial_Function
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	Congruences_Reduction
	This class provides the reduction method for the Congruences_Product domain. More...
class	Shape_Preserving_Reduction
	This class provides the reduction method for the Shape_Preserving_Product domain. More...
class	No_Reduction
	This class provides the reduction method for the Direct_Product domain. More...
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	PIP_Problem
	A Parametric Integer (linear) Programming problem. More...
class	PIP_Tree_Node
	A node of the PIP solution tree. More...
class	PIP_Solution_Node
	A tree node representing part of the space of solutions. More...
class	PIP_Decision_Node
	A tree node representing a decision in the space of solutions. More...
class	Pointset_Ask_Tell
	The ask-and-tell construction instantiated on PPL polyhedra. More...
class	Pointset_Powerset
	The powerset construction instantiated on PPL pointset domains. 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...
class	Polyhedron
	The base class for convex polyhedra. More...
class	Powerset
	The powerset construction on a base-level domain. More...
struct	Rational_Interval_Info_Policy
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...
struct	Slow_Copy
struct	Slow_Copy< mpz_class >
struct	Slow_Copy< mpq_class >
class	Sparse_Row
	A finite sparse sequence of coefficients. More...
class	stdiobuf
class	Sum_Floating_Point_Expression
	A generic Sum Floating Point Expression. More...
class	Swapping_Vector
class	Temp_Item
	A pool of temporary items of type `T`. More...
class	Temp_Reference_Holder
	An holder for a reference to a temporary object. More...
class	Temp_Value_Holder
	An (fake) holder for the value of a temporary object. More...
class	Dirty_Temp< T, typename Enable_If< Slow_Copy< T >::value >::type >
	Specialization for the handling of temporaries with a free list. More...
class	Dirty_Temp< T, typename Enable_If<!Slow_Copy< T >::value >::type >
	Specialization for the handling of temporaries with local variables. More...
class	Termination_Helpers
class	Threshold_Watcher
	A class of watchdogs controlling the exceeding of a threshold. More...
class	Variable
	A dimension of the vector space. More...
class	Variable_Floating_Point_Expression
	A generic Variable Floating Point Expression. More...
class	Variables_Set
	An std::set of variables' indexes. More...
struct	Watchdog_Traits
class	Watchdog
	A watchdog timer. More...
class	Weight_Profiler
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...
struct	WRD_Extended_Number_Policy
	The production policy for checked numbers used in weakly-relational domains. More...
struct	Debug_WRD_Extended_Number_Policy
	The debugging policy for checked numbers used in weakly-relational domains. More...
class	Concrete_Expression
	The base class of all concrete expressions. More...
class	Binary_Operator
	A binary operator applied to two concrete expressions. More...
class	Unary_Operator
	A unary operator applied to one concrete expression. More...
class	Cast_Operator
	A cast operator converting one concrete expression to some type. More...
class	Integer_Constant
	An integer constant concrete expression. More...
class	Floating_Point_Constant
	A floating-point constant concrete expression. More...
class	Approximable_Reference
	A concrete expression representing a reference to some approximable. More...
class	GMP_Integer
	Unbounded integers as provided by the GMP library. More...

Typedefs
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 int	Concrete_Expression_Kind
	Encodes the kind of concrete expression.
typedef int	Concrete_Expression_BOP
	Encodes a binary operator of concrete expressions.
typedef int	Concrete_Expression_UOP
	Encodes a unary operator of concrete expressions.
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.
typedef mpz_class	GMP_Integer
typedef Interval_Info_Bitset < unsigned int, Integer_Interval_Info_Policy >	Integer_Interval_Info
typedef Interval< mpz_class, Integer_Interval_Info >	Integer_Interval
	An interval with integral, necessarily closed boundaries.
typedef const PIP_Tree_Node *	PIP_Tree
typedef Box< Rational_Interval >	Rational_Box
	A box with rational, possibly open boundaries.
typedef Interval_Info_Bitset < unsigned int, Rational_Interval_Info_Policy >	Rational_Interval_Info
typedef Interval< mpq_class, Rational_Interval_Info >	Rational_Interval
	An interval with rational, possibly open boundaries.

Enumerations
enum	fpu_rounding_direction_type
enum	fpu_rounding_control_word_type
enum	Degenerate_Element { UNIVERSE, EMPTY }
	Kinds of degenerate abstract elements. More...
enum	Relation_Symbol { EQUAL, LESS_THAN, LESS_OR_EQUAL, GREATER_THAN, GREATER_OR_EQUAL, 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	Bounded_Integer_Type_Width { BITS_8, BITS_16, BITS_32, BITS_64, BITS_128 }
	Widths of bounded integer types. More...
enum	Bounded_Integer_Type_Representation { UNSIGNED, SIGNED_2_COMPLEMENT }
	Representation of bounded integer types. More...
enum	Bounded_Integer_Type_Overflow { OVERFLOW_WRAPS, OVERFLOW_UNDEFINED, OVERFLOW_IMPOSSIBLE }
	Overflow behavior of bounded integer types. More...
enum	Representation { DENSE, SPARSE }
	Possible representations of coefficient sequences (i.e. linear expressions and more complex objects containing linear expressions, e.g. Constraints, Generators, etc.). More...
enum	Floating_Point_Format { IEEE754_HALF, IEEE754_SINGLE, IEEE754_DOUBLE, IEEE754_QUAD, INTEL_DOUBLE_EXTENDED, IBM_SINGLE, IBM_DOUBLE }
	Floating point formats known to the library. More...
enum	Ternary { T_YES, T_NO, T_MAYBE }
enum	I_Result { I_EMPTY, I_SINGLETON, I_SOME, I_UNIVERSE, I_NOT_EMPTY, I_ANY, I_NOT_UNIVERSE, I_NOT_DEGENERATE, I_EXACT, I_INEXACT, I_CHANGED, I_UNCHANGED, I_SINGULARITIES }
	The result of an operation on intervals. More...
enum	MIP_Problem_Status { UNFEASIBLE_MIP_PROBLEM, UNBOUNDED_MIP_PROBLEM, OPTIMIZED_MIP_PROBLEM }
	Possible outcomes of the MIP_Problem solver. More...
enum	PIP_Problem_Status { UNFEASIBLE_PIP_PROBLEM, OPTIMIZED_PIP_PROBLEM }
	Possible outcomes of the PIP_Problem solver. More...
enum	Result_Class { VC_NORMAL, VC_MINUS_INFINITY, VC_PLUS_INFINITY, VC_NAN, VC_MASK = VC_NAN }
enum	Result_Relation { VR_EMPTY, VR_EQ, VR_LT, VR_GT, VR_NE, VR_LE, VR_GE, VR_LGE, VR_MASK = VR_LGE }
enum	Result { V_EMPTY, V_EQ, V_LT, V_GT, V_NE, V_LE, V_GE, V_LGE, V_OVERFLOW, V_LT_INF, V_GT_SUP, V_LT_PLUS_INFINITY, V_GT_MINUS_INFINITY, V_EQ_MINUS_INFINITY, V_EQ_PLUS_INFINITY, V_NAN, V_CVT_STR_UNK, V_DIV_ZERO, V_INF_ADD_INF, V_INF_DIV_INF, V_INF_MOD, V_INF_MUL_ZERO, V_INF_SUB_INF, V_MOD_ZERO, V_SQRT_NEG, V_UNKNOWN_NEG_OVERFLOW, V_UNKNOWN_POS_OVERFLOW, V_UNREPRESENTABLE }
	Possible outcomes of a checked arithmetic computation. More...
enum	Rounding_Dir { ROUND_DOWN, ROUND_UP, ROUND_IGNORE, ROUND_NATIVE = ROUND_IGNORE, ROUND_NOT_NEEDED, ROUND_DIRECT = ROUND_UP, ROUND_INVERSE = ROUND_DOWN, ROUND_DIR_MASK = 7U, ROUND_STRICT_RELATION, ROUND_CHECK = ROUND_DIRECT \| ROUND_STRICT_RELATION }
	Rounding directions for arithmetic computations. More...
enum	Topology { NECESSARILY_CLOSED = 0, NOT_NECESSARILY_CLOSED = 1 }
	Kinds of polyhedra domains. More...

Functions
void	ppl_unreachable () PPL_WEAK_NORETURN
	Helper function causing program termination by calling `abort`.
void	ppl_unreachable_msg (const char msg, const char file, unsigned int line, const char *function) PPL_WEAK_NORETURN
	Helper function printing message on `std::cerr` and causing program termination by calling `abort`.
void	ppl_assertion_failed (const char assertion_text, const char file, unsigned int line, const char *function) PPL_WEAK_NORETURN
	Helper function printing an assertion failure message on `std::cerr` and causing program termination by calling `abort`.
template<typename T >
bool	copy_contains (T x_copy, T y_copy)
	Returns `true` if and only if `x_copy` contains `y_copy`.
template<typename T >
Enable_If< Has_Assign_Or_Swap < T >::value, void >::type	assign_or_swap (T &to, T &from)
template<typename ITV >
Poly_Con_Relation	interval_relation (const ITV &i, const Constraint::Type constraint_type, Coefficient_traits::const_reference numer, Coefficient_traits::const_reference denom=1)
	Returns the relations holding between an interval and an interval constraint.
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)
unsigned	irrational_precision ()
	Returns the precision parameter used for irrational calculations.
void	set_irrational_precision (const unsigned p)
	Sets the precision parameter used for irrational calculations.
void	throw_result_exception (Result r)
template<typename T >
T	plus_infinity ()
template<typename T >
T	minus_infinity ()
template<typename T >
T	not_a_number ()
template<typename T >
void	maybe_reset_fpu_inexact ()
template<typename T >
int	maybe_check_fpu_inexact ()
Rounding_Dir	rounding_dir (Rounding_Dir dir)
Result	check_result (Result r, Rounding_Dir dir)
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	infinity_sign (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)
template<typename T >
Enable_If < Is_Native_Or_Checked< T > ::value, void >::type	ascii_dump (std::ostream &s, const T &t)
template<typename T >
Enable_If < Is_Native_Or_Checked< T > ::value, bool >::type	ascii_load (std::istream &s, T &t)
void	swap (CO_Tree &x, CO_Tree &y)
void	swap (CO_Tree::const_iterator &x, CO_Tree::const_iterator &y)
void	swap (CO_Tree::iterator &x, CO_Tree::iterator &y)
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.
template<typename T >
void	PPL_CC_FLUSH (const T &x)
	No-op function that force the compiler to store the argument and to reread it from memory if needed (thus preventing CSE).
unsigned int	clz32 (uint32_t w)
unsigned int	clz64 (uint64_t w)
unsigned int	ctz32 (uint32_t w)
unsigned int	ctz64 (uint64_t w)
unsigned int	clz (unsigned int u)
unsigned int	clz (unsigned long ul)
unsigned int	clz (unsigned long long ull)
unsigned int	ctz (unsigned int u)
unsigned int	ctz (unsigned long ul)
unsigned int	ctz (unsigned long long ull)
bool	operator== (const Constraint_System &x, const Constraint_System &y)
bool	operator!= (const Constraint_System &x, const Constraint_System &y)
void	linear_combine (Dense_Row &x, const Dense_Row &y, Coefficient_traits::const_reference coeff1, Coefficient_traits::const_reference coeff2)
void	linear_combine (Dense_Row &x, const Dense_Row &y, Coefficient_traits::const_reference c1, Coefficient_traits::const_reference c2, dimension_type start, dimension_type end)
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.
unsigned int	msb_position (unsigned long long v)
	If `v` is nonzero, returns the position of the most significant bit in `a`.
bool	is_less_precise_than (Floating_Point_Format f1, Floating_Point_Format f2)
template<typename FP_Interval_Type >
void	affine_form_image (std::map< dimension_type, Linear_Form< FP_Interval_Type > > &lf_store, const Variable var, const Linear_Form< FP_Interval_Type > &lf)
template<typename FP_Interval_Type >
const FP_Interval_Type &	compute_absolute_error (const Floating_Point_Format analyzed_format)
template<typename FP_Interval_Type >
void	discard_occurrences (std::map< dimension_type, Linear_Form< FP_Interval_Type > > &lf_store, Variable var)
template<typename FP_Interval_Type >
void	upper_bound_assign (std::map< dimension_type, Linear_Form< FP_Interval_Type > > &ls1, const std::map< dimension_type, Linear_Form< FP_Interval_Type > > &ls2)
int	fpu_get_control ()
void	fpu_set_control (int c)
int	fpu_get_status ()
void	fpu_clear_status (unsigned short bits)
void	fpu_clear_exceptions ()
void	fpu_set_rounding_direction (int)
int	fpu_save_rounding_direction (int)
void	fpu_restore_rounding_direction (int)
bool	operator== (const Generator_System &x, const Generator_System &y)
bool	operator!= (const Generator_System &x, const Generator_System &y)
dimension_type	check_space_dimension_overflow (const dimension_type dim, const dimension_type max, const char domain, const char method, const char *reason)
dimension_type	not_a_dimension ()
	Returns a value that does not designate a valid dimension.
int32_t	hash_code_from_dimension (dimension_type dim)
	Returns the hash code for space dimension `dim`.
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.
bool	is_space (char c)
	Returns `true` if `c` is any kind of space character.
template<typename T >
Enable_If< Has_OK< T >::value, bool >::type	f_OK (const T &to)
void	ascii_dump (std::ostream &s, Representation r)
bool	ascii_load (std::istream &s, Representation &r)
template<typename RA_Container >
RA_Container::iterator	nth_iter (RA_Container &cont, dimension_type n)
template<typename RA_Container >
RA_Container::const_iterator	nth_iter (const RA_Container &cont, dimension_type n)
dimension_type	least_significant_one_mask (dimension_type i)
void	maybe_abandon ()
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	mul_2exp_assign (GMP_Integer &x, const GMP_Integer &y, unsigned int exp)
void	div_2exp_assign (GMP_Integer &x, const GMP_Integer &y, unsigned int exp)
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	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.
I_Result	combine (Result l, Result u)
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	infinity_sign (const Interval< Boundary, Info > &x)
template<typename T >
Enable_If< Is_Singleton< T > ::value\|\|Is_Interval< T > ::value, bool >::type	is_singleton_integer (const T &x)
template<typename T >
Enable_If< Is_Singleton< T > ::value\|\|Is_Interval< T > ::value, bool >::type	check_empty_arg (const T &x)
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 Boundary , typename Info >
std::istream &	operator>> (std::istream &is, Interval< Boundary, Info > &x)
I_Result	operator\| (I_Result a, I_Result b)
I_Result	operator& (I_Result a, I_Result b)
I_Result	operator- (I_Result a, I_Result b)
template<typename T >
I_Constraint< T >	i_constraint (I_Constraint_Rel rel, const T &v)
template<typename T >
I_Constraint< T >	i_constraint (I_Constraint_Rel rel, const T &v, bool force)
template<typename T >
I_Constraint< T >	i_constraint (I_Constraint_Rel rel, T &v)
template<typename T , typename Val_Or_Ref_Criteria >
I_Constraint< T, Val_Or_Ref_Criteria >	i_constraint (I_Constraint_Rel rel, const T &v, const Val_Or_Ref_Criteria &)
template<typename T , typename Val_Or_Ref_Criteria >
I_Constraint< T, Val_Or_Ref_Criteria >	i_constraint (I_Constraint_Rel rel, const T &v, bool force, const Val_Or_Ref_Criteria &)
template<typename T , typename Val_Or_Ref_Criteria >
I_Constraint< T, Val_Or_Ref_Criteria >	i_constraint (I_Constraint_Rel rel, T &v, const Val_Or_Ref_Criteria &)
void	add_mul_assign (Linear_Expression &e1, Coefficient_traits::const_reference factor, const Linear_Expression &e2)
void	sub_mul_assign (Linear_Expression &e1, Coefficient_traits::const_reference factor, const Linear_Expression &e2)
int	compare (const Linear_Expression &x, const Linear_Expression &y)
template<typename T >
Enable_If < Is_Native_Or_Checked< T > ::value, void >::type	numer_denom (const T &from, Coefficient &numer, Coefficient &denom)
	Extract the numerator and denominator components of `from`.
template<typename T >
Enable_If < Is_Native_Or_Checked< T > ::value, void >::type	div_round_up (T &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 >
Enable_If < Is_Native_Or_Checked< T > ::value, bool >::type	is_even (const T &x)
	Returns `true` if and only if `x` is an even number.
template<typename T >
Enable_If < Is_Native_Or_Checked< T > ::value, bool >::type	is_additive_inverse (const T &x, const T &y)
	Returns `true` if and only if .
void	normalize2 (Coefficient_traits::const_reference x, Coefficient_traits::const_reference y, Coefficient &n_x, Coefficient &n_y)
	If is the GCD of `x` and `y`, the values of `x` and `y` divided by are assigned to `n_x` and `n_y`, respectively.
bool	is_canonical (const mpq_class &x)
	Returns `true` if and only if `x` is in canonical form.
template<typename T >
T	low_bits_mask (unsigned n)
	Returns a mask for the lowest `n` bits,.
template<typename Row >
void	swap (Matrix< Row > &x, Matrix< Row > &y)
dimension_type	max_space_dimension ()
	Returns the maximum space dimension this library can handle.
dimension_type	isqrt (dimension_type x)
	Returns the integer square root of `x`.
template<typename D1 , typename D2 >
bool	shrink_to_congruence_no_check (D1 &d1, D2 &d2, const Congruence &cg)
int	result_overflow (Result r)
bool	result_representable (Result r)
void	swap (Parma_Polyhedra_Library::Sparse_Row &x, Parma_Polyhedra_Library::Dense_Row &y)
void	swap (Parma_Polyhedra_Library::Dense_Row &x, Parma_Polyhedra_Library::Sparse_Row &y)
bool	operator== (const Dense_Row &x, const Sparse_Row &y)
bool	operator!= (const Dense_Row &x, const Sparse_Row &y)
bool	operator== (const Sparse_Row &x, const Dense_Row &y)
bool	operator!= (const Sparse_Row &x, const Dense_Row &y)
template<typename T >
void	swap (Swapping_Vector< T > &vec1, Swapping_Vector< T > &vec2)
void	swap (Variable &x, Variable &y)
void	PPL_handle_timeout (int signum)
Library Version Control 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.
Functions Controlling Floating Point Unit
void	fpu_initialize_control_functions ()
	Initializes the FPU control functions.
fpu_rounding_direction_type	fpu_get_rounding_direction ()
	Returns the current FPU rounding direction.
void	fpu_set_rounding_direction (fpu_rounding_direction_type dir)
	Sets the FPU rounding direction to `dir`.
fpu_rounding_control_word_type	fpu_save_rounding_direction (fpu_rounding_direction_type dir)
	Sets the FPU rounding direction to `dir` and returns the rounding control word previously in use.
void	fpu_reset_inexact ()
	Clears the inexact computation status.
void	fpu_restore_rounding_direction (fpu_rounding_control_word_type w)
	Restores the FPU rounding rounding control word to `cw`.
int	fpu_check_inexact ()
	Queries the inexact computation status.
fpu_rounding_control_word_type	fpu_save_rounding_direction_reset_inexact (fpu_rounding_direction_type dir)
	Sets the FPU rounding direction to `dir`, clears the inexact computation status, and returns the rounding control word previously in use.
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`.
Functions Inspecting and/or Combining Result Values
Result	operator& (Result x, Result y)
Result	operator\| (Result x, Result y)
Result	operator- (Result x, Result y)
Result_Class	result_class (Result r)
	Extracts the value class part of `r` (representable number, unrepresentable minus/plus infinity or nan).
Result_Relation	result_relation (Result r)
	Extracts the relation part of `r`.
Result	result_relation_class (Result r)
Functions Inspecting and/or Combining Rounding_Dir Values
Rounding_Dir	operator& (Rounding_Dir x, Rounding_Dir y)
Rounding_Dir	operator\| (Rounding_Dir x, Rounding_Dir y)
Rounding_Dir	inverse (Rounding_Dir dir)
	Returns the inverse rounding mode of `dir`, `ROUND_IGNORE` being the inverse of itself.
Rounding_Dir	round_dir (Rounding_Dir dir)
bool	round_down (Rounding_Dir dir)
bool	round_up (Rounding_Dir dir)
bool	round_ignore (Rounding_Dir dir)
bool	round_not_needed (Rounding_Dir dir)
bool	round_not_requested (Rounding_Dir dir)
bool	round_direct (Rounding_Dir dir)
bool	round_inverse (Rounding_Dir dir)
bool	round_strict_relation (Rounding_Dir dir)
fpu_rounding_direction_type	round_fpu_dir (Rounding_Dir dir)
Functions for the Synthesis of Linear Rankings
template<typename PSET >
bool	termination_test_MS (const PSET &pset)
	Termination test using an improvement of the method by Mesnard and Serebrenik [BMPZ10].
template<typename PSET >
bool	termination_test_MS_2 (const PSET &pset_before, const PSET &pset_after)
	Termination test using an improvement of the method by Mesnard and Serebrenik [BMPZ10].
template<typename PSET >
bool	one_affine_ranking_function_MS (const PSET &pset, Generator &mu)
	Termination test with witness ranking function using an improvement of the method by Mesnard and Serebrenik [BMPZ10].
template<typename PSET >
bool	one_affine_ranking_function_MS_2 (const PSET &pset_before, const PSET &pset_after, Generator &mu)
	Termination test with witness ranking function using an improvement of the method by Mesnard and Serebrenik [BMPZ10].
template<typename PSET >
void	all_affine_ranking_functions_MS (const PSET &pset, C_Polyhedron &mu_space)
	Termination test with ranking function space using an improvement of the method by Mesnard and Serebrenik [BMPZ10].
template<typename PSET >
void	all_affine_ranking_functions_MS_2 (const PSET &pset_before, const PSET &pset_after, C_Polyhedron &mu_space)
	Termination test with ranking function space using an improvement of the method by Mesnard and Serebrenik [BMPZ10].
template<typename PSET >
void	all_affine_quasi_ranking_functions_MS (const PSET &pset, C_Polyhedron &decreasing_mu_space, C_Polyhedron &bounded_mu_space)
	Computes the spaces of affine quasi ranking functions using an improvement of the method by Mesnard and Serebrenik [BMPZ10].
template<typename PSET >
void	all_affine_quasi_ranking_functions_MS_2 (const PSET &pset_before, const PSET &pset_after, C_Polyhedron &decreasing_mu_space, C_Polyhedron &bounded_mu_space)
	Computes the spaces of affine quasi ranking functions using an improvement of the method by Mesnard and Serebrenik [BMPZ10].
template<typename PSET >
bool	termination_test_PR (const PSET &pset)
	Like termination_test_MS() but using the method by Podelski and Rybalchenko [BMPZ10].
template<typename PSET >
bool	termination_test_PR_2 (const PSET &pset_before, const PSET &pset_after)
	Like termination_test_MS_2() but using an alternative formalization of the method by Podelski and Rybalchenko [BMPZ10].
template<typename PSET >
bool	one_affine_ranking_function_PR (const PSET &pset, Generator &mu)
	Like one_affine_ranking_function_MS() but using the method by Podelski and Rybalchenko [BMPZ10].
template<typename PSET >
bool	one_affine_ranking_function_PR_2 (const PSET &pset_before, const PSET &pset_after, Generator &mu)
	Like one_affine_ranking_function_MS_2() but using an alternative formalization of the method by Podelski and Rybalchenko [BMPZ10].
template<typename PSET >
void	all_affine_ranking_functions_PR (const PSET &pset, NNC_Polyhedron &mu_space)
	Like all_affine_ranking_functions_MS() but using the method by Podelski and Rybalchenko [BMPZ10].
template<typename PSET >
void	all_affine_ranking_functions_PR_2 (const PSET &pset_before, const PSET &pset_after, NNC_Polyhedron &mu_space)
	Like all_affine_ranking_functions_MS_2() but using an alternative formalization of the method by Podelski and Rybalchenko [BMPZ10].

Variables
Minus_Infinity	MINUS_INFINITY
Plus_Infinity	PLUS_INFINITY
Not_A_Number	NOT_A_NUMBER
const Throwable *volatile	abandon_expensive_computations = 0
	A pointer to an exception object.
	Enable_If<(static_cast< Unsigned >-1) >

Detailed Description

The entire library is confined to this namespace.

Typedef Documentation

typedef int Parma_Polyhedra_Library::Concrete_Expression_BOP

Encodes a binary operator of concrete expressions.

The values should be uniquely defined by the particular instance and named: ADD, SUB, MUL, DIV, REM, BAND, BOR, BXOR, LSHIFT, RSHIFT.

Definition at line 86 of file Concrete_Expression.types.hh.

typedef int Parma_Polyhedra_Library::Concrete_Expression_Kind

Encodes the kind of concrete expression.

The values should be defined by the particular instance and uniquely identify one of: Binary_Operator, Unary_Operator, Cast_Operator, Integer_Constant, Floating_Point_Constant, or Approximable_Reference. For example, the Binary_Operator kind integer constant should be defined by an instance as the member Binary_Operator<T>::KIND

Definition at line 66 of file Concrete_Expression.types.hh.

typedef int Parma_Polyhedra_Library::Concrete_Expression_UOP

Encodes a unary operator of concrete expressions.

The values should be uniquely defined by the particular instance and named: PLUS, MINUS, BNOT.

Definition at line 94 of file Concrete_Expression.types.hh.

typedef mpz_class Parma_Polyhedra_Library::GMP_Integer

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

typedef Interval<mpz_class, Integer_Interval_Info> Parma_Polyhedra_Library::Integer_Interval

An interval with integral, necessarily closed boundaries.

Definition at line 49 of file Integer_Interval.hh.

typedef Interval_Info_Bitset<unsigned int, Integer_Interval_Info_Policy> Parma_Polyhedra_Library::Integer_Interval_Info

Definition at line 44 of file Integer_Interval.hh.

typedef const PIP_Tree_Node* Parma_Polyhedra_Library::PIP_Tree

Definition at line 20 of file PIP_Tree.types.hh.

typedef Box<Rational_Interval> Parma_Polyhedra_Library::Rational_Box

A box with rational, possibly open boundaries.

Definition at line 35 of file Rational_Box.hh.

typedef Interval<mpq_class, Rational_Interval_Info> Parma_Polyhedra_Library::Rational_Interval

An interval with rational, possibly open boundaries.

Definition at line 50 of file Rational_Interval.hh.

typedef Interval_Info_Bitset<unsigned int, Rational_Interval_Info_Policy> Parma_Polyhedra_Library::Rational_Interval_Info

Definition at line 45 of file Rational_Interval.hh.

Enumeration Type Documentation

enum Parma_Polyhedra_Library::fpu_rounding_control_word_type

Definition at line 23 of file fpu.types.hh.

{};

enum Parma_Polyhedra_Library::fpu_rounding_direction_type

Definition at line 22 of file fpu.types.hh.

{};

enum Parma_Polyhedra_Library::Result_Class

Enumerator:

VC_NORMAL	Representable number result class.
VC_MINUS_INFINITY	Negative infinity result class.
VC_PLUS_INFINITY	Positive infinity result class.
VC_NAN	Not a number result class.
VC_MASK

Definition at line 29 of file Result.defs.hh.

                  {
  VC_NORMAL = 0U << 4,
  VC_MINUS_INFINITY = 1U << 4,
  VC_PLUS_INFINITY = 2U << 4,
  VC_NAN = 3U << 4,
  VC_MASK = VC_NAN
};

enum Parma_Polyhedra_Library::Result_Relation

Enumerator:

VR_EMPTY	No values satisfies the relation.
VR_EQ	Equal. This need to be accompanied by a value.
VR_LT	Less than. This need to be accompanied by a value.
VR_GT	Greater than. This need to be accompanied by a value.
VR_NE	Not equal. This need to be accompanied by a value.
VR_LE	Less or equal. This need to be accompanied by a value.
VR_GE	Greater or equal. This need to be accompanied by a value.
VR_LGE	All values satisfy the relation.
VR_MASK

Definition at line 46 of file Result.defs.hh.

                     {
  VR_EMPTY = 0U,
  VR_EQ = 1U,
  VR_LT = 2U,
  VR_GT = 4U,
  VR_NE = VR_LT | VR_GT,
  VR_LE = VR_EQ | VR_LT,
  VR_GE = VR_EQ | VR_GT,
  VR_LGE = VR_LT | VR_EQ | VR_GT,
  VR_MASK = VR_LGE
};

enum Parma_Polyhedra_Library::Ternary

Enumerator:

T_YES
T_NO
T_MAYBE

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

{ T_YES, T_NO, T_MAYBE };

Function Documentation

void Parma_Polyhedra_Library::abs_assign ( GMP_Integer & x )

Referenced by Parma_Polyhedra_Library::MIP_Problem::compute_simplex_using_steepest_edge_float(), and Parma_Polyhedra_Library::MIP_Problem::get_exiting_base_index().

                           {
  mpz_abs(x.get_mpz_t(), x.get_mpz_t());
}

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

                                                 {
  mpz_abs(x.get_mpz_t(), y.get_mpz_t());
}

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

                                                                           {
  mpz_addmul(x.get_mpz_t(), y.get_mpz_t(), z.get_mpz_t());
}

void Parma_Polyhedra_Library::add_mul_assign	(	Linear_Expression &	e1,
		Coefficient_traits::const_reference	factor,
		const Linear_Expression &	e2
	)

References Parma_Polyhedra_Library::Linear_Expression_Interface::add_mul_assign(), and Parma_Polyhedra_Library::Linear_Expression::impl.

                                                 {
  e1.impl->add_mul_assign(factor, *e2.impl);
}

template<typename FP_Interval_Type >

void Parma_Polyhedra_Library::affine_form_image	(	std::map< dimension_type, Linear_Form< FP_Interval_Type > > &	lf_store,
		const Variable	var,
		const Linear_Form< FP_Interval_Type > &	lf
	)

References discard_occurrences(), and Parma_Polyhedra_Library::Variable::id().

                                                           {
  // Assign the new linear form for var.
  lf_store[var.id()] = lf;
  // Now invalidate all linear forms in which var occurs.
  discard_occurrences(lf_store, var);
}

template<typename T >

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

                                      {
  if (std::numeric_limits<T>::is_exact)
    // An exact data type: pretty printer is accurate.
    s << t;
  else {
    // An inexact data type (probably floating point):
    // first dump its hexadecimal representation ...
    const std::ios::fmtflags old_flags = s.setf(std::ios::hex,
                                                std::ios::basefield);
    const unsigned char* p = reinterpret_cast<const unsigned char*>(&t);
    for (unsigned i = 0; i < sizeof(T); ++i) {
      s << std::setw(2) << std::setfill('0') << static_cast<unsigned>(p[i]);
    }
    s.flags(old_flags);
    // ... and then pretty print it for readability.
    s << " (" << t << ")";
  }
}

void Parma_Polyhedra_Library::ascii_dump	(	std::ostream &	s,
		Representation	r
	)

inline

Definition at line 140 of file globals.inlines.hh.

References DENSE.

                                            {
  if (r == DENSE)
    s << "DENSE";
  else
    s << "SPARSE";
}

template<typename T >

Enable_If<Is_Native_Or_Checked<T>::value, bool>::type Parma_Polyhedra_Library::ascii_load	(	std::istream &	s,
		T &	t
	)

Definition at line 56 of file Checked_Number.templates.hh.

References PPL_ASSERT.

Referenced by Parma_Polyhedra_Library::Congruence_System::ascii_load(), Parma_Polyhedra_Library::Matrix< Row >::ascii_load(), Parma_Polyhedra_Library::Linear_System< Row >::ascii_load(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::ascii_load().

                                {
  if (std::numeric_limits<T>::is_exact) {
    // An exact data type: input from pretty printed version is accurate.
    s >> t;
    return !s.fail();
  }
  else {
    // An inexact data type (probably floating point):
    // first load its hexadecimal representation ...
    std::string str;
    if (!(s >> str) || str.size() != 2*sizeof(T))
      return false;
    unsigned char* p = reinterpret_cast<unsigned char*>(&t);
    // CHECKME: any (portable) simpler way?
    for (unsigned i = 0; i < sizeof(T); ++i) {
      unsigned byte_value = 0;
      for (unsigned j = 0; j < 2; ++j) {
        byte_value <<= 4;
        unsigned half_byte_value;
        // Interpret single hex character.
        switch (str[2*i + j]) {
        case '0':
          half_byte_value = 0;
          break;
        case '1':
          half_byte_value = 1;
          break;
        case '2':
          half_byte_value = 2;
          break;
        case '3':
          half_byte_value = 3;
          break;
        case '4':
          half_byte_value = 4;
          break;
        case '5':
          half_byte_value = 5;
          break;
        case '6':
          half_byte_value = 6;
          break;
        case '7':
          half_byte_value = 7;
          break;
        case '8':
          half_byte_value = 8;
          break;
        case '9':
          half_byte_value = 9;
          break;
        case 'A':
        case 'a':
          half_byte_value = 10;
          break;
        case 'B':
        case 'b':
          half_byte_value = 11;
          break;
        case 'C':
        case 'c':
          half_byte_value = 12;
          break;
        case 'D':
        case 'd':
          half_byte_value = 13;
          break;
        case 'E':
        case 'e':
          half_byte_value = 14;
          break;
        case 'F':
        case 'f':
          half_byte_value = 15;
          break;
        default:
          return false;
        }
        byte_value += half_byte_value;
      }
      PPL_ASSERT(byte_value <= 255);
      p[i] = static_cast<unsigned char>(byte_value);
    }
    // ... then read and discard pretty printed value.
    if (!(s >> str))
      return false;
    const std::string::size_type sz = str.size();
    return sz > 2 && str[0] == '(' && str[sz-1] == ')';
  }
}

bool Parma_Polyhedra_Library::ascii_load	(	std::istream &	s,
		Representation &	r
	)

inline

Definition at line 148 of file globals.inlines.hh.

References DENSE, and SPARSE.

                                              {
  std::string s;
  if (!(is >> s))
    return false;
  if (s == "DENSE")  {
    r = DENSE;
    return true;
  }
  if (s == "SPARSE")  {
    r = SPARSE;
    return true;
  }
  return false;
}

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
	)

References check_result(), raw_value(), and rounding_dir().

                                                {
  return check_result(Checked::assign_special<typename Native_Checked_To_Wrapper<To>
                      ::Policy>(Native_Checked_To_Wrapper<To>::raw_value(to),
                                From::vclass,
                                rounding_dir(dir)),
                      dir);
}

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 106 of file version.cc.

            {
  return banner_string;
}

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

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

References Parma_Polyhedra_Library::Interval_NS::f_info(), f_is_empty(), and PPL_ASSERT.

                            {
  if (f_info(x).may_be_empty)
    return f_is_empty(x);
  else {
    PPL_ASSERT(!f_is_empty(x));
    return false;
  }
}

Result Parma_Polyhedra_Library::check_result	(	Result	r,
		Rounding_Dir	dir
	)

inline

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

References PPL_ASSERT, result_relation(), ROUND_NOT_NEEDED, and VR_EQ.

Referenced by assign_r(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::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().

                                         {
  if (dir == ROUND_NOT_NEEDED) {
#ifdef DEBUG_ROUND_NOT_NEEDED
    PPL_ASSERT(result_relation(r) == VR_EQ);
#endif
    return r;
  }
  return r;
}

dimension_type Parma_Polyhedra_Library::check_space_dimension_overflow	(	const dimension_type	dim,
		const dimension_type	max,
		const char *	domain,
		const char *	method,
		const char *	reason
	)

Definition at line 45 of file globals.cc.

                                                   {
  if (dim > max) {
    std::ostringstream s;
    s << domain << method << ":" << std::endl
      << reason << ".";
    throw std::length_error(s.str());
  }
  return dim;
}

unsigned int Parma_Polyhedra_Library::clz ( unsigned int u )

inline

Definition at line 138 of file compiler.hh.

References clz32(), and clz64().

Referenced by Parma_Polyhedra_Library::Implementation::last_one(), and msb_position().

                    {
  assert(u != 0);
#if defined(__GNUC__)
  return static_cast<unsigned int>(__builtin_clz(u));
#elif PPL_SIZEOF_INT == 4
  return clz32(u);
#elif PPL_SIZEOF_INT == 8
  return clz64(u);
#else
  #error "Unsupported unsigned int size"
#endif
}

unsigned int Parma_Polyhedra_Library::clz ( unsigned long ul )

inline

Definition at line 152 of file compiler.hh.

References clz32(), and clz64().

                      {
  assert(ul != 0);
#if defined(__GNUC__)
  return static_cast<unsigned int>(__builtin_clzl(ul));
#elif PPL_SIZEOF_LONG == 4
  return clz32(ul);
#elif PPL_SIZEOF_LONG == 8
  return clz64(ul);
#else
  #error "Unsupported unsigned long size"
#endif
}

unsigned int Parma_Polyhedra_Library::clz ( unsigned long long ull )

inline

Definition at line 166 of file compiler.hh.

References clz32(), and clz64().

                            {
  assert(ull != 0);
#if defined(__GNUC__)
  return static_cast<unsigned int>(__builtin_clzll(ull));
#elif PPL_SIZEOF_LONG_LONG == 4
  return clz32(ull);
#elif PPL_SIZEOF_LONG_LONG == 8
  return clz64(ull);
#else
  #error "Unsupported unsigned long long size"
#endif
}

unsigned int Parma_Polyhedra_Library::clz32 ( uint32_t w )

inline

Definition at line 86 of file compiler.hh.

Referenced by clz(), and clz64().

                  {
  unsigned int r = 31;
  if ((w & 0xffff0000U) != 0) {
    w >>= 16;
    r -= 16;
  }
  if ((w & 0xff00U) != 0) {
    w >>= 8;
    r -= 8;
  }
  if ((w & 0xf0U) != 0) {
    w >>= 4;
    r -= 4;
  }
  if ((w & 0xcU) != 0) {
    w >>= 2;
    r -= 2;
  }
  if ((w & 0x2U) != 0)
    r -= 1;
  return r;
}

unsigned int Parma_Polyhedra_Library::clz64 ( uint64_t w )

inline

Definition at line 110 of file compiler.hh.

References clz32().

Referenced by clz().

                  {
  if ((w & 0xffffffff00000000ULL) == 0)
    return clz32(static_cast<uint32_t>(w)) + 32;
  else
    return clz32(static_cast<uint32_t>(w >> 32));
}

int Parma_Polyhedra_Library::cmp	(	const GMP_Integer &	x,
		const GMP_Integer &	y
	)

Referenced by Parma_Polyhedra_Library::Polyhedron::add_and_minimize(), Parma_Polyhedra_Library::Checked::cmp_mp(), Parma_Polyhedra_Library::Linear_Expression_Impl< Row >::compare(), and Parma_Polyhedra_Library::Linear_System< Row >::sort_pending_and_remove_duplicates().

                                                {
  return mpz_cmp(x.get_mpz_t(), y.get_mpz_t());
}

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.

Coefficient_traits::const_reference Parma_Polyhedra_Library::Coefficient_zero ( )

Returns a const reference to a Coefficient with value 0.

I_Result Parma_Polyhedra_Library::combine	(	Result	l,
		Result	u
	)

inline

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

                            {
  unsigned res = static_cast<unsigned>(l) | (static_cast<unsigned>(u) << 6);
  return static_cast<I_Result>(res);
}

int Parma_Polyhedra_Library::compare	(	const Linear_Expression &	x,
		const Linear_Expression &	y
	)

References Parma_Polyhedra_Library::Linear_Expression_Interface::compare(), and Parma_Polyhedra_Library::Linear_Expression::impl.

                                                                {
  return x.impl->compare(*y.impl);
}

template<typename FP_Interval_Type >

const FP_Interval_Type& Parma_Polyhedra_Library::compute_absolute_error ( const Floating_Point_Format analyzed_format )

                                                                     {
  typedef typename FP_Interval_Type::boundary_type analyzer_format;
  // FIXME: check if initializing caches with EMPTY is better.
  static const FP_Interval_Type ZERO_INTERVAL = FP_Interval_Type(0);
  // Cached results for each different analyzed format.
  static FP_Interval_Type ieee754_half_result = ZERO_INTERVAL;
  static FP_Interval_Type ieee754_single_result = ZERO_INTERVAL;
  static FP_Interval_Type ieee754_double_result = ZERO_INTERVAL;
  static FP_Interval_Type ibm_single_result = ZERO_INTERVAL;
  static FP_Interval_Type ieee754_quad_result = ZERO_INTERVAL;
  static FP_Interval_Type intel_double_extended_result = ZERO_INTERVAL;
  FP_Interval_Type* to_compute = NULL;
  // Get the necessary information on the analyzed's format.
  unsigned int f_base;
  int f_exponent_bias;
  unsigned int f_mantissa_bits;
  switch (analyzed_format) {
    case IEEE754_HALF:
      if (ieee754_half_result != ZERO_INTERVAL)
        return ieee754_half_result;
      to_compute = &ieee754_half_result;
      f_base = float_ieee754_half::BASE;
      f_exponent_bias = float_ieee754_half::EXPONENT_BIAS;
      f_mantissa_bits = float_ieee754_half::MANTISSA_BITS;
      break;
    case IEEE754_SINGLE:
      if (ieee754_single_result != ZERO_INTERVAL)
        return ieee754_single_result;
      to_compute = &ieee754_single_result;
      f_base = float_ieee754_single::BASE;
      f_exponent_bias = float_ieee754_single::EXPONENT_BIAS;
      f_mantissa_bits = float_ieee754_single::MANTISSA_BITS;
      break;
    case IEEE754_DOUBLE:
      if (ieee754_double_result != ZERO_INTERVAL)
        return ieee754_double_result;
      to_compute = &ieee754_double_result;
      f_base = float_ieee754_double::BASE;
      f_exponent_bias = float_ieee754_double::EXPONENT_BIAS;
      f_mantissa_bits = float_ieee754_double::MANTISSA_BITS;
      break;
    case IBM_SINGLE:
      if (ibm_single_result != ZERO_INTERVAL)
        return ibm_single_result;
      to_compute = &ibm_single_result;
      f_base = float_ibm_single::BASE;
      f_exponent_bias = float_ibm_single::EXPONENT_BIAS;
      f_mantissa_bits = float_ibm_single::MANTISSA_BITS;
      break;
    case IEEE754_QUAD:
      if (ieee754_quad_result != ZERO_INTERVAL)
        return ieee754_quad_result;
      to_compute = &ieee754_quad_result;
      f_base = float_ieee754_quad::BASE;
      f_exponent_bias = float_ieee754_quad::EXPONENT_BIAS;
      f_mantissa_bits = float_ieee754_quad::MANTISSA_BITS;
      break;
    case INTEL_DOUBLE_EXTENDED:
      if (intel_double_extended_result != ZERO_INTERVAL)
        return intel_double_extended_result;
      to_compute = &intel_double_extended_result;
      f_base = float_intel_double_extended::BASE;
      f_exponent_bias = float_intel_double_extended::EXPONENT_BIAS;
      f_mantissa_bits = float_intel_double_extended::MANTISSA_BITS;
      break;
    default:
      PPL_UNREACHABLE;
      break;
  }
  PPL_ASSERT(to_compute != NULL);
  // We assume that f_base is a power of 2.
  analyzer_format omega;
  int power = static_cast<int>(msb_position(f_base))
    * ((1 - f_exponent_bias) - static_cast<int>(f_mantissa_bits));
  omega = std::max(static_cast<analyzer_format>(ldexp(1.0, power)),
                   std::numeric_limits<analyzer_format>::denorm_min());
  to_compute->build(i_constraint(GREATER_OR_EQUAL, -omega),
                    i_constraint(LESS_OR_EQUAL, omega));
  return *to_compute;
}

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 90 of file globals.inlines.hh.

                                                    {
  assert(requested_size <= maximum_size);
  // Speculation factor 2.
  return (requested_size < maximum_size/2)
    ? (2*(requested_size + 1))
    : maximum_size;
  // Speculation factor 1.5.
  // return (maximum_size - requested_size > requested_size/2)
  //   ? requested_size + requested_size/2 + 1
  //   : maximum_size;
}

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
	)

References check_result(), raw_value(), and rounding_dir().

Referenced by Parma_Polyhedra_Library::DB_Row< T >::construct(), Parma_Polyhedra_Library::Linear_Expression_Impl< Row >::construct(), Parma_Polyhedra_Library::DB_Row_Impl_Handler< T >::Impl::construct_upward_approximation(), Parma_Polyhedra_Library::DB_Matrix< T >::DB_Matrix(), Parma_Polyhedra_Library::DB_Row< T >::DB_Row(), Parma_Polyhedra_Library::DB_Matrix< T >::grow(), Parma_Polyhedra_Library::Linear_Expression_Impl< Row >::Linear_Expression_Impl(), and Parma_Polyhedra_Library::DB_Matrix< T >::resize_no_copy().

                                                 {
  return check_result(Checked::construct_special<typename Native_Checked_To_Wrapper<To>
                      ::Policy>(Native_Checked_To_Wrapper<To>::raw_value(to),
                                From::vclass,
                                rounding_dir(dir)),
                      dir);
}

template<typename T >

bool Parma_Polyhedra_Library::copy_contains	(	T	x_copy,
		T	y_copy
	)

Returns true if and only if x_copy contains y_copy.

Note:: This is a helper function for debugging purposes, to be used in assertions. The two arguments are meant to be passed by value, i.e., copied, so that their representations will not be affected by the containment check.

Definition at line 144 of file assert.hh.

                                       {
  return x_copy.contains(y_copy);
}

unsigned int Parma_Polyhedra_Library::ctz ( unsigned int u )

inline

Definition at line 181 of file compiler.hh.

References ctz32(), and ctz64().

Referenced by Parma_Polyhedra_Library::Implementation::first_one().

                    {
  assert(u != 0);
#if defined(__GNUC__)
  return static_cast<unsigned int>(__builtin_ctz(u));
#elif PPL_SIZEOF_INT == 4
  return ctz32(u);
#elif PPL_SIZEOF_INT == 8
  return ctz64(u);
#else
  #error "Unsupported unsigned int size"
#endif
}

unsigned int Parma_Polyhedra_Library::ctz ( unsigned long ul )

inline

Definition at line 195 of file compiler.hh.

References ctz32(), and ctz64().

                      {
  assert(ul != 0);
#if defined(__GNUC__)
  return static_cast<unsigned int>(__builtin_ctzl(ul));
#elif PPL_SIZEOF_LONG == 4
  return ctz32(ul);
#elif PPL_SIZEOF_LONG == 8
  return ctz64(ul);
#else
  #error "Unsupported unsigned long size"
#endif
}

unsigned int Parma_Polyhedra_Library::ctz ( unsigned long long ull )

inline

Definition at line 209 of file compiler.hh.

References ctz32(), and ctz64().

                            {
  assert(ull != 0);
#if defined(__GNUC__)
  return static_cast<unsigned int>(__builtin_ctzll(ull));
#elif PPL_SIZEOF_LONG_LONG == 4
  return ctz32(ull);
#elif PPL_SIZEOF_LONG_LONG == 8
  return ctz64(ull);
#else
  #error "Unsupported unsigned long long size"
#endif
}

unsigned int Parma_Polyhedra_Library::ctz32 ( uint32_t w )

inline

Definition at line 118 of file compiler.hh.

Referenced by ctz(), and ctz64().

                  {
  static const unsigned int mod37_table[] = {
    32, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28, 11, 0, 13,
    4, 7, 17, 0, 25, 22, 31, 15, 29, 10, 12, 6, 0, 21, 14, 9,
    5, 20, 8, 19, 18
  };
  return mod37_table[(w & -w) % 37];
}

unsigned int Parma_Polyhedra_Library::ctz64 ( uint64_t w )

inline

Definition at line 128 of file compiler.hh.

References ctz32().

Referenced by ctz().

                  {
  if ((w & 0x00000000ffffffffULL) == 0)
    return ctz32(static_cast<uint32_t>(w >> 32)) + 32;
  else
    return ctz32(static_cast<uint32_t>(w));
}

template<typename FP_Interval_Type >

void Parma_Polyhedra_Library::discard_occurrences	(	std::map< dimension_type, Linear_Form< FP_Interval_Type > > &	lf_store,
		Variable	var
	)

Referenced by affine_form_image().

                                  {
  typedef Linear_Form<FP_Interval_Type> FP_Linear_Form;
  typedef typename std::map<dimension_type, FP_Linear_Form>::iterator Iter;
  for (Iter i = lf_store.begin(); i != lf_store.end(); ) {
    if((i->second).coefficient(var) != 0)
      i = lf_store.erase(i);
    else
      ++i;
  }
}

void Parma_Polyhedra_Library::div_2exp_assign	(	GMP_Integer &	x,
		const GMP_Integer &	y,
		unsigned int	exp
	)

                                                                        {
  mpz_tdiv_q_2exp(x.get_mpz_t(), y.get_mpz_t(), exp);
}

template<typename T >

Enable_If< Is_Native_Or_Checked< T >::value, void >::type Parma_Polyhedra_Library::div_round_up	(	T &	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 65 of file math_utilities.inlines.hh.

References assign_r(), PPL_DIRTY_TEMP, ROUND_NOT_NEEDED, and ROUND_UP.

                                                  {
  PPL_DIRTY_TEMP(mpq_class, q_x);
  PPL_DIRTY_TEMP(mpq_class, q_y);
  // Note: this code assumes that a Coefficient is always convertible
  // to an mpq_class without loss of precision.
  assign_r(q_x, x, ROUND_NOT_NEEDED);
  assign_r(q_y, y, ROUND_NOT_NEEDED);
  div_assign_r(q_x, q_x, q_y, ROUND_NOT_NEEDED);
  assign_r(to, q_x, ROUND_UP);
}

void Parma_Polyhedra_Library::exact_div_assign	(	GMP_Integer &	x,
		const GMP_Integer &	y,
		const GMP_Integer &	z
	)

References PPL_ASSERT.

                                                                             {
  PPL_ASSERT(y % z == 0);
  mpz_divexact(x.get_mpz_t(), y.get_mpz_t(), z.get_mpz_t());
}

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
	)

References ROUND_NOT_NEEDED.

                                                     {
  Policy::handle_result(div_assign_r(x, y, z, ROUND_NOT_NEEDED));
}

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 106 of file globals.inlines.hh.

                                   {
  return 0;
}

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 118 of file globals.inlines.hh.

                                             {
  return static_cast<memory_size_type>(x.get_mpz_t()[0]._mp_alloc)
    * PPL_SIZEOF_MP_LIMB_T;
}

memory_size_type Parma_Polyhedra_Library::external_memory_in_bytes ( const mpq_class & x )

inline

Returns the size in bytes of the memory managed by x.

Definition at line 129 of file globals.inlines.hh.

References external_memory_in_bytes().

                                             {
  return external_memory_in_bytes(x.get_num())
    + external_memory_in_bytes(x.get_den());
}

template<typename Boundary , typename Info >

bool Parma_Polyhedra_Library::f_is_empty ( const Interval< Boundary, Info > & x )

inline

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

References Parma_Polyhedra_Library::Interval< Boundary, Info >::is_empty().

Referenced by check_empty_arg().

                                              {
  return x.is_empty();
}

template<typename Boundary , typename Info >

bool Parma_Polyhedra_Library::f_is_singleton ( const Interval< Boundary, Info > & x )

inline

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

References Parma_Polyhedra_Library::Interval< Boundary, Info >::is_singleton().

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_existential(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::refine_universal().

                                                  {
  return x.is_singleton();
}

template<typename T >

Enable_If<Has_OK<T>::value, bool>::type Parma_Polyhedra_Library::f_OK ( const T & to )

inline

Definition at line 449 of file globals.defs.hh.

                  {
  return to.OK();
}

void Parma_Polyhedra_Library::finalize ( )

inline

Finalizes the library.

Definition at line 52 of file initializer.hh.

References PPL_ASSERT.

Referenced by Parma_Polyhedra_Library::DB_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::Generator::l_m_distance_assign(), Parma_Polyhedra_Library::OR_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::Box< ITV >::l_m_distance_assign(), and Parma_Polyhedra_Library::Init::~Init().

           {
#ifdef PPL_NO_AUTOMATIC_INITIALIZATION
  PPL_ASSERT(Parma_Polyhedra_Library_initializer_p != 0);
  delete Parma_Polyhedra_Library_initializer_p;
  Parma_Polyhedra_Library_initializer_p = 0;
#endif
}

int Parma_Polyhedra_Library::fpu_check_inexact ( )

inline

Queries the inexact computation status.

Returns 0 if the computation was definitely exact, 1 if it was definitely inexact, -1 if definite exactness information is unavailable.

Definition at line 188 of file fpu-ia32.inlines.hh.

References fpu_get_status(), FPU_INEXACT, and SSE_INEXACT.

Referenced by maybe_check_fpu_inexact(), Parma_Polyhedra_Library::Checked::prepare_inexact(), and Parma_Polyhedra_Library::Checked::result_relation().

                    {
#ifdef PPL_FPMATH_MAY_USE_387
  if (fpu_get_status() & FPU_INEXACT)
    return 1;
#endif
#ifdef PPL_FPMATH_MAY_USE_SSE
  extern bool have_sse_unit;
  if (have_sse_unit && (sse_get_control() & SSE_INEXACT))
    return 1;
#endif
  return 0;
}

void Parma_Polyhedra_Library::fpu_clear_exceptions ( )

inline

Definition at line 105 of file fpu-ia32.inlines.hh.

Referenced by fpu_reset_inexact().

                       {
  __asm__ __volatile__ ("fnclex" : /* No outputs.  */ : : "memory");
}

void Parma_Polyhedra_Library::fpu_clear_status ( unsigned short bits )

inline

Definition at line 96 of file fpu-ia32.inlines.hh.

References Parma_Polyhedra_Library::ia32_fenv_t::status_word.

                                      {
  /* There is no fldsw instruction */
  ia32_fenv_t env;
  __asm__ __volatile__ ("fnstenv %0" : "=m" (env));
  env.status_word = static_cast<unsigned short>(env.status_word & ~bits);
  __asm__ __volatile__ ("fldenv %0" : : "m" (env) : "memory");
}

int Parma_Polyhedra_Library::fpu_get_control ( )

inline

Definition at line 76 of file fpu-ia32.inlines.hh.

Referenced by fpu_get_rounding_direction().

                  {
  unsigned short cw;
  __asm__ __volatile__ ("fnstcw %0" : "=m" (*&cw) : : "memory");
  return cw;
}

fpu_rounding_direction_type Parma_Polyhedra_Library::fpu_get_rounding_direction ( )

inline

Returns the current FPU rounding direction.

Definition at line 132 of file fpu-ia32.inlines.hh.

References fpu_get_control(), and FPU_ROUNDING_MASK.

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

                             {
  return static_cast<fpu_rounding_direction_type>(fpu_get_control() & FPU_ROUNDING_MASK);
}

int Parma_Polyhedra_Library::fpu_get_status ( )

inline

Definition at line 89 of file fpu-ia32.inlines.hh.

Referenced by fpu_check_inexact().

                 {
  unsigned short sw;
  __asm__ __volatile__ ("fnstsw %0" : "=a" (sw) : : "memory");
  return sw;
}

void Parma_Polyhedra_Library::fpu_initialize_control_functions ( )

inline

Initializes the FPU control functions.

Definition at line 124 of file fpu-ia32.inlines.hh.

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

                                   {
#ifdef PPL_FPMATH_MAY_USE_SSE
  extern void detect_sse_unit();
  detect_sse_unit();
#endif
}

void Parma_Polyhedra_Library::fpu_reset_inexact ( )

inline

Clears the inexact computation status.

Definition at line 162 of file fpu-ia32.inlines.hh.

References fpu_clear_exceptions(), and PPL_SSE_CONTROL_DEFAULT.

Referenced by maybe_reset_fpu_inexact(), and Parma_Polyhedra_Library::Checked::prepare_inexact().

                    {
#ifdef PPL_FPMATH_MAY_USE_387
  fpu_clear_exceptions();
#endif
#ifdef PPL_FPMATH_MAY_USE_SSE
  // NOTE: on entry to this function the current rounding mode
  // has to be the default one.
  extern bool have_sse_unit;
  if (have_sse_unit)
    sse_set_control(PPL_SSE_CONTROL_DEFAULT);
#endif
}

void Parma_Polyhedra_Library::fpu_restore_rounding_direction ( int )

inline

Definition at line 62 of file fpu-none.inlines.hh.

                                    {
  throw std::logic_error("PPL::fpu_restore_rounding_direction():"
                         " cannot control the FPU");
}

void Parma_Polyhedra_Library::fpu_restore_rounding_direction ( fpu_rounding_control_word_type )

inline

Restores the FPU rounding rounding control word to cw.

Definition at line 176 of file fpu-ia32.inlines.hh.

References fpu_set_control(), PPL_FPU_CONTROL_DEFAULT, and PPL_SSE_CONTROL_DEFAULT.

                                                               {
#ifdef PPL_FPMATH_MAY_USE_387
  fpu_set_control(PPL_FPU_CONTROL_DEFAULT);
#endif
#ifdef PPL_FPMATH_MAY_USE_SSE
  extern bool have_sse_unit;
  if (have_sse_unit)
    sse_set_control(PPL_SSE_CONTROL_DEFAULT);
#endif
}

int Parma_Polyhedra_Library::fpu_save_rounding_direction ( int )

inline

Definition at line 50 of file fpu-none.inlines.hh.

                                 {
  throw std::logic_error("PPL::fpu_save_rounding_direction():"
                         " cannot control the FPU");
}

fpu_rounding_control_word_type Parma_Polyhedra_Library::fpu_save_rounding_direction ( fpu_rounding_direction_type dir )

inline

Sets the FPU rounding direction to dir and returns the rounding control word previously in use.

Definition at line 149 of file fpu-ia32.inlines.hh.

References fpu_set_control(), PPL_FPU_CONTROL_DEFAULT_BASE, and PPL_SSE_CONTROL_DEFAULT_BASE.

                                                             {
#ifdef PPL_FPMATH_MAY_USE_387
  fpu_set_control(PPL_FPU_CONTROL_DEFAULT_BASE | dir);
#endif
#ifdef PPL_FPMATH_MAY_USE_SSE
  extern bool have_sse_unit;
  if (have_sse_unit)
    sse_set_control(PPL_SSE_CONTROL_DEFAULT_BASE | (dir << 3));
#endif
  return static_cast<fpu_rounding_control_word_type>(0);
}

fpu_rounding_control_word_type Parma_Polyhedra_Library::fpu_save_rounding_direction_reset_inexact ( fpu_rounding_direction_type dir )

Sets the FPU rounding direction to dir, clears the inexact computation status, and returns the rounding control word previously in use.

void Parma_Polyhedra_Library::fpu_set_control ( int c )

inline

Definition at line 83 of file fpu-ia32.inlines.hh.

References c.

Referenced by fpu_restore_rounding_direction(), fpu_save_rounding_direction(), and fpu_set_rounding_direction().

                       {
  unsigned short cw = static_cast<unsigned short>(c);
  __asm__ __volatile__ ("fldcw %0" : : "m" (*&cw) : "memory");
}

void Parma_Polyhedra_Library::fpu_set_rounding_direction ( int )

inline

Definition at line 44 of file fpu-none.inlines.hh.

                                {
  throw std::logic_error("PPL::fpu_set_rounding_direction():"
                         " cannot control the FPU");
}

void Parma_Polyhedra_Library::fpu_set_rounding_direction ( fpu_rounding_direction_type dir )

inline

Sets the FPU rounding direction to dir.

Definition at line 137 of file fpu-ia32.inlines.hh.

References fpu_set_control(), PPL_FPU_CONTROL_DEFAULT_BASE, and PPL_SSE_CONTROL_DEFAULT_BASE.

Referenced by Parma_Polyhedra_Library::Init::Init(), restore_pre_PPL_rounding(), set_rounding_for_PPL(), and Parma_Polyhedra_Library::Init::~Init().

                                                            {
#ifdef PPL_FPMATH_MAY_USE_387
  fpu_set_control(PPL_FPU_CONTROL_DEFAULT_BASE | dir);
#endif
#ifdef PPL_FPMATH_MAY_USE_SSE
  extern bool have_sse_unit;
  if (have_sse_unit)
    sse_set_control(PPL_SSE_CONTROL_DEFAULT_BASE | (dir << 3));
#endif
}

void Parma_Polyhedra_Library::gcd_assign	(	GMP_Integer &	x,
		const GMP_Integer &	y,
		const GMP_Integer &	z
	)

                                                                       {
  mpz_gcd(x.get_mpz_t(), y.get_mpz_t(), z.get_mpz_t());
}

void Parma_Polyhedra_Library::gcdext_assign	(	GMP_Integer &	x,
		GMP_Integer &	s,
		GMP_Integer &	t,
		const GMP_Integer &	y,
		const GMP_Integer &	z
	)

Referenced by Parma_Polyhedra_Library::Grid::reduce_pc_with_pc().

                                                          {
  mpz_gcdext(x.get_mpz_t(),
             s.get_mpz_t(), t.get_mpz_t(),
             y.get_mpz_t(), z.get_mpz_t());
}

int32_t Parma_Polyhedra_Library::hash_code_from_dimension ( dimension_type dim )

inline

Returns the hash code for space dimension dim.

Definition at line 43 of file globals.inlines.hh.

Referenced by Parma_Polyhedra_Library::Pointset_Ask_Tell< PSET >::hash_code(), Parma_Polyhedra_Library::Pointset_Powerset< PSET >::hash_code(), Parma_Polyhedra_Library::Partially_Reduced_Product< D1, D2, R >::hash_code(), Parma_Polyhedra_Library::Box< ITV >::hash_code(), Parma_Polyhedra_Library::Octagonal_Shape< T >::hash_code(), Parma_Polyhedra_Library::BD_Shape< T >::hash_code(), Parma_Polyhedra_Library::Grid::hash_code(), and Parma_Polyhedra_Library::Polyhedron::hash_code().

                                             {
  const dimension_type divisor = 1U << (32 - 1);
  dim = dim % divisor;
  return static_cast<int32_t>(dim);
}

template<typename T >

I_Constraint<T> Parma_Polyhedra_Library::i_constraint	(	I_Constraint_Rel	rel,
		const T &	v
	)

inline

Definition at line 436 of file intervals.defs.hh.

                                               {
  return I_Constraint<T>(rel, v);
}

template<typename T >

I_Constraint<T> Parma_Polyhedra_Library::i_constraint	(	I_Constraint_Rel	rel,
		const T &	v,
		bool	force
	)

inline

Definition at line 442 of file intervals.defs.hh.

                                                           {
  return I_Constraint<T>(rel, v, force);
}

template<typename T >

I_Constraint<T> Parma_Polyhedra_Library::i_constraint	(	I_Constraint_Rel	rel,
		T &	v
	)

inline

Definition at line 448 of file intervals.defs.hh.

                                         {
  return I_Constraint<T>(rel, v);
}

template<typename T , typename Val_Or_Ref_Criteria >

I_Constraint<T, Val_Or_Ref_Criteria> Parma_Polyhedra_Library::i_constraint	(	I_Constraint_Rel	rel,
		const T &	v,
		const Val_Or_Ref_Criteria &
	)

inline

Definition at line 454 of file intervals.defs.hh.

                                                                           {
  return I_Constraint<T, Val_Or_Ref_Criteria>(rel, v);
}

template<typename T , typename Val_Or_Ref_Criteria >

I_Constraint<T, Val_Or_Ref_Criteria> Parma_Polyhedra_Library::i_constraint	(	I_Constraint_Rel	rel,
		const T &	v,
		bool	force,
		const Val_Or_Ref_Criteria &
	)

inline

Definition at line 460 of file intervals.defs.hh.

                                         {
  return I_Constraint<T, Val_Or_Ref_Criteria>(rel, v, force);
}

template<typename T , typename Val_Or_Ref_Criteria >

I_Constraint<T, Val_Or_Ref_Criteria> Parma_Polyhedra_Library::i_constraint	(	I_Constraint_Rel	rel,
		T &	v,
		const Val_Or_Ref_Criteria &
	)

inline

Definition at line 467 of file intervals.defs.hh.

                                                                     {
  return I_Constraint<T, Val_Or_Ref_Criteria>(rel, v);
}

template<typename Boundary , typename Info >

int Parma_Polyhedra_Library::infinity_sign ( const Interval< Boundary, Info > & x )

inline

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

References Parma_Polyhedra_Library::Interval< Boundary, Info >::infinity_sign().

                                                 {
  return x.infinity_sign();
}

template<typename T >

Enable_If<Is_Native_Or_Checked<T>::value, int>::type Parma_Polyhedra_Library::infinity_sign ( const T & x )

References is_minus_infinity(), and is_plus_infinity().

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().

                          {
  return is_minus_infinity(x) ? -1 : (is_plus_infinity(x) ? 1 : 0);
}

void Parma_Polyhedra_Library::initialize ( )

inline

Initializes the library.

Definition at line 43 of file initializer.hh.

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

             {
#ifdef PPL_NO_AUTOMATIC_INITIALIZATION
  if (Parma_Polyhedra_Library_initializer_p == 0)
    Parma_Polyhedra_Library_initializer_p = new Init();
#endif
}

template<typename ITV >

Poly_Con_Relation Parma_Polyhedra_Library::interval_relation	(	const ITV &	i,
		const Constraint::Type	constraint_type,
		Coefficient_traits::const_reference	numer,
		Coefficient_traits::const_reference	denom = `1`
	)

Returns the relations holding between an interval and an interval constraint.

Parameters:

i	The interval;
constraint_type	The constraint type;
numer	The numerator of the constraint bound;
denom	The denominator of the constraint bound

The interval constraint has the form denom * Variable(0) relsym numer where relsym is ==, > or >= depending on the constraint_type.

Definition at line 614 of file Box.templates.hh.

Referenced by Parma_Polyhedra_Library::Box< ITV >::get_limiting_box(), and Parma_Polyhedra_Library::Box< ITV >::relation_with().

                                                           {
  if (i.is_universe())
    return Poly_Con_Relation::strictly_intersects();
  PPL_DIRTY_TEMP(mpq_class, bound);
  assign_r(bound.get_num(), numer, ROUND_NOT_NEEDED);
  assign_r(bound.get_den(), denom, ROUND_NOT_NEEDED);
  bound.canonicalize();
  neg_assign_r(bound, bound, ROUND_NOT_NEEDED);
  const bool is_lower_bound = (denom > 0);
  PPL_DIRTY_TEMP(mpq_class, bound_diff);
  if (constraint_type == Constraint::EQUALITY) {
    if (i.lower_is_boundary_infinity()) {
      PPL_ASSERT(!i.upper_is_boundary_infinity());
      assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED);
      sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
      switch (sgn(bound_diff)) {
      case 1:
        return Poly_Con_Relation::strictly_intersects();
      case 0:
        return i.upper_is_open()
          ? Poly_Con_Relation::is_disjoint()
          : Poly_Con_Relation::strictly_intersects();
      case -1:
        return Poly_Con_Relation::is_disjoint();
      }
    }
    else {
      assign_r(bound_diff, i.lower(), ROUND_NOT_NEEDED);
      sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
      switch (sgn(bound_diff)) {
      case 1:
        return Poly_Con_Relation::is_disjoint();
      case 0:
        if (i.lower_is_open())
          return Poly_Con_Relation::is_disjoint();
        if (i.is_singleton())
          return Poly_Con_Relation::is_included()
            && Poly_Con_Relation::saturates();
        return Poly_Con_Relation::strictly_intersects();
      case -1:
        if (i.upper_is_boundary_infinity())
          return Poly_Con_Relation::strictly_intersects();
        else {
          assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED);
          sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
          switch (sgn(bound_diff)) {
          case 1:
            return Poly_Con_Relation::strictly_intersects();
          case 0:
            if (i.upper_is_open())
              return Poly_Con_Relation::is_disjoint();
            else
              return Poly_Con_Relation::strictly_intersects();
          case -1:
            return Poly_Con_Relation::is_disjoint();
          }
        }
      }
    }
  }
  PPL_ASSERT(constraint_type != Constraint::EQUALITY);
  if (is_lower_bound) {
    if (i.lower_is_boundary_infinity()) {
      PPL_ASSERT(!i.upper_is_boundary_infinity());
      assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED);
      sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
      switch (sgn(bound_diff)) {
      case 1:
        return Poly_Con_Relation::strictly_intersects();
      case 0:
        if (constraint_type == Constraint::STRICT_INEQUALITY
            || i.upper_is_open())
          return Poly_Con_Relation::is_disjoint();
        else
          return Poly_Con_Relation::strictly_intersects();
      case -1:
        return Poly_Con_Relation::is_disjoint();
      }
    }
    else {
      assign_r(bound_diff, i.lower(), ROUND_NOT_NEEDED);
      sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
      switch (sgn(bound_diff)) {
      case 1:
        return Poly_Con_Relation::is_included();
      case 0:
        if (constraint_type == Constraint::NONSTRICT_INEQUALITY
            || i.lower_is_open()) {
          Poly_Con_Relation result = Poly_Con_Relation::is_included();
          if (i.is_singleton())
            result = result && Poly_Con_Relation::saturates();
          return result;
        }
        else {
          PPL_ASSERT(constraint_type == Constraint::STRICT_INEQUALITY
                 && !i.lower_is_open());
          if (i.is_singleton())
            return Poly_Con_Relation::is_disjoint()
              && Poly_Con_Relation::saturates();
          else
            return Poly_Con_Relation::strictly_intersects();
        }
      case -1:
        if (i.upper_is_boundary_infinity())
          return Poly_Con_Relation::strictly_intersects();
        else {
          assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED);
          sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
          switch (sgn(bound_diff)) {
          case 1:
            return Poly_Con_Relation::strictly_intersects();
          case 0:
            if (constraint_type == Constraint::STRICT_INEQUALITY
                || i.upper_is_open())
              return Poly_Con_Relation::is_disjoint();
            else
              return Poly_Con_Relation::strictly_intersects();
          case -1:
            return Poly_Con_Relation::is_disjoint();
          }
        }
      }
    }
  }
  else {
    // `c' is an upper bound.
    if (i.upper_is_boundary_infinity())
      return Poly_Con_Relation::strictly_intersects();
    else {
      assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED);
      sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
      switch (sgn(bound_diff)) {
      case -1:
        return Poly_Con_Relation::is_included();
      case 0:
        if (constraint_type == Constraint::NONSTRICT_INEQUALITY
            || i.upper_is_open()) {
          Poly_Con_Relation result = Poly_Con_Relation::is_included();
          if (i.is_singleton())
            result = result && Poly_Con_Relation::saturates();
          return result;
        }
        else {
          PPL_ASSERT(constraint_type == Constraint::STRICT_INEQUALITY
                 && !i.upper_is_open());
          if (i.is_singleton())
            return Poly_Con_Relation::is_disjoint()
              && Poly_Con_Relation::saturates();
          else
            return Poly_Con_Relation::strictly_intersects();
        }
      case 1:
        if (i.lower_is_boundary_infinity())
          return Poly_Con_Relation::strictly_intersects();
        else {
          assign_r(bound_diff, i.lower(), ROUND_NOT_NEEDED);
          sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
          switch (sgn(bound_diff)) {
          case -1:
            return Poly_Con_Relation::strictly_intersects();
          case 0:
            if (constraint_type == Constraint::STRICT_INEQUALITY
                || i.lower_is_open())
              return Poly_Con_Relation::is_disjoint();
            else
              return Poly_Con_Relation::strictly_intersects();
          case 1:
            return Poly_Con_Relation::is_disjoint();
          }
        }
      }
    }
  }
  // Quiet a compiler warning: this program point is unreachable.
  PPL_UNREACHABLE;
  return Poly_Con_Relation::nothing();
}

unsigned Parma_Polyhedra_Library::irrational_precision ( )

inline

Returns the precision parameter used for irrational calculations.

Definition at line 518 of file checked_mpq.inlines.hh.

References Parma_Polyhedra_Library::Checked::irrational_precision.

                       {
  return Checked::irrational_precision;
}

template<typename T >

Enable_If< Is_Native_Or_Checked< T >::value, bool >::type Parma_Polyhedra_Library::is_additive_inverse	(	const T &	x,
		const T &	y
	)

inline

Returns true if and only if $x = -y$ .

Definition at line 102 of file math_utilities.inlines.hh.

References ROUND_DIRECT, ROUND_STRICT_RELATION, and V_EQ.

                                            {
  T negated_x;
  return neg_assign_r(negated_x, x, ROUND_DIRECT | ROUND_STRICT_RELATION) == V_EQ
    && negated_x == y;
}

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.

References PPL_DIRTY_TEMP.

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

                                 {
  if (x.get_den() <= 0)
    return false;
  PPL_DIRTY_TEMP(mpq_class, temp);
  temp = x;
  temp.canonicalize();
  return temp.get_num() == x.get_num();
}

template<typename T >

Enable_If< Is_Native_Or_Checked< T >::value, bool >::type Parma_Polyhedra_Library::is_even ( const T & x )

inline

Returns true if and only if x is an even number.

Definition at line 94 of file math_utilities.inlines.hh.

References ROUND_DIRECT, ROUND_STRICT_RELATION, and V_EQ.

Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::drop_some_non_integer_points(), Parma_Polyhedra_Library::Octagonal_Shape< T >::tight_closure_assign(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::tight_coherence_would_make_empty().

                    {
  T mod;
  return umod_2exp_assign_r(mod, x, 1, ROUND_DIRECT | ROUND_STRICT_RELATION) == V_EQ
    && mod == 0;
}

template<typename T >

Enable_If<Is_Native_Or_Checked<T>::value, bool>::type Parma_Polyhedra_Library::is_integer ( const T & x )

References raw_value().

                       {
  return Checked::is_int<typename Native_Checked_From_Wrapper<T>
    ::Policy>(Native_Checked_From_Wrapper<T>::raw_value(x));
}

bool Parma_Polyhedra_Library::is_less_precise_than	(	Floating_Point_Format	f1,
		Floating_Point_Format	f2
	)

Referenced by Parma_Polyhedra_Library::Concrete_Expression::cast_linearize().

                                                                         {
  return f1 < f2;
}

template<typename T >

Enable_If<Is_Native_Or_Checked<T>::value, bool>::type Parma_Polyhedra_Library::is_minus_infinity ( const T & x )

References raw_value().

Referenced by Parma_Polyhedra_Library::DB_Matrix< T >::ascii_load(), Parma_Polyhedra_Library::OR_Matrix< T >::ascii_load(), infinity_sign(), numer_denom(), Parma_Polyhedra_Library::BD_Shape< T >::OK(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::OK().

                              {
  return Checked::is_minf<typename Native_Checked_From_Wrapper<T>
    ::Policy>(Native_Checked_From_Wrapper<T>::raw_value(x));
}

template<typename T , typename Policy >

bool Parma_Polyhedra_Library::is_minus_infinity ( const Checked_Number< T, Policy > & x )

inline

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

References Parma_Polyhedra_Library::Checked_Number< T, Policy >::raw_value().

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

template<typename T >

Enable_If<Is_Native_Or_Checked<T>::value, bool>::type Parma_Polyhedra_Library::is_not_a_number ( const T & x )

References raw_value().

Referenced by Parma_Polyhedra_Library::Interval_NS::f_is_empty(), numer_denom(), Parma_Polyhedra_Library::DB_Row< T >::OK(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::OK().

                            {
  return Checked::is_nan<typename Native_Checked_From_Wrapper<T>
    ::Policy>(Native_Checked_From_Wrapper<T>::raw_value(x));
}

template<typename T , typename Policy >

bool Parma_Polyhedra_Library::is_not_a_number ( const Checked_Number< T, Policy > & x )

inline

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

References Parma_Polyhedra_Library::Checked_Number< T, Policy >::raw_value().

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

template<typename T >

Enable_If<Is_Native_Or_Checked<T>::value, bool>::type Parma_Polyhedra_Library::is_plus_infinity ( const T & x )

References raw_value().

                             {
  return Checked::is_pinf<typename Native_Checked_From_Wrapper<T>
    ::Policy>(Native_Checked_From_Wrapper<T>::raw_value(x));
}

template<typename T , typename Policy >

bool Parma_Polyhedra_Library::is_plus_infinity ( const Checked_Number< T, Policy > & x )

inline

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

References Parma_Polyhedra_Library::Checked_Number< T, Policy >::raw_value().

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

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

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

References Parma_Polyhedra_Library::Interval_NS::f_lower(), and is_integer().

                                 {
  return is_singleton(x) && is_integer(f_lower(x));
}

bool Parma_Polyhedra_Library::is_space ( char c )

inline

Returns true if c is any kind of space character.

Definition at line 165 of file globals.inlines.hh.

Referenced by operator>>(), Parma_Polyhedra_Library::Checked::parse_number_part(), and Parma_Polyhedra_Library::IO_Operators::wrap_string().

                 {
  return isspace(c) != 0;
}

dimension_type Parma_Polyhedra_Library::isqrt ( dimension_type x )

inline

Returns the integer square root of x.

Definition at line 449 of file OR_Matrix.inlines.hh.

Referenced by Parma_Polyhedra_Library::OR_Matrix< T >::max_num_rows().

                        {
  dimension_type r = 0;
  const dimension_type FIRST_BIT_MASK = 0x40000000U;
  for (dimension_type t = FIRST_BIT_MASK; t != 0; t >>= 2) {
    dimension_type s = r + t;
    if (s <= x) {
      x -= s;
      r = s + t;
    }
    r >>= 1;
  }
  return r;
}

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

Referenced by Parma_Polyhedra_Library::MIP_Problem::compute_generator(), Parma_Polyhedra_Library::Grid::conversion(), Parma_Polyhedra_Library::Polyhedron::convert_to_integer_expression(), Parma_Polyhedra_Library::Polyhedron::convert_to_integer_expressions(), Parma_Polyhedra_Library::MIP_Problem::get_exiting_base_index(), Parma_Polyhedra_Library::Box< ITV >::max_min(), Parma_Polyhedra_Library::Grid::normalize_divisors(), Parma_Polyhedra_Library::Congruence_System::normalize_moduli(), and Parma_Polyhedra_Library::MIP_Problem::steepest_edge_exact_entering_index().

                                                                       {
  mpz_lcm(x.get_mpz_t(), y.get_mpz_t(), z.get_mpz_t());
}

dimension_type Parma_Polyhedra_Library::least_significant_one_mask ( dimension_type i )

inline

Definition at line 184 of file globals.inlines.hh.

Referenced by Parma_Polyhedra_Library::CO_Tree::tree_iterator::follow_left_children_with_value(), Parma_Polyhedra_Library::CO_Tree::tree_iterator::follow_right_children_with_value(), Parma_Polyhedra_Library::CO_Tree::tree_iterator::operator=(), and Parma_Polyhedra_Library::CO_Tree::tree_iterator::tree_iterator().

                                                   {
  return i & (~i + 1U);
}

void Parma_Polyhedra_Library::linear_combine	(	Dense_Row &	x,
		const Dense_Row &	y,
		Coefficient_traits::const_reference	coeff1,
		Coefficient_traits::const_reference	coeff2
	)

References Parma_Polyhedra_Library::Dense_Row::linear_combine().

                                                         {
  x.linear_combine(y, coeff1, coeff2);
}

void Parma_Polyhedra_Library::linear_combine	(	Dense_Row &	x,
		const Dense_Row &	y,
		Coefficient_traits::const_reference	c1,
		Coefficient_traits::const_reference	c2,
		dimension_type	start,
		dimension_type	end
	)

References Parma_Polyhedra_Library::Dense_Row::linear_combine().

                                                         {
  x.linear_combine(y, c1, c2, start, end);
}

template<typename T >

T Parma_Polyhedra_Library::low_bits_mask ( unsigned n )

inline

Returns a mask for the lowest n bits,.

Definition at line 45 of file math_utilities.inlines.hh.

References PPL_ASSERT.

                                {
  PPL_ASSERT(n < unsigned(std::numeric_limits<T>::digits));
  return ~((~static_cast<T>(0)) << n);
}

template<typename N >

void Parma_Polyhedra_Library::max_assign	(	N &	x,
		const N &	y
	)

inline

Assigns to x the maximum between x and y.

Definition at line 87 of file math_utilities.inlines.hh.

                             {
  if (x < y)
    x = y;
}

dimension_type Parma_Polyhedra_Library::max_space_dimension ( )

inline

Returns the maximum space dimension this library can handle.

Definition at line 40 of file max_space_dimension.hh.

References Parma_Polyhedra_Library::Variable::max_space_dimension(), Parma_Polyhedra_Library::Box< ITV >::max_space_dimension(), Parma_Polyhedra_Library::Grid::max_space_dimension(), Parma_Polyhedra_Library::Polyhedron::max_space_dimension(), and not_a_dimension().

                      {
  // Note: we assume that the powerset and the ask-and-tell construction
  // do not limit the space dimension more than their parameters.
  static bool computed = false;
  static dimension_type d = not_a_dimension();
  if (!computed) {
    d = Variable::max_space_dimension();
    d = std::min(d, C_Polyhedron::max_space_dimension());
    d = std::min(d, NNC_Polyhedron::max_space_dimension());
    d = std::min(d, Grid::max_space_dimension());
    // FIXME: what about all other boxes?
    d = std::min(d, Rational_Box::max_space_dimension());
    d = std::min(d, BD_Shape<int8_t>::max_space_dimension());
    d = std::min(d, BD_Shape<int16_t>::max_space_dimension());
    d = std::min(d, BD_Shape<int32_t>::max_space_dimension());
    d = std::min(d, BD_Shape<int64_t>::max_space_dimension());
    d = std::min(d, BD_Shape<float>::max_space_dimension());
    d = std::min(d, BD_Shape<double>::max_space_dimension());
    d = std::min(d, BD_Shape<long double>::max_space_dimension());
    d = std::min(d, BD_Shape<mpz_class>::max_space_dimension());
    d = std::min(d, BD_Shape<mpq_class>::max_space_dimension());
    d = std::min(d, Octagonal_Shape<int8_t>::max_space_dimension());
    d = std::min(d, Octagonal_Shape<int16_t>::max_space_dimension());
    d = std::min(d, Octagonal_Shape<int32_t>::max_space_dimension());
    d = std::min(d, Octagonal_Shape<int64_t>::max_space_dimension());
    d = std::min(d, Octagonal_Shape<float>::max_space_dimension());
    d = std::min(d, Octagonal_Shape<double>::max_space_dimension());
    d = std::min(d, Octagonal_Shape<long double>::max_space_dimension());
    d = std::min(d, Octagonal_Shape<mpz_class>::max_space_dimension());
    d = std::min(d, Octagonal_Shape<mpq_class>::max_space_dimension());
    computed = true;
  }
  return d;
}

void Parma_Polyhedra_Library::maybe_abandon ( )

References abandon_expensive_computations, Parma_Polyhedra_Library::In_Assert::asserting(), and Parma_Polyhedra_Library::Weightwatch_Traits::check_function.

Referenced by Parma_Polyhedra_Library::PIP_Tree_Node::compatibility_check(), Parma_Polyhedra_Library::MIP_Problem::compute_simplex_using_exact_pricing(), Parma_Polyhedra_Library::MIP_Problem::compute_simplex_using_steepest_edge_float(), Parma_Polyhedra_Library::Polyhedron::conversion(), Parma_Polyhedra_Library::Box< ITV >::propagate_constraints_no_check(), and Parma_Polyhedra_Library::PIP_Solution_Node::solve().

                {
#ifndef NDEBUG
  if (In_Assert::asserting())
    return;
#endif
  if (Weightwatch_Traits::check_function != 0)
    Weightwatch_Traits::check_function();
  if (const Throwable* p = abandon_expensive_computations)
    p->throw_me();
}

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 64 of file distances.inlines.hh.

References Parma_Polyhedra_Library::maybe_assign_struct< To, From >::function().

Referenced by Parma_Polyhedra_Library::DB_Matrix< T >::l_m_distance_assign(), Parma_Polyhedra_Library::Generator::l_m_distance_assign(), Parma_Polyhedra_Library::OR_Matrix< T >::l_m_distance_assign(), and Parma_Polyhedra_Library::Box< ITV >::l_m_distance_assign().

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

template<typename T >

int Parma_Polyhedra_Library::maybe_check_fpu_inexact ( )

inline

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

References fpu_check_inexact().

                          {
  if (FPU_Related<T>::value)
    return fpu_check_inexact();
  else
    return 0;
}

template<typename T >

void Parma_Polyhedra_Library::maybe_reset_fpu_inexact ( )

inline

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

References fpu_reset_inexact().

                          {
  if (FPU_Related<T>::value)
    return fpu_reset_inexact();
}

template<typename N >

void Parma_Polyhedra_Library::min_assign	(	N &	x,
		const N &	y
	)

inline

Assigns to x the minimum between x and y.

Definition at line 80 of file math_utilities.inlines.hh.

Referenced by Parma_Polyhedra_Library::BD_Shape< T >::incremental_shortest_path_closure_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::incremental_strong_closure_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::lower_extend(), Parma_Polyhedra_Library::BD_Shape< T >::shortest_path_closure_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::strong_closure_assign(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::strong_coherence_assign().

                             {
  if (x > y)
    x = y;
}

template<typename T >

T Parma_Polyhedra_Library::minus_infinity ( )

inline

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

References MINUS_INFINITY.

                 {
  return MINUS_INFINITY;
}

unsigned int Parma_Polyhedra_Library::msb_position ( unsigned long long v )

inline

If v is nonzero, returns the position of the most significant bit in a.

The behavior is undefined if v is zero.

Definition at line 470 of file Float.inlines.hh.

References clz(), and sizeof_to_bits.

Referenced by compute_absolute_error(), and Parma_Polyhedra_Library::Linear_Form< C >::relative_error().

                                   {
  return static_cast<unsigned int>(sizeof_to_bits(sizeof(v))) - 1U - clz(v);
}

void Parma_Polyhedra_Library::mul_2exp_assign	(	GMP_Integer &	x,
		const GMP_Integer &	y,
		unsigned int	exp
	)

Referenced by Parma_Polyhedra_Library::Implementation::wrap_assign(), Parma_Polyhedra_Library::Box< ITV >::wrap_assign(), Parma_Polyhedra_Library::Grid::wrap_assign(), Parma_Polyhedra_Library::Implementation::wrap_assign_col(), and Parma_Polyhedra_Library::Implementation::wrap_assign_ind().

                                                                        {
  mpz_mul_2exp(x.get_mpz_t(), y.get_mpz_t(), exp);
}

void Parma_Polyhedra_Library::neg_assign ( GMP_Integer & x )

                           {
  mpz_neg(x.get_mpz_t(), x.get_mpz_t());
}

void Parma_Polyhedra_Library::neg_assign	(	GMP_Integer &	x,
		const GMP_Integer &	y
	)

                                                 {
  mpz_neg(x.get_mpz_t(), y.get_mpz_t());
}

void Parma_Polyhedra_Library::normalize2	(	Coefficient_traits::const_reference	x,
		Coefficient_traits::const_reference	y,
		Coefficient &	n_x,
		Coefficient &	n_y
	)

inline

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

Note:: x and n_x may be the same object and likewise for y and n_y. Any other aliasing results in undefined behavior.

Definition at line 34 of file math_utilities.inlines.hh.

References exact_div_assign(), gcd_assign(), and PPL_DIRTY_TEMP_COEFFICIENT.

Referenced by Parma_Polyhedra_Library::Polyhedron::conversion(), Parma_Polyhedra_Library::MIP_Problem::evaluate_objective_function(), Parma_Polyhedra_Library::Box< ITV >::frequency(), Parma_Polyhedra_Library::BD_Shape< T >::frequency(), Parma_Polyhedra_Library::Octagonal_Shape< T >::frequency(), Parma_Polyhedra_Library::Linear_Expression_Impl< Row >::linear_combine(), and Parma_Polyhedra_Library::MIP_Problem::linear_combine().

                                               {
  PPL_DIRTY_TEMP_COEFFICIENT(gcd);
  gcd_assign(gcd, x, y);
  exact_div_assign(n_x, x, gcd);
  exact_div_assign(n_y, y, gcd);
}

dimension_type Parma_Polyhedra_Library::not_a_dimension ( )

inline

Returns a value that does not designate a valid dimension.

Definition at line 38 of file globals.inlines.hh.

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

template<typename T >

T Parma_Polyhedra_Library::not_a_number ( )

inline

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

References NOT_A_NUMBER.

               {
  return NOT_A_NUMBER;
}

template<typename RA_Container >

RA_Container::iterator Parma_Polyhedra_Library::nth_iter	(	RA_Container &	cont,
		dimension_type	n
	)

inline

Definition at line 171 of file globals.inlines.hh.

Referenced by Parma_Polyhedra_Library::MIP_Problem::external_memory_in_bytes(), Parma_Polyhedra_Library::PIP_Problem::solve(), Parma_Polyhedra_Library::PIP_Solution_Node::update_tableau(), and Parma_Polyhedra_Library::MIP_Problem::~MIP_Problem().

                                               {
  typedef typename RA_Container::difference_type diff_t;
  return cont.begin() + static_cast<diff_t>(n);
}

template<typename RA_Container >

RA_Container::const_iterator Parma_Polyhedra_Library::nth_iter	(	const RA_Container &	cont,
		dimension_type	n
	)

inline

Definition at line 178 of file globals.inlines.hh.

                                                     {
  typedef typename RA_Container::difference_type diff_t;
  return cont.begin() + static_cast<diff_t>(n);
}

template<typename T >

Enable_If< Is_Native_Or_Checked< T >::value, void >::type Parma_Polyhedra_Library::numer_denom	(	const T &	from,
		Coefficient &	numer,
		Coefficient &	denom
	)

inline

Extract the numerator and denominator components of from.

Definition at line 52 of file math_utilities.inlines.hh.

References assign_r(), is_minus_infinity(), is_not_a_number(), is_plus_infinity(), PPL_ASSERT, PPL_DIRTY_TEMP, and ROUND_NOT_NEEDED.

                                                    {
  PPL_ASSERT(!is_not_a_number(from)
         && !is_minus_infinity(from)
         && !is_plus_infinity(from));
  PPL_DIRTY_TEMP(mpq_class, q);
  assign_r(q, from, ROUND_NOT_NEEDED);
  numer = q.get_num();
  denom = q.get_den();
}

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
	)

                                     {
  return !(x == y);
}

template<typename ITV >

bool Parma_Polyhedra_Library::operator!=	(	const Box< ITV > &	x,
		const Box< ITV > &	y
	)

                                                 {
  return !(x == y);
}

bool Parma_Polyhedra_Library::operator!=	(	const Generator_System &	x,
		const Generator_System &	y
	)

                                                                 {
  return !(x == y);
}

bool Parma_Polyhedra_Library::operator!=	(	const Constraint_System &	x,
		const Constraint_System &	y
	)

                                                                   {
  return !(x == y);
}

bool Parma_Polyhedra_Library::operator!=	(	const Dense_Row &	x,
		const Sparse_Row &	y
	)

Definition at line 746 of file Sparse_Row.cc.

                                                       {
  return !(x == y);
}

bool Parma_Polyhedra_Library::operator!=	(	const Sparse_Row &	x,
		const Dense_Row &	y
	)

Definition at line 756 of file Sparse_Row.cc.

                                                       {
  return !(x == y);
}

I_Result Parma_Polyhedra_Library::operator&	(	I_Result	a,
		I_Result	b
	)

inline

Definition at line 102 of file intervals.defs.hh.

                                  {
  return static_cast<I_Result>(static_cast<unsigned>(a)
                               & static_cast<unsigned>(b));
}

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 970 of file Interval.inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign().

                                                  {
  Interval<B, Info> z;
  z.mul_assign(x, y);
  return z;
}

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 978 of file Interval.inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign().

                                                  {
  Interval<B, Info> z;
  z.mul_assign(x, y);
  return z;
}

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 986 of file Interval.inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign().

                                                                  {
  Interval<B, Info> z;
  z.mul_assign(x, y);
  return z;
}

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 922 of file Interval.inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign().

                                                  {
  Interval<B, Info> z;
  z.add_assign(x, y);
  return z;
}

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 930 of file Interval.inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign().

                                                  {
  Interval<B, Info> z;
  z.add_assign(x, y);
  return z;
}

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 938 of file Interval.inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign().

                                                                  {
  Interval<B, Info> z;
  z.add_assign(x, y);
  return z;
}

I_Result Parma_Polyhedra_Library::operator-	(	I_Result	a,
		I_Result	b
	)

inline

Definition at line 108 of file intervals.defs.hh.

                                  {
    return static_cast<I_Result>(static_cast<unsigned>(a)
                                 & ~static_cast<unsigned>(b));
}

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 946 of file Interval.inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().

                                                  {
  Interval<B, Info> z;
  z.sub_assign(x, y);
  return z;
}

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 954 of file Interval.inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().

                                                  {
  Interval<B, Info> z;
  z.sub_assign(x, y);
  return z;
}

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 962 of file Interval.inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().

                                                                  {
  Interval<B, Info> z;
  z.sub_assign(x, y);
  return z;
}

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 994 of file Interval.inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign().

                                                  {
  Interval<B, Info> z;
  z.div_assign(x, y);
  return z;
}

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 1002 of file Interval.inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign().

                                                  {
  Interval<B, Info> z;
  z.div_assign(x, y);
  return z;
}

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 1010 of file Interval.inlines.hh.

References Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign().

                                                                  {
  Interval<B, Info> z;
  z.div_assign(x, y);
  return z;
}

template<typename Boundary , typename Info >

std::ostream& Parma_Polyhedra_Library::operator<<	(	std::ostream &	os,
		const Interval< Boundary, Info > &	x
	)

inline

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

References check_empty_arg(), Parma_Polyhedra_Library::Boundary_NS::LOWER, ROUND_NOT_NEEDED, Parma_Polyhedra_Library::Boundary_NS::SPECIAL, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                                                              {
  if (check_empty_arg(x))
    return os << "[]";
  if (x.is_singleton()) {
    output(os, x.lower(), Numeric_Format(), ROUND_NOT_NEEDED);
    return os;
  }
  os << (x.lower_is_open() ? "(" : "[");
  if (x.info().get_boundary_property(LOWER, SPECIAL))
    os << "-inf";
  else
    output(os, x.lower(), Numeric_Format(), ROUND_NOT_NEEDED);
  os << ", ";
  if (x.info().get_boundary_property(UPPER, SPECIAL))
    os << "+inf";
  else
    output(os, x.upper(), Numeric_Format(), ROUND_NOT_NEEDED);
  os << (x.upper_is_open() ? ")" : "]");
  return os;
}

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
	)

References check_empty_arg(), Parma_Polyhedra_Library::Boundary_NS::eq(), Parma_Polyhedra_Library::Interval_NS::f_info(), Parma_Polyhedra_Library::Interval_NS::f_lower(), f_OK(), Parma_Polyhedra_Library::Interval_NS::f_upper(), Parma_Polyhedra_Library::Boundary_NS::LOWER, PPL_ASSERT, and Parma_Polyhedra_Library::Boundary_NS::UPPER.

                                     {
  PPL_ASSERT(f_OK(x));
  PPL_ASSERT(f_OK(y));
  if (check_empty_arg(x))
    return check_empty_arg(y);
  else if (check_empty_arg(y))
    return false;
  return eq(LOWER, f_lower(x), f_info(x), LOWER, f_lower(y), f_info(y))
    && eq(UPPER, f_upper(x), f_info(x), UPPER, f_upper(y), f_info(y));
}

bool Parma_Polyhedra_Library::operator==	(	const Generator_System &	x,
		const Generator_System &	y
	)

References Parma_Polyhedra_Library::Generator_System::sys.

                                                                 {
  return x.sys == y.sys;
}

bool Parma_Polyhedra_Library::operator==	(	const Constraint_System &	x,
		const Constraint_System &	y
	)

References Parma_Polyhedra_Library::Constraint_System::sys.

                                                                   {
  return x.sys == y.sys;
}

template<typename ITV >

bool Parma_Polyhedra_Library::operator==	(	const Box< ITV > &	x,
		const Box< ITV > &	y
	)

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::iterator_to_const< Container >::operator!=(), Parma_Polyhedra_Library::const_iterator_to_const< Container >::operator!=(), and Parma_Polyhedra_Library::PIP_Tree_Node::Artificial_Parameter::operator!=().

                                                 {
  const dimension_type x_space_dim = x.space_dimension();
  if (x_space_dim != y.space_dimension())
    return false;
  if (x.is_empty())
    return y.is_empty();
  if (y.is_empty())
    return x.is_empty();
  for (dimension_type k = x_space_dim; k-- > 0; )
    if (x.seq[k] != y.seq[k])
      return false;
  return true;
}

bool Parma_Polyhedra_Library::operator==	(	const Dense_Row &	x,
		const Sparse_Row &	y
	)

Definition at line 728 of file Sparse_Row.cc.

References Parma_Polyhedra_Library::Sparse_Row::end(), Parma_Polyhedra_Library::CO_Tree::const_iterator::index(), Parma_Polyhedra_Library::Sparse_Row::lower_bound(), Parma_Polyhedra_Library::Sparse_Row::size(), and Parma_Polyhedra_Library::Dense_Row::size().

                                                       {
  if (x.size() != y.size())
    return false;
  Sparse_Row::const_iterator itr = y.end();
  for (dimension_type i = 0; i < x.size(); ++i) {
    itr = y.lower_bound(itr, i);
    if (itr != y.end() && itr.index() == i) {
      if (x[i] != *itr)
        return false;
    } else {
      if (x[i] != 0)
        return false;
    }
  }
  return true;
}

bool Parma_Polyhedra_Library::operator==	(	const Sparse_Row &	x,
		const Dense_Row &	y
	)

Definition at line 751 of file Sparse_Row.cc.

                                                       {
  return y == x;
}

template<typename Boundary , typename Info >

std::istream& Parma_Polyhedra_Library::operator>>	(	std::istream &	is,
		Interval< Boundary, Info > &	x
	)

inline

Definition at line 229 of file Interval.templates.hh.

                                                        {
  Boundary lower_bound;
  Boundary upper_bound;
  bool lower_boundary_infinity = false;
  bool upper_boundary_infinity = false;
  bool lower_open = false;
  bool upper_open = false;
  Result lower_r;
  Result upper_r;
  // Eat leading white space.
  char c;
  do {
    if (!is.get(c))
      goto fail;
  } while (is_space(c));
  // Get the opening parenthesis and handle the empty interval case.
  if (c == '(')
    lower_open = true;
  else if (c == '[') {
    if (!is.get(c))
      goto fail;
    if (c == ']') {
      // Empty interval.
      x.assign(EMPTY);
      return is;
    }
    else
      is.unget();
  }
  else
    goto unexpected;
  // Get the lower bound.
  lower_r = input(lower_bound, is, ROUND_DOWN);
  if (lower_r == V_CVT_STR_UNK || lower_r == V_NAN)
    goto fail;
  lower_r = result_relation_class(lower_r);
  // Match the comma separating the lower and upper bounds.
  do {
    if (!is.get(c))
      goto fail;
  } while (is_space(c));
  if (c != ',')
    goto unexpected;
  // Get the upper bound.
  upper_r = input(upper_bound, is, ROUND_UP);
  if (upper_r == V_CVT_STR_UNK || upper_r == V_NAN)
    goto fail;
  upper_r = result_relation_class(upper_r);
  // Get the closing parenthesis.
  do {
    if (!is.get(c))
      goto fail;
  } while (is_space(c));
  if (c == ')')
    upper_open = true;
  else if (c != ']') {
  unexpected:
    is.unget();
  fail:
    is.setstate(std::ios::failbit);
    return is;
  }
  // Build interval.
  switch (lower_r) {
  case V_EQ: // Fall through.
  case V_GE:
    break;
  case V_GT:
    lower_open = true;
    break;
  case V_GT_MINUS_INFINITY:
    lower_open = true;
    // Fall through.
  case V_EQ_MINUS_INFINITY:
    lower_boundary_infinity = true;
    break;
  case V_EQ_PLUS_INFINITY: // Fall through.
  case V_LT_PLUS_INFINITY:
    if (upper_r == V_EQ_PLUS_INFINITY || upper_r == V_LT_PLUS_INFINITY)
      x.assign(UNIVERSE);
    else
      x.assign(EMPTY);
    return is;
  default:
    PPL_UNREACHABLE;
    break;
  }
  switch (upper_r) {
  case V_EQ: // Fall through.
  case V_LE:
    break;
  case V_LT:
    upper_open = true;
    break;
  case V_GT_MINUS_INFINITY:
    upper_open = true;
    // Fall through.
  case V_EQ_MINUS_INFINITY:
    if (lower_r == V_EQ_MINUS_INFINITY || lower_r == V_GT_MINUS_INFINITY)
      x.assign(UNIVERSE);
    else
      x.assign(EMPTY);
    return is;
  case V_EQ_PLUS_INFINITY: // Fall through.
  case V_LT_PLUS_INFINITY:
    upper_boundary_infinity = true;
    break;
  default:
    PPL_UNREACHABLE;
    break;
  }
  if (!lower_boundary_infinity
      && !upper_boundary_infinity
      && (lower_bound > upper_bound
          || (lower_open && lower_bound == upper_bound)))
    x.assign(EMPTY);
  else {
    if (lower_boundary_infinity)
      set_minus_infinity(LOWER, x.lower(), x.info(), lower_open);
    else
      assign(LOWER, x.lower(), x.info(),
             LOWER, lower_bound, SCALAR_INFO, lower_open);
    if (upper_boundary_infinity)
      set_plus_infinity(UPPER, x.upper(), x.info(), upper_open);
    else
      assign(UPPER, x.upper(), x.info(),
             UPPER, upper_bound, SCALAR_INFO, upper_open);
  }
  return is;
}

I_Result Parma_Polyhedra_Library::operator\|	(	I_Result	a,
		I_Result	b
	)

inline

Definition at line 96 of file intervals.defs.hh.

                                  {
  return static_cast<I_Result>(static_cast<unsigned>(a)
                               | static_cast<unsigned>(b));
}

template<typename T >

T Parma_Polyhedra_Library::plus_infinity ( )

inline

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

References PLUS_INFINITY.

                {
  return PLUS_INFINITY;
}

void Parma_Polyhedra_Library::ppl_assertion_failed	(	const char *	assertion_text,
		const char *	file,
		unsigned int	line,
		const char *	function
	)

Helper function printing an assertion failure message on std::cerr and causing program termination by calling abort.

Definition at line 46 of file assert.cc.

                                                {
  std::cerr << file << ":" << line << ": " << function
            << ": Assertion `" << assertion_text << "' failed.\n";
  abort();
}

template<typename T >

void Parma_Polyhedra_Library::PPL_CC_FLUSH ( const T & x )

inline

No-op function that force the compiler to store the argument and to reread it from memory if needed (thus preventing CSE).

Definition at line 49 of file compiler.hh.

References PPL_USED.

Referenced by Parma_Polyhedra_Library::Checked::limit_precision().

                         {
#if defined(__GNUC__) || defined(__INTEL_COMPILER)
  __asm__ __volatile__ ("" : "+m" (const_cast<T&>(x)));
#else
  // FIXME: is it possible to achieve the same effect in a portable way?
  PPL_USED(x);
#endif
}

void Parma_Polyhedra_Library::PPL_handle_timeout ( int signum )

void Parma_Polyhedra_Library::ppl_unreachable ( )

Helper function causing program termination by calling abort.

Definition at line 32 of file assert.cc.

                     {
  abort();
}

void Parma_Polyhedra_Library::ppl_unreachable_msg	(	const char *	msg,
		const char *	file,
		unsigned int	line,
		const char *	function
	)

Helper function printing message on std::cerr and causing program termination by calling abort.

Definition at line 37 of file assert.cc.

                                               {
  std::cerr << file << ":" << line << ": " << function
            << ": Latent fault detected: " << msg << ".\n";
  abort();
}

const mpz_class& Parma_Polyhedra_Library::raw_value ( const GMP_Integer & x )

Referenced by assign_r(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::assign_r(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::cmp(), construct(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::input(), is_integer(), is_minus_infinity(), is_not_a_number(), is_plus_infinity(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::output(), and Parma_Polyhedra_Library::Checked_Number< T, Policy >::sgn().

                                {
  return x;
}

mpz_class& Parma_Polyhedra_Library::raw_value ( GMP_Integer & x )

                          {
  return x;
}

void Parma_Polyhedra_Library::rem_assign	(	GMP_Integer &	x,
		const GMP_Integer &	y,
		const GMP_Integer &	z
	)

Referenced by Parma_Polyhedra_Library::Pointset_Powerset< PSET >::approximate_partition_aux().

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

void Parma_Polyhedra_Library::restore_pre_PPL_rounding ( )

inline

Sets the FPU rounding mode as it was before initialization of the PPL.

This is important if the application uses floating-point computations outside the PPL. It is crucial when the application uses functions from a mathematical library that are not guaranteed to work correctly under all rounding modes.

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 40 of file Init.inlines.hh.

References fpu_set_rounding_direction(), and Parma_Polyhedra_Library::Init::old_rounding_direction.

                           {
#if PPL_CAN_CONTROL_FPU
  fpu_set_rounding_direction(Init::old_rounding_direction);
#endif
}

int Parma_Polyhedra_Library::result_overflow ( Result r )

inline

Definition at line 73 of file Result.inlines.hh.

References result_class(), V_GT_SUP, V_LT_INF, VC_MINUS_INFINITY, VC_NORMAL, and VC_PLUS_INFINITY.

Referenced by Parma_Polyhedra_Library::Checked::add_mul_int(), Parma_Polyhedra_Library::Checked::sub_mul_int(), Parma_Polyhedra_Library::Implementation::wrap_assign(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::wrap_assign().

                          {
  switch (result_class(r)) {
  case VC_NORMAL:
    switch (r) {
    case V_LT_INF:
      return -1;
    case V_GT_SUP:
      return 1;
    default:
      break;
    }
    break;
  case VC_MINUS_INFINITY:
    return -1;
  case VC_PLUS_INFINITY:
    return 1;
  default:
    break;
  }
  return 0;
}

bool Parma_Polyhedra_Library::result_representable ( Result r )

inline

Definition at line 96 of file Result.inlines.hh.

References V_UNREPRESENTABLE.

Referenced by Parma_Polyhedra_Library::Boundary_NS::set_boundary_infinity(), Parma_Polyhedra_Library::Boundary_NS::set_minus_infinity(), and Parma_Polyhedra_Library::Boundary_NS::set_plus_infinity().

                               {
  return (r & V_UNREPRESENTABLE) != V_UNREPRESENTABLE;
}

Rounding_Dir Parma_Polyhedra_Library::rounding_dir ( Rounding_Dir dir )

inline

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

References ROUND_CHECK, and ROUND_NOT_NEEDED.

Referenced by assign_r(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::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().

                               {
  if (dir == ROUND_NOT_NEEDED) {
#ifdef DEBUG_ROUND_NOT_NEEDED
    return ROUND_CHECK;
#endif
  }
  return dir;
}

void Parma_Polyhedra_Library::set_irrational_precision ( const unsigned p )

inline

Sets the precision parameter used for irrational calculations.

The lesser between numerator and denominator is limited to 2**p.

If p is less than or equal to INT_MAX, sets the precision parameter used for irrational calculations to p.

Exceptions:

std::invalid_argument Thrown if p is greater than INT_MAX.

Definition at line 532 of file checked_mpq.inlines.hh.

References Parma_Polyhedra_Library::Checked::irrational_precision.

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

                                           {
  if (p <= INT_MAX)
    Checked::irrational_precision = p;
  else
    throw std::invalid_argument("PPL::set_irrational_precision(p)"
                                " with p > INT_MAX");
}

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 33 of file Init.inlines.hh.

References fpu_set_rounding_direction(), ROUND_DIRECT, and round_fpu_dir().

                       {
#if PPL_CAN_CONTROL_FPU
    fpu_set_rounding_direction(round_fpu_dir(ROUND_DIRECT));
#endif
}

template<typename D1 , typename D2 >

bool Parma_Polyhedra_Library::shrink_to_congruence_no_check	(	D1 &	d1,
		D2 &	d2,
		const Congruence &	cg
	)

Definition at line 515 of file Partially_Reduced_Product.templates.hh.

References EMPTY, Parma_Polyhedra_Library::Poly_Con_Relation::is_included(), Parma_Polyhedra_Library::Congruence::modulus(), PPL_ASSERT, PPL_DIRTY_TEMP_COEFFICIENT, and swap().

Referenced by Parma_Polyhedra_Library::Congruences_Reduction< D1, D2 >::product_reduce().

                                                                         {
  // It is assumed that cg is a proper congruence.
  PPL_ASSERT(cg.modulus() != 0);
  // It is assumed that cg is satisfied by all points in d1.
  PPL_ASSERT(d1.relation_with(cg) == Poly_Con_Relation::is_included());
  Linear_Expression e(cg);
  // Find the maximum and minimum bounds for the domain element d with the
  // linear expression e.
  PPL_DIRTY_TEMP_COEFFICIENT(max_numer);
  PPL_DIRTY_TEMP_COEFFICIENT(max_denom);
  bool max_included;
  PPL_DIRTY_TEMP_COEFFICIENT(min_numer);
  PPL_DIRTY_TEMP_COEFFICIENT(min_denom);
  if (d2.maximize(e, max_numer, max_denom, max_included)) {
    bool min_included;
    if (d2.minimize(e, min_numer, min_denom, min_included)) {
      // Adjust values to allow for the denominators max_denom and min_denom.
      max_numer *= min_denom;
      min_numer *= max_denom;
      PPL_DIRTY_TEMP_COEFFICIENT(denom);
      PPL_DIRTY_TEMP_COEFFICIENT(mod);
      denom = max_denom * min_denom;
      mod = cg.modulus() * denom;
      // If the difference between the maximum and minimum bounds is more than
      // twice the modulus, then there will be two neighboring hyperplanes
      // defined by cg that are intersected by the domain element d;
      // there is no possible reduction in this case.
      PPL_DIRTY_TEMP_COEFFICIENT(mod2);
      mod2 = 2 * mod;
      if (max_numer - min_numer < mod2
          || (max_numer - min_numer == mod2 && (!max_included || !min_included)))
        {
          PPL_DIRTY_TEMP_COEFFICIENT(shrink_amount);
          PPL_DIRTY_TEMP_COEFFICIENT(max_decreased);
          PPL_DIRTY_TEMP_COEFFICIENT(min_increased);
          // Find the amount by which the maximum value may be decreased.
          shrink_amount = max_numer % mod;
          if (!max_included && shrink_amount == 0)
            shrink_amount = mod;
          if (shrink_amount < 0)
            shrink_amount += mod;
          max_decreased = max_numer - shrink_amount;
          // Find the amount by which the minimum value may be increased.
          shrink_amount = min_numer % mod;
          if (!min_included && shrink_amount == 0)
            shrink_amount = - mod;
          if (shrink_amount > 0)
            shrink_amount -= mod;
          min_increased = min_numer - shrink_amount;
          if (max_decreased == min_increased) {
            // The domain element d2 intersects exactly one hyperplane
            // defined by cg, so add the equality to d1 and d2.
            Constraint new_c(denom * e == min_increased);
            d1.refine_with_constraint(new_c);
            d2.refine_with_constraint(new_c);
            return true;
          }
          else {
            if (max_decreased < min_increased) {
              using std::swap;
              // In this case, d intersects no hyperplanes defined by cg,
              // so set d to empty and return false.
              D1 new_d1(d1.space_dimension(), EMPTY);
              swap(d1, new_d1);
              D2 new_d2(d2.space_dimension(), EMPTY);
              swap(d2, new_d2);
              return false;
            }
          }
        }
    }
  }
  return true;
}

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

                                                  {
  mpz_sqrt(x.get_mpz_t(), y.get_mpz_t());
}

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

                                                                           {
  mpz_submul(x.get_mpz_t(), y.get_mpz_t(), z.get_mpz_t());
}

void Parma_Polyhedra_Library::sub_mul_assign	(	Linear_Expression &	e1,
		Coefficient_traits::const_reference	factor,
		const Linear_Expression &	e2
	)

References Parma_Polyhedra_Library::Linear_Expression::impl, and Parma_Polyhedra_Library::Linear_Expression_Interface::sub_mul_assign().

                                                 {
  e1.impl->sub_mul_assign(factor, *e2.impl);
}

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 58 of file globals.defs.hh.

References PPL_COMPILE_TIME_CHECK.

             {
  PPL_COMPILE_TIME_CHECK(!Slow_Copy<T>::value, "missing swap specialization");
}

void Parma_Polyhedra_Library::swap	(	Variable &	x,
		Variable &	y
	)

References Parma_Polyhedra_Library::Variable::m_swap().

                               {
  x.m_swap(y);
}

template<typename Row >

void Parma_Polyhedra_Library::swap	(	Matrix< Row > &	x,
		Matrix< Row > &	y
	)

References Parma_Polyhedra_Library::Matrix< Row >::m_swap().

                                     {
  x.m_swap(y);
}

template<typename T >

void Parma_Polyhedra_Library::swap	(	Swapping_Vector< T > &	vec1,
		Swapping_Vector< T > &	vec2
	)

References Parma_Polyhedra_Library::Swapping_Vector< T >::m_swap().

                                                         {
  vec1.m_swap(vec2);
}

void Parma_Polyhedra_Library::swap	(	Parma_Polyhedra_Library::Sparse_Row &	x,
		Parma_Polyhedra_Library::Dense_Row &	y
	)

Definition at line 1047 of file Sparse_Row.cc.

References Parma_Polyhedra_Library::Sparse_Row::begin(), Parma_Polyhedra_Library::Sparse_Row::end(), Parma_Polyhedra_Library::Sparse_Row::size(), and swap().

                                     {
  Dense_Row new_dense(x.size(), x.size());
  for (Sparse_Row::iterator i = x.begin(), i_end = x.end(); i != i_end; ++i)
    swap(new_dense[i.index()], *i);
  // NOTE: This copies the coefficients, but it could steal them.
  // Implementing a stealing-based algorithm takes a lot of time and it's
  // probably not worth it.
  Sparse_Row new_sparse(y);
  swap(new_dense, y);
  swap(new_sparse, x);
}

void Parma_Polyhedra_Library::swap	(	Parma_Polyhedra_Library::Dense_Row &	x,
		Parma_Polyhedra_Library::Sparse_Row &	y
	)

Definition at line 1063 of file Sparse_Row.cc.

References swap().

                                     {
  swap(y, x);
}

void Parma_Polyhedra_Library::swap	(	CO_Tree &	x,
		CO_Tree &	y
	)

References Parma_Polyhedra_Library::CO_Tree::m_swap().

                             {
  x.m_swap(y);
}

void Parma_Polyhedra_Library::swap	(	CO_Tree::const_iterator &	x,
		CO_Tree::const_iterator &	y
	)

References Parma_Polyhedra_Library::CO_Tree::const_iterator::m_swap().

                                                         {
  x.m_swap(y);
}

void Parma_Polyhedra_Library::swap	(	CO_Tree::iterator &	x,
		CO_Tree::iterator &	y
	)

References Parma_Polyhedra_Library::CO_Tree::iterator::m_swap().

                                             {
  x.m_swap(y);
}

void Parma_Polyhedra_Library::throw_result_exception ( Result r )

Definition at line 30 of file Checked_Number.cc.

References V_CVT_STR_UNK, V_DIV_ZERO, V_EMPTY, V_EQ, V_EQ_MINUS_INFINITY, V_EQ_PLUS_INFINITY, V_GE, V_GT, V_GT_MINUS_INFINITY, V_GT_SUP, V_INF_ADD_INF, V_INF_DIV_INF, V_INF_MOD, V_INF_MUL_ZERO, V_INF_SUB_INF, V_LE, V_LGE, V_LT, V_LT_INF, V_LT_PLUS_INFINITY, V_MOD_ZERO, V_NAN, V_NE, V_SQRT_NEG, V_UNKNOWN_NEG_OVERFLOW, V_UNKNOWN_POS_OVERFLOW, and V_UNREPRESENTABLE.

Referenced by Parma_Polyhedra_Library::Extended_Number_Policy::handle_result(), Parma_Polyhedra_Library::WRD_Extended_Number_Policy::handle_result(), and Parma_Polyhedra_Library::Debug_WRD_Extended_Number_Policy::handle_result().

                                 {
  switch (r - V_UNREPRESENTABLE) {
  case V_EMPTY:
    throw std::domain_error("Exact result is not comparable to computable one.");
  case V_EQ:
    throw std::logic_error("Exact result is equal to computed one.");
  case V_LT:
    throw std::logic_error("Exact result is less than computed one.");
  case V_LE:
    throw std::logic_error("Exact result is less than or equal to "
                           "computed one.");
  case V_GT:
    throw std::logic_error("Exact result is greater than computed one.");
  case V_GE:
    throw std::logic_error("Exact result is greater than or equal to "
                           "computed one.");
  case V_NE:
    throw std::logic_error("Exact result is less than or greater than "
                           "computed one.");
  case V_LGE:
    throw std::logic_error("Exact result is less than, greater than or "
                           "equal to computed one.");
  case V_EQ_MINUS_INFINITY:
    throw std::overflow_error("Minus infinity.");
  case V_GT_MINUS_INFINITY:
  case V_LT_INF:
    throw std::overflow_error("Negative overflow.");
  case V_UNKNOWN_NEG_OVERFLOW:
    throw std::overflow_error("Unknown result due to intermediate negative overflow.");
  case V_EQ_PLUS_INFINITY:
    throw std::overflow_error("Plus infinity.");
  case V_LT_PLUS_INFINITY:
  case V_GT_SUP:
    throw std::overflow_error("Positive overflow.");
  case V_UNKNOWN_POS_OVERFLOW:
    throw std::overflow_error("Unknown result due to intermediate positive overflow.");
  case V_NAN:
    throw std::domain_error("Not-a-Number.");
  case V_CVT_STR_UNK:
    throw std::domain_error("Invalid numeric string.");
  case V_DIV_ZERO:
    throw std::domain_error("Division by zero.");
  case V_INF_ADD_INF:
    throw std::domain_error("Infinities addition.");
  case V_INF_DIV_INF:
    throw std::domain_error("Infinities division.");
  case V_INF_MOD:
    throw std::domain_error("Remainder of division of infinity.");
  case V_INF_MUL_ZERO:
    throw std::domain_error("Multiplication of infinity and zero.");
  case V_INF_SUB_INF:
    throw std::domain_error("Subtraction of infinities.");
  case V_MOD_ZERO:
    throw std::domain_error("Remainder of division by zero.");
  case V_SQRT_NEG:
    throw std::domain_error("Square root of negative number.");
  default:
    throw std::logic_error("Unexpected result.");
  }
}

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 113 of file globals.inlines.hh.

Referenced by Parma_Polyhedra_Library::Checked_Number< T, Policy >::total_memory_in_bytes().

                                {
  return sizeof(T);
}

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 124 of file globals.inlines.hh.

References external_memory_in_bytes().

                                          {
  return sizeof(x) + external_memory_in_bytes(x);
}

memory_size_type Parma_Polyhedra_Library::total_memory_in_bytes ( const mpq_class & x )

inline

Returns the total size in bytes of the memory occupied by x.

Definition at line 135 of file globals.inlines.hh.

References external_memory_in_bytes().

                                          {
  return sizeof(x) + external_memory_in_bytes(x);
}

template<typename FP_Interval_Type >

void Parma_Polyhedra_Library::upper_bound_assign	(	std::map< dimension_type, Linear_Form< FP_Interval_Type > > &	ls1,
		const std::map< dimension_type, Linear_Form< FP_Interval_Type > > &	ls2
	)

Referenced by Parma_Polyhedra_Library::Polyhedron::BFT00_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::BD_Shape< T >::BFT00_upper_bound_assign_if_exact(), Parma_Polyhedra_Library::BD_Shape< T >::BHZ09_upper_bound_assign_if_exact(), Parma_Polyhedra_Library::Grid::fold_space_dimensions(), Parma_Polyhedra_Library::Octagonal_Shape< T >::integer_upper_bound_assign_if_exact(), Parma_Polyhedra_Library::Octagonal_Shape< T >::upper_bound_assign_if_exact(), and Parma_Polyhedra_Library::Grid::upper_bound_assign_if_exact().

                                                                             {
  typedef Linear_Form<FP_Interval_Type> FP_Linear_Form;
  typedef typename std::map<dimension_type, FP_Linear_Form>::iterator Iter;
  typedef typename std::map<dimension_type,
                            FP_Linear_Form>::const_iterator Const_Iter;
  Const_Iter i2_end = ls2.end();
  for (Iter i1 = ls1.begin(), i1_end = ls1.end(); i1 != i1_end; ) {
    Const_Iter i2 = ls2.find(i1->first);
    if ((i2 == i2_end) || (i1->second != i2->second))
      i1 = ls1.erase(i1);
    else
      ++i1;
  }
}

const char * Parma_Polyhedra_Library::version ( )

Returns a character string containing the PPL version.

Definition at line 101 of file version.cc.

             {
  return version_string;
}

unsigned Parma_Polyhedra_Library::version_beta ( )

Returns the beta number of the PPL version.

Definition at line 96 of file version.cc.

References PPL_VERSION_BETA.

                  {
  return PPL_VERSION_BETA;
}

unsigned Parma_Polyhedra_Library::version_major ( )

Returns the major number of the PPL version.

Definition at line 81 of file version.cc.

References PPL_VERSION_MAJOR.

                   {
  return PPL_VERSION_MAJOR;
}

unsigned Parma_Polyhedra_Library::version_minor ( )

Returns the minor number of the PPL version.

Definition at line 86 of file version.cc.

References PPL_VERSION_MINOR.

                   {
  return PPL_VERSION_MINOR;
}

unsigned Parma_Polyhedra_Library::version_revision ( )

Returns the revision number of the PPL version.

Definition at line 91 of file version.cc.

References PPL_VERSION_REVISION.

                      {
  return PPL_VERSION_REVISION;
}

Variable Documentation

Parma_Polyhedra_Library::Enable_If<(static_cast< Unsigned >-1) >

inline

Definition at line 268 of file OR_Matrix.inlines.hh.

Minus_Infinity Parma_Polyhedra_Library::MINUS_INFINITY

Definition at line 30 of file checked.cc.

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::add_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::div_assign(), minus_infinity(), Parma_Polyhedra_Library::Interval< Boundary, Info >::mul_assign(), Parma_Polyhedra_Library::Boundary_NS::set_boundary_infinity(), Parma_Polyhedra_Library::Boundary_NS::set_minus_infinity(), Parma_Polyhedra_Library::Boundary_NS::set_unbounded(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::sub_assign().

Not_A_Number Parma_Polyhedra_Library::NOT_A_NUMBER

Definition at line 32 of file checked.cc.

Referenced by not_a_number().

Plus_Infinity Parma_Polyhedra_Library::PLUS_INFINITY

Definition at line 31 of file checked.cc.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation