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

Namespaces
	Boundary_NS

	Checked
	Types and functions implementing checked numbers.

	Implementation
	Implementation related data and functions.

	Interfaces
	Data and functions related to language interfaces.

	Interval_NS

	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	Approximable_Reference
	A concrete expression representing a reference to some approximable. More...

class	Approximable_Reference_Common
	Base class for references to some approximable. More...

class	Ask_Tell
	The ask and tell construction on a base-level domain. More...

class	Ask_Tell_Pair
	A pair of ask and tell descriptions. More...

class	BD_Shape
	A bounded difference shape. More...

class	BD_Shape_Helpers

class	BHRZ03_Certificate
	The convergence certificate for the BHRZ03 widening operator. More...

class	Binary_Operator
	A binary operator applied to two concrete expressions. More...

class	Binary_Operator_Common
	Base class for binary operator applied to two concrete expressions. More...

class	Bit_Matrix
	A matrix of bits. More...

class	Bit_Row
	A row in a matrix of bits. More...

struct	Bool
	A class holding a constant called `value` that evaluates to `b`. 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 int >

struct	C_Integer< signed long >

struct	C_Integer< signed long long >

struct	C_Integer< signed short >

struct	C_Integer< unsigned char >

struct	C_Integer< unsigned int >

struct	C_Integer< unsigned long >

struct	C_Integer< unsigned long long >

struct	C_Integer< unsigned short >

class	C_Polyhedron
	A closed convex polyhedron. More...

class	c_streambuf

class	Cast_Floating_Point_Expression
	A generic Cast Floating Point Expression. More...

class	Cast_Operator
	A cast operator converting one concrete expression to some type. More...

class	Cast_Operator_Common
	Base class for cast operator concrete expressions. More...

struct	Check_Overflow_Policy
	A policy checking for overflows. More...

class	Checked_Number
	A wrapper for numeric types implementing a given policy. More...

struct	Checked_Number_Transparent_Policy

class	CO_Tree
	A cache-oblivious binary search tree of pairs. More...

struct	Coefficient_traits_template
	Coefficient traits. More...

struct	Coefficient_traits_template< GMP_Integer >
	Coefficient traits specialization for unbounded integers. More...

struct	Compile_Time_Check
	A class that is only defined if `b` evaluates to `true`. More...

struct	Compile_Time_Check< true >
	A class that is only defined if `b` evaluates to `true`. More...

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

class	Concrete_Expression_Common
	Base class for all concrete expressions. More...

class	Concrete_Expression_Type
	The type of a concrete expression. More...

class	Congruence
	A linear congruence. More...

class	Congruence_System
	A system of congruences. More...

class	Congruences_Reduction
	This class provides the reduction method for the Congruences_Product domain. More...

class	const_iterator_to_const
	A const_iterator on a sequence of read-only objects. More...

struct	Constant

struct	Constant_

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	Constraints_Reduction
	This class provides the reduction method for the Constraints_Product domain. More...

class	DB_Matrix
	The base class for the square matrices. More...

class	DB_Row
	The base class for the single rows of matrices. More...

class	DB_Row_Impl_Handler
	The handler of the actual DB_Row implementation. More...

struct	Debug_WRD_Extended_Number_Policy

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

class	Dirty_Temp
	A structure for the efficient handling of temporaries. 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	Division_Floating_Point_Expression
	A generic Division Floating Point Expression. More...

class	Domain_Product
	This class is temporary and will be removed when template typedefs will be supported in C++. 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< true, T >
	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	Euclidean_Distance_Specialization

class	Expression_Adapter
	An adapter for Linear_Expression objects. More...

class	Expression_Adapter_Base
	Adapters' base type (for template meta-programming). More...

class	Expression_Adapter_Transparent
	A transparent adapter for Linear_Expression objects. More...

class	Expression_Hide_Inhomo
	An adapter for Linear_Expression that hides the inhomogeneous term. More...

class	Expression_Hide_Last
	An adapter for Linear_Expression that maybe hides the last coefficient. More...

struct	Extended_Number_Policy

struct	False
	A class holding a constant called `value` that evaluates to `false`. More...

struct	Fit

struct	Fit< T, v, typename Enable_If< C_Integer< T >::value >::type >

class	Float

struct	float_ibm_double

struct	float_ibm_single

struct	float_ieee754_double

struct	float_ieee754_half

struct	float_ieee754_quad

struct	float_ieee754_single

struct	float_intel_double_extended

class	Floating_Point_Constant
	A floating-point constant concrete expression. More...

class	Floating_Point_Constant_Common
	Base class for floating-point constant concrete expression. More...

class	Floating_Point_Expression

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

struct	FPU_Related

struct	FPU_Related< Checked_Number< T, Policy > >

struct	FPU_Related< double >

struct	FPU_Related< float >

struct	FPU_Related< long double >

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

class	GMP_Integer
	Unbounded integers as provided by the GMP library. 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 >

struct	Has_OK

struct	Has_OK< T, typename Enable_If_Is< bool(T::*)() const,&T::OK >::type >

class	I_Constraint

class	I_Constraint_Base

class	I_Constraint_Common

struct	I_Constraint_Rel

struct	ia32_fenv_t

class	In_Assert

class	Init
	Class for initialization and finalization. More...

class	Integer_Constant
	An integer constant concrete expression. More...

class	Integer_Constant_Common
	Base class for integer constant concrete expressions. More...

struct	Integer_Interval_Info_Policy

class	Interval
	A generic, not necessarily closed, possibly restricted interval. More...

struct	Interval_Base

class	Interval_Info_Bitset

class	Interval_Info_Null

class	Interval_Info_Null_Open

struct	Is_Checked

struct	Is_Checked< Checked_Number< T, P > >

struct	Is_Interval

struct	Is_Native

struct	Is_Native< char >

struct	Is_Native< mpq_class >

struct	Is_Native< mpz_class >

struct	Is_Native< signed char >

struct	Is_Native< signed int >

struct	Is_Native< signed long >

struct	Is_Native< signed long long >

struct	Is_Native< signed short >

struct	Is_Native< unsigned char >

struct	Is_Native< unsigned int >

struct	Is_Native< unsigned long >

struct	Is_Native< unsigned long long >

struct	Is_Native< unsigned short >

struct	Is_Native_Or_Checked

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	Is_Singleton

struct	Is_Special

struct	Is_Special< Minus_Infinity >

struct	Is_Special< Not_A_Number >

struct	Is_Special< Plus_Infinity >

class	iterator_to_const
	An iterator on a sequence of read-only objects. More...

struct	L_Infinity_Distance_Specialization

class	Limited_Widening_Function
	Wraps a limited widening method into a function object. 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	Linear_System_With_Bit_Matrix_iterator

class	Matrix
	A sparse matrix of Coefficient. More...

struct	maybe_assign_struct

struct	maybe_assign_struct< Type, Type >

struct	Minus_Infinity

class	MIP_Problem
	A Mixed Integer (linear) Programming problem. More...

class	Multiplication_Floating_Point_Expression
	A generic Multiplication Floating Point Expression. More...

struct	Native_Checked_From_Wrapper

struct	Native_Checked_From_Wrapper< Checked_Number< T, P > >

struct	Native_Checked_From_Wrapper< T, typename Enable_If< Is_Native< T >::value >::type >

struct	Native_Checked_To_Wrapper

struct	Native_Checked_To_Wrapper< Checked_Number< T, P > >

struct	Native_Checked_To_Wrapper< T, typename Enable_If< Is_Native< T >::value >::type >

class	NNC_Polyhedron
	A not necessarily closed convex polyhedron. More...

class	No_Reduction
	This class provides the reduction method for the Direct_Product domain. More...

struct	Not_A_Number

class	Numeric_Format

class	Octagonal_Shape
	An octagonal shape. More...

class	Octagonal_Shape_Helper

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	Partially_Reduced_Product
	The partially reduced product of two abstractions. More...

class	PIP_Decision_Node
	A tree node representing a decision in the space of solutions. More...

class	PIP_Problem
	A Parametric Integer (linear) Programming problem. More...

class	PIP_Solution_Node
	A tree node representing part of the space of solutions. More...

class	PIP_Tree_Node
	A node of the PIP solution tree. More...

struct	Plus_Infinity

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

struct	Rectilinear_Distance_Specialization

struct	Recycle_Input
	A tag class. More...

class	Scalar_Products
	A class implementing various scalar product functions. More...

struct	Select_Temp_Boundary_Type
	Helper class to select the appropriate numerical type to perform boundary computations so as to reduce the chances of overflow without incurring too much overhead. More...

struct	Select_Temp_Boundary_Type< char >

struct	Select_Temp_Boundary_Type< signed char >

struct	Select_Temp_Boundary_Type< signed int >

struct	Select_Temp_Boundary_Type< signed long >

struct	Select_Temp_Boundary_Type< signed short >

struct	Select_Temp_Boundary_Type< unsigned char >

struct	Select_Temp_Boundary_Type< unsigned int >

struct	Select_Temp_Boundary_Type< unsigned long >

struct	Select_Temp_Boundary_Type< unsigned long long >

struct	Select_Temp_Boundary_Type< unsigned short >

class	Shape_Preserving_Reduction
	This class provides the reduction method for the Shape_Preserving_Product domain. More...

struct	Slow_Copy

struct	Slow_Copy< Checked_Number< T, P > >

struct	Slow_Copy< mpq_class >

struct	Slow_Copy< mpz_class >

class	Smash_Reduction
	This class provides the reduction method for the Smash_Product domain. More...

class	Sparse_Row
	A finite sparse sequence of coefficients. More...

class	stdiobuf

class	Sum_Floating_Point_Expression
	A generic Sum Floating Point Expression. More...

struct	Suppress_Uninitialized_Warnings_Type

class	Swapping_Vector

struct	TConstant

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	Termination_Helpers

class	Threshold_Watcher
	A class of watchdogs controlling the exceeding of a threshold. More...

class	Throwable
	User objects the PPL can throw. More...

class	Topology_Adjusted_Scalar_Product_Sign
	Scalar product sign function object depending on topology. More...

struct	True
	A class holding a constant called `value` that evaluates to `true`. More...

class	Unary_Operator
	A unary operator applied to one concrete expression. More...

class	Unary_Operator_Common
	Base class for unary operator applied to one concrete expression. More...

struct	Use_By_Ref

struct	Use_By_Ref< By_Ref, T >

struct	Use_By_Ref< By_Value, T >

struct	Use_By_Ref< Use_Slow_Copy, T >

class	Val_Or_Ref

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

class	Watchdog
	A watchdog timer. More...

struct	Watchdog_Traits

class	Weight_Profiler

struct	Weightwatch_Traits
	Traits class for the deterministic timeout mechanism. More...

class	Widening_Function
	Wraps a widening method into a function object. More...

struct	WRD_Extended_Number_Policy

Typedefs
typedef PPL_COEFFICIENT_TYPE	Coefficient
	An alias for easily naming the type of PPL coefficients. More...

typedef Coefficient_traits_template< Coefficient >	Coefficient_traits
	An alias for easily naming the coefficient traits. More...

typedef int	Concrete_Expression_Kind
	Encodes the kind of concrete expression. More...

typedef int	Concrete_Expression_BOP
	Encodes a binary operator of concrete expressions. More...

typedef int	Concrete_Expression_UOP
	Encodes a unary operator of concrete expressions. More...

typedef size_t	dimension_type
	An unsigned integral type for representing space dimensions. More...

typedef size_t	memory_size_type
	An unsigned integral type for representing memory size in bytes. More...

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. More...

typedef const PIP_Tree_Node *	PIP_Tree

typedef Box< Rational_Interval >	Rational_Box
	A box with rational, possibly open boundaries. More...

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. More...

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 }

enum	Bounded_Integer_Type_Representation { UNSIGNED, SIGNED_2_COMPLEMENT }

enum	Bounded_Integer_Type_Overflow { OVERFLOW_WRAPS, OVERFLOW_UNDEFINED, OVERFLOW_IMPOSSIBLE }

enum	Representation { DENSE, SPARSE }

enum	Floating_Point_Format { IEEE754_HALF, IEEE754_SINGLE, IEEE754_DOUBLE, IEEE754_QUAD, INTEL_DOUBLE_EXTENDED, IBM_SINGLE, IBM_DOUBLE }

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
template<typename T >
Enable_If< Has_Assign_Or_Swap< T >::value, void >::type	assign_or_swap (T &to, T &from)

template<typename T >
Enable_If<!Has_Assign_Or_Swap< T >::value &&!Slow_Copy< T >::value, void >::type	assign_or_swap (T &to, T &from)

template<typename T >
Enable_If<!Has_Assign_Or_Swap< T >::value &&Slow_Copy< 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=Coefficient_one())
	Returns the relations holding between an interval and an interval constraint. More...

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. More...

void	set_irrational_precision (const unsigned p)
	Sets the precision parameter used for irrational calculations. More...

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. More...

void	Coefficient_constants_finalize ()
	Finalizes the Coefficient constants. More...

Coefficient_traits::const_reference	Coefficient_zero ()
	Returns a const reference to a Coefficient with value 0. More...

Coefficient_traits::const_reference	Coefficient_one ()
	Returns a const reference to a Coefficient with value 1. More...

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

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. More...

unsigned int	msb_position (unsigned long long v)
	If `v` is nonzero, returns the position of the most significant bit in `a`. More...

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. More...

int32_t	hash_code_from_dimension (dimension_type dim)
	Returns the hash code for space dimension `dim`. More...

template<typename T >
Enable_If< Slow_Copy< T >::value, void >::type	swap (T &, T &)
	Make sure swap() is specialized when needed. More...

dimension_type	compute_capacity (dimension_type requested_size, dimension_type maximum_size)
	Speculative allocation function. More...

bool	is_space (char c)
	Returns `true` if `c` is any kind of space character. More...

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. More...

void	restore_pre_PPL_rounding ()
	Sets the FPU rounding mode as it was before initialization of the PPL. More...

void	initialize ()
	Initializes the library. More...

void	finalize ()
	Finalizes the library. More...

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`. More...

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. More...

template<typename N >
void	min_assign (N &x, const N &y)
	Assigns to `x` the minimum between `x` and `y`. More...

template<typename N >
void	max_assign (N &x, const N &y)
	Assigns to `x` the maximum between `x` and `y`. More...

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. More...

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 . More...

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. More...

bool	is_canonical (const mpq_class &x)
	Returns `true` if and only if `x` is in canonical form. More...

template<typename T >
T	low_bits_mask (unsigned n)
	Returns a mask for the lowest `n` bits,. More...

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. More...

dimension_type	isqrt (dimension_type x)
	Returns the integer square root of `x`. More...

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. More...

unsigned	version_minor ()
	Returns the minor number of the PPL version. More...

unsigned	version_revision ()
	Returns the revision number of the PPL version. More...

unsigned	version_beta ()
	Returns the beta number of the PPL version. More...

const char *	version ()
	Returns a character string containing the PPL version. More...

const char *	banner ()
	Returns a character string containing the PPL banner. More...

Functions Controlling Floating Point Unit
void	fpu_initialize_control_functions ()
	Initializes the FPU control functions. More...

fpu_rounding_direction_type	fpu_get_rounding_direction ()
	Returns the current FPU rounding direction. More...

void	fpu_set_rounding_direction (fpu_rounding_direction_type dir)
	Sets the FPU rounding direction to `dir`. More...

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. More...

void	fpu_reset_inexact ()
	Clears the inexact computation status. More...

void	fpu_restore_rounding_direction (fpu_rounding_control_word_type w)
	Restores the FPU rounding rounding control word to `cw`. More...

int	fpu_check_inexact ()
	Queries the inexact computation status. More...

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. More...

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. More...

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. More...

memory_size_type	total_memory_in_bytes (const mpz_class &x)
	Returns the total size in bytes of the memory occupied by `x`. More...

memory_size_type	external_memory_in_bytes (const mpz_class &x)
	Returns the size in bytes of the memory managed by `x`. More...

memory_size_type	total_memory_in_bytes (const mpq_class &x)
	Returns the total size in bytes of the memory occupied by `x`. More...

memory_size_type	external_memory_in_bytes (const mpq_class &x)
	Returns the size in bytes of the memory managed by `x`. More...

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)

Result_Relation	result_relation (Result 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)

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)

template<typename PSET >
bool	termination_test_MS_2 (const PSET &pset_before, const PSET &pset_after)

template<typename PSET >
bool	one_affine_ranking_function_MS (const PSET &pset, Generator &mu)

template<typename PSET >
bool	one_affine_ranking_function_MS_2 (const PSET &pset_before, const PSET &pset_after, Generator &mu)

template<typename PSET >
void	all_affine_ranking_functions_MS (const PSET &pset, C_Polyhedron &mu_space)

template<typename PSET >
void	all_affine_ranking_functions_MS_2 (const PSET &pset_before, const PSET &pset_after, C_Polyhedron &mu_space)

template<typename PSET >
void	all_affine_quasi_ranking_functions_MS (const PSET &pset, C_Polyhedron &decreasing_mu_space, C_Polyhedron &bounded_mu_space)

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)

template<typename PSET >
bool	termination_test_PR (const PSET &pset)

template<typename PSET >
bool	termination_test_PR_2 (const PSET &pset_before, const PSET &pset_after)

template<typename PSET >
bool	one_affine_ranking_function_PR (const PSET &pset, Generator &mu)

template<typename PSET >
bool	one_affine_ranking_function_PR_2 (const PSET &pset_before, const PSET &pset_after, Generator &mu)

template<typename PSET >
void	all_affine_ranking_functions_PR (const PSET &pset, NNC_Polyhedron &mu_space)

template<typename PSET >
void	all_affine_ranking_functions_PR_2 (const PSET &pset_before, const PSET &pset_after, NNC_Polyhedron &mu_space)

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. More...

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

23 {};

enum Parma_Polyhedra_Library::fpu_rounding_direction_type

Definition at line 22 of file fpu_types.hh.

22 {};

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 37 of file Interval_defs.hh.

37 { T_YES, T_NO, T_MAYBE };

Parma_Polyhedra_Library::T_MAYBE

Definition: Interval_defs.hh:37

Parma_Polyhedra_Library::T_YES

Definition: Interval_defs.hh:37

Parma_Polyhedra_Library::T_NO

Definition: Interval_defs.hh:37

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
	)

Referenced by Parma_Polyhedra_Library::Congruence_System::ascii_dump(), Parma_Polyhedra_Library::Linear_System< Row >::ascii_dump(), Parma_Polyhedra_Library::Interval< Boundary, Info >::ascii_dump(), Parma_Polyhedra_Library::MIP_Problem::OK(), Parma_Polyhedra_Library::PIP_Problem::OK(), Parma_Polyhedra_Library::Polyhedron::OK(), and Parma_Polyhedra_Library::Grid::OK().

                                       {
   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 57 of file Checked_Number_templates.hh.

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 150 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 T >

Enable_If<!Has_Assign_Or_Swap<T>::value && !Slow_Copy<T>::value, void>::type Parma_Polyhedra_Library::assign_or_swap	(	T &	to,
		T &	from
	)

inline

If there is no assign_or_swap() method but copies are not slow, copy.

Definition at line 52 of file assign_or_swap.hh.

                                {
   to = from;
 }

template<typename T >

Enable_If<!Has_Assign_Or_Swap<T>::value && Slow_Copy<T>::value, void>::type Parma_Polyhedra_Library::assign_or_swap	(	T &	to,
		T &	from
	)

inline

If there is no assign_or_swap() and copies are slow, delegate to swap().

Definition at line 64 of file assign_or_swap.hh.

References swap().

                                {
   using std::swap;
   swap(to, from);
 }

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(), 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(), and f_is_empty().

                             {
   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 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 48 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 143 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 157 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 171 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 111 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 40 of file Interval_defs.hh.

                             {
   const 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(), 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_Row< T >::DB_Row(), and Parma_Polyhedra_Library::Linear_Expression_Impl< Row >::Linear_Expression_Impl().

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

unsigned int Parma_Polyhedra_Library::ctz ( unsigned int u )

inline

Definition at line 186 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 200 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 214 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 121 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 131 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
	)

                                                                              {
   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 518 of file globals_defs.hh.

                   {
   return to.OK();
 }

void Parma_Polyhedra_Library::finalize ( )

inline

Finalizes the library.

Definition at line 60 of file initializer.hh.

References Parma_Polyhedra_Library::Implementation::finalize_aux().

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
   Implementation::finalize_aux();
 #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 190 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 177 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 443 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 449 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 455 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 461 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 467 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 474 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 52 of file initializer.hh.

References Parma_Polyhedra_Library::Implementation::initialize_aux().

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

              {
 #ifdef PPL_NO_AUTOMATIC_INITIALIZATION
   Implementation::initialize_aux();
 #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 = `Coefficient_one()`
	)

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 645 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 535 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 104 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 111 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 96 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< Target >::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(), Parma_Polyhedra_Library::Boundary_NS::is_domain_inf(), Parma_Polyhedra_Library::Boundary_NS::normal_is_boundary_infinity(), Parma_Polyhedra_Library::Boundary_NS::normal_is_reverse_infinity(), 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 168 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 452 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) {
     const 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 187 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.

                                 {
   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 88 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* const 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 843 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 835 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 815 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 518 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 821 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 174 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 181 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_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 832 of file Sparse_Row.cc.

                                                        {
   return !(x == y);
 }

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

Definition at line 842 of file Sparse_Row.cc.

                                                        {
   return !(x == y);
 }

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

inline

Definition at line 101 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 1037 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 1045 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 1053 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 989 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 997 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 1005 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 107 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 1013 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 1021 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 1029 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 1061 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 1069 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 1077 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 1085 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, 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 810 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 837 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 244 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_char;
   }
 
   // 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_char;
   }
 
   // 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_char:
     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 95 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 809 of file Checked_Number_inlines.hh.

References PLUS_INFINITY.

                 {
   return PLUS_INFINITY;
 }

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 )

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

Referenced by Parma_Polyhedra_Library::Checked_Number< T, Policy >::cmp(), is_integer(), is_minus_infinity(), is_not_a_number(), is_plus_infinity(), 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 549 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 551 of file Partially_Reduced_Product_templates.hh.

References EMPTY, Parma_Polyhedra_Library::Congruence::expression(), Parma_Polyhedra_Library::Poly_Con_Relation::is_included(), Parma_Polyhedra_Library::Congruence::modulus(), 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.expression());
 
   // 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);
 }

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

References Parma_Polyhedra_Library::Variable::m_swap().

Referenced by Parma_Polyhedra_Library::Variable::m_swap().

                                {
   x.m_swap(y);
 }

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 122 of file globals_defs.hh.

References PPL_COMPILE_TIME_CHECK.

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

template<typename Row >

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

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

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

Referenced by Parma_Polyhedra_Library::Swapping_Vector< T >::erase(), Parma_Polyhedra_Library::Swapping_Vector< T >::m_swap(), and Parma_Polyhedra_Library::Swapping_Vector< T >::reserve().

                                                          {
   vec1.m_swap(vec2);
 }

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

Definition at line 1171 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 1189 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().

Referenced by Parma_Polyhedra_Library::CO_Tree::const_iterator::m_swap(), Parma_Polyhedra_Library::CO_Tree::iterator::m_swap(), and Parma_Polyhedra_Library::CO_Tree::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

template<typename Unsigned >

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

inline

Definition at line 270 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