Parma_Polyhedra_Library Namespace Reference
[C++ Language Interface]

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

Classes

struct Compile_Time_Check< true >

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

struct Bool

A class holding a constant called value that evaluates to b. More...

struct True

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

struct False

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

struct Is_Same

A class holding a constant called value that evaluates to true if and only if T1 is the same type as T2. More...

struct Is_Same< T, T >

A class holding a constant called value that evaluates to true if and only if T1 is the same type as T2. More...

struct Is_Same_Or_Derived

A class holding a constant called value that evaluates to true if and only if Base is the same type as Derived or Derived is a class derived from Base. More...

struct Enable_If

A class that provides a type member called type equivalent to T if and only if b is true. More...

struct Enable_If_Is

struct Enable_If< true, T >

A class that provides a type member called type equivalent to T if and only if b is true. More...

struct Is_Native

struct Is_Native< signed char >

struct Is_Native< signed short >

struct Is_Native< signed int >

struct Is_Native< signed long >

struct Is_Native< signed long long >

struct Is_Native< unsigned char >

struct Is_Native< unsigned short >

struct Is_Native< unsigned int >

struct Is_Native< unsigned long >

struct Is_Native< unsigned long long >

struct Is_Native< mpz_class >

struct Is_Native< mpq_class >

struct float_ieee754_single

struct float_ieee754_double

struct float_intel_double_extended

struct float_ieee754_quad

class Float

struct Checked_Number_Default_Policy

struct Extended_Number_Policy

struct WRD_Extended_Number_Policy

struct Check_Overflow_Policy

A policy checking for overflows. More...

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

struct Native_Checked_From_Wrapper< Checked_Number< T, P > >

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

struct Native_Checked_To_Wrapper< Checked_Number< T, P > >

struct Is_Checked

struct Is_Checked< Checked_Number< T, P > >

struct Is_Native_Or_Checked

class Checked_Number

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

struct Slow_Copy< Checked_Number< T, P > >

struct FPU_Related< Checked_Number< T, Policy > >

struct Coefficient_traits_template< GMP_Integer >

Coefficient traits specialization for unbounded integers. More...

struct Coefficient_traits_template

Coefficient traits. More...

struct Minus_Infinity

struct Plus_Infinity

struct Not_A_Number

struct Is_Special

struct Is_Special< Minus_Infinity >

struct Is_Special< Plus_Infinity >

struct Is_Special< Not_A_Number >

struct Checked_Number_Transparent_Policy

class Init

Class for initialization and finalization. More...

class Throwable

User objects the PPL can throw. More...

struct From_Covering_Box

A tag class. More...

struct Recycle_Input

A tag class. More...

struct Fit

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

struct TConstant

struct Constant_

struct Constant_< T, v, prefer_signed, typename Enable_If<(Fit< typename C_Integer< T >::smaller_signed_type, v >::value &&(prefer_signed||!Fit< typename C_Integer< T >::smaller_unsigned_type, v >::value))>::type >

struct Constant_< T, v, prefer_signed, typename Enable_If<(Fit< typename C_Integer< T >::smaller_unsigned_type, v >::value &&(!prefer_signed||!Fit< typename C_Integer< T >::smaller_signed_type, v >::value))>::type >

struct Constant

struct Has_OK

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

struct Rectilinear_Distance_Specialization

struct Euclidean_Distance_Specialization

struct L_Infinity_Distance_Specialization

struct maybe_assign_struct

struct maybe_assign_struct< Type, Type >

class stdiobuf

class Row_Impl_Handler

The handler of the actual Row implementation. More...

class Row

A finite sequence of coefficients. More...

class Matrix

A 2-dimensional matrix of coefficients. More...

class Linear_Row

The base class for linear expressions, constraints and generators. More...

class Linear_System

The base class for systems of constraints and generators. More...

class MIP_Problem

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

class Bit_Row

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

class Bit_Matrix

A matrix of bits. More...

class Variable

A dimension of the vector space. More...

class Linear_Expression

A linear expression. More...

class Constraint

A linear equality or inequality. More...

class Congruence

A linear congruence. More...

class Generator

A line, ray, point or closure point. More...

class Grid_Generator

A grid line, parameter or grid point. More...

class Constraint_System

A system of constraints. More...

class Congruence_System

A system of congruences. More...

class Generator_System

A system of generators. More...

class Grid_Generator_System

A system of grid generators. More...

class Scalar_Products

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

class Topology_Adjusted_Scalar_Product_Sign

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

class Polyhedron

The base class for convex polyhedra. More...

class Grid

A grid. More...

class Poly_Con_Relation

The relation between a polyhedron and a constraint. More...

class Poly_Gen_Relation

The relation between a polyhedron and a generator. More...

struct Boundary_Value

struct Boundary_Value< T, typename Enable_If< Is_Same_Or_Derived< Interval_Base, T >::value >::type >

class Interval_Restriction_None_Base

class Interval_Restriction_None

class Interval_Restriction_Integer_Base

class Interval_Restriction_Integer

class Simple_Restriction_Integer

struct Restriction_Integer< From, Base, typename Enable_If< Is_Native_Or_Checked< From >::value >::type >

struct Restriction_Integer< From, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_None_Base, typename From::info_type >::value >::type >

struct Restriction_Integer< From, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_Integer_Base, typename From::info_type >::value >::type >

class Interval_Restriction_Integer_Modulo_Base

class Interval_Restriction_Integer_Modulo

struct Slow_Copy< Interval_Restriction_Integer_Modulo< T, Base > >

struct Restriction_Integer< From, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_Integer_Modulo_Base, typename From::info_type >::value >::type >

struct Simple_Restriction_Integer_Modulo

struct Restriction_Integer_Modulo< From, T, Base, typename Enable_If< Is_Native_Or_Checked< From >::value >::type >

struct Restriction_Integer_Modulo< From, T, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_None_Base, typename From::info_type >::value >::type >

struct Restriction_Integer_Modulo< From, T, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_Integer_Base, typename From::info_type >::value >::type >

struct Restriction_Integer_Modulo< From, T, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_Integer_Modulo_Base, typename From::info_type >::value >::type >

class Interval_Info_Null

class Interval_Info_Null_Open

class Interval_Info_Bitset

struct Interval_Base

struct Is_Singleton

struct Is_Interval

class Interval

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

struct Select_Temp_Boundary_Type

struct Select_Temp_Boundary_Type< float >

struct Select_Temp_Boundary_Type< signed char >

struct Select_Temp_Boundary_Type< unsigned char >

struct Select_Temp_Boundary_Type< signed short >

struct Select_Temp_Boundary_Type< unsigned short >

struct Select_Temp_Boundary_Type< signed int >

struct Select_Temp_Boundary_Type< unsigned int >

struct Select_Temp_Boundary_Type< signed long >

struct Select_Temp_Boundary_Type< unsigned long >

struct Select_Temp_Boundary_Type< unsigned long long >

class C_Polyhedron

A closed convex polyhedron. More...

class NNC_Polyhedron

A not necessarily closed convex polyhedron. More...

class Widening_Function

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

class Limited_Widening_Function

Wraps a limited widening method into a function object. More...

class BHRZ03_Certificate

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

class H79_Certificate

A convergence certificate for the H79 widening operator. More...

class Grid_Certificate

The convergence certificate for the Grid widening operator. More...

class Determinate

Wraps a PPL class into a determinate constraint system interface. More...

class iterator_to_const

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

class const_iterator_to_const

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

class Powerset

The powerset construction on a base-level domain. More...

class Pointset_Powerset

The powerset construction instantiated on PPL pointset domains. More...

class Smash_Reduction

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

class Constraints_Reduction

This class provides the reduction method for the Constraints_Product domain. More...

class No_Reduction

class Partially_Reduced_Product

The partially reduced product of two abstractions. More...

class Domain_Product

This class is temporary and will be removed when template typedefs will be supported in C++. More...

class Box

A not necessarily closed, iso-oriented hyperrectangle. More...

class DB_Row_Impl_Handler

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

class DB_Row

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

class DB_Matrix

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

class BD_Shape

A bounded difference shape. More...

class OR_Matrix

A matrix representing octagonal constraints. More...

class Octagonal_Shape

An octagonal shape. More...

class GMP_Integer

Unbounded integers as provided by the GMP library. More...

Namespaces

namespace Checked

Types and functions implementing checked numbers.

namespace Implementation

Implementation related data and functions.

namespace Interfaces

Data and functions related to foreign language interfaces.

namespace Interval_NS

namespace IO_Operators

All input/output operators are confined to this namespace.

Typedefs

typedef mpz_class GMP_Integer

typedef PPL_COEFFICIENT_TYPE Coefficient

An alias for easily naming the type of PPL coefficients.

typedef
Coefficient_traits_template
< Coefficient > Coefficient_traits

An alias for easily naming the coefficient traits.

typedef size_t dimension_type

An unsigned integral type for representing space dimensions.

typedef size_t memory_size_type

An unsigned integral type for representing memory size in bytes.

Enumerations

enum Degenerate_Element { UNIVERSE, EMPTY }

Kinds of degenerate abstract elements. More...

enum Relation_Symbol {
LESS_THAN, LESS_OR_EQUAL, EQUAL, GREATER_OR_EQUAL,
GREATER_THAN, NOT_EQUAL
}

Relation symbols. More...

enum Complexity_Class { POLYNOMIAL_COMPLEXITY, SIMPLEX_COMPLEXITY, ANY_COMPLEXITY }

Complexity pseudo-classes. More...

enum Optimization_Mode { MINIMIZATION, MAXIMIZATION }

Possible optimization modes. More...

enum Topology { NECESSARILY_CLOSED = 0, NOT_NECESSARILY_CLOSED = 1 }

Kinds of polyhedra domains. More...

enum MIP_Problem_Status { UNFEASIBLE_MIP_PROBLEM, UNBOUNDED_MIP_PROBLEM, OPTIMIZED_MIP_PROBLEM }

Possible outcomes of the MIP_Problem solver. More...

enum I_Result { I_EMPTY = 0, I_MAYBE_EMPTY = 1 << 12, I_SINGULARITIES = 1 << 13 }

enum Ternary { T_YES, T_NO, T_MAYBE }

Functions

unsigned version_major ()

Returns the major number of the PPL version.

unsigned version_minor ()

Returns the minor number of the PPL version.

unsigned version_revision ()

Returns the revision number of the PPL version.

unsigned version_beta ()

Returns the beta number of the PPL version.

const char * version ()

Returns a character string containing the PPL version.

const char * banner ()

Returns a character string containing the PPL banner.

void throw_result_exception (Result r)

template<typename T>

T plus_infinity ()

template<typename T>

T minus_infinity ()

template<typename T>

T not_a_number ()

template<typename T>

void maybe_reset_fpu_inexact ()

template<typename T>

int maybe_check_fpu_inexact ()

Rounding_Dir rounding_dir (Rounding_Dir dir)

Result check_result (Result r, Rounding_Dir dir)

COND (PPL_SUPPORTED_FLOAT, DEF_CTOR(float)) COND(PPL_SUPPORTED_DOUBLE

DEF_CTOR (double)) COND(PPL_SUPPORTED_LONG_DOUBLE

DEF_CTOR (long double)) template< typename T

template<typename To, typename From>

Enable_If
< Is_Native_Or_Checked< To >
::value &&Is_Special< From >
::value, Result >::type assign_r (To &to, const From &, Rounding_Dir dir)

template<typename To, typename From>

Enable_If
< Is_Native_Or_Checked< To >
::value &&Is_Special< From >
::value, Result >::type construct (To &to, const From &, Rounding_Dir dir)

template<typename T>

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

template<typename T>

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

template<typename T>

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

template<typename T>

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

template<typename T>

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

template<typename T, typename Policy>

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

template<typename T, typename Policy>

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

template<typename T, typename Policy>

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

template<typename T, typename Policy>

void exact_div_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y, const Checked_Number< T, Policy > &z)

void neg_assign (GMP_Integer &x)

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

void abs_assign (GMP_Integer &x)

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

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

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

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

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

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

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

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

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

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

const mpz_class & raw_value (const GMP_Integer &x)

mpz_class & raw_value (GMP_Integer &x)

void Coefficient_constants_initialize ()

Initializes the Coefficient constants.

void Coefficient_constants_finalize ()

Finalizes the Coefficient constants.

Coefficient_traits::const_reference Coefficient_zero ()

Returns a const reference to a Coefficient with value 0.

Coefficient_traits::const_reference Coefficient_one ()

Returns a const reference to a Coefficient with value 1.

unsigned rational_sqrt_precision_parameter ()

Returns the precision parameter used for rational square root calculations.

void set_rational_sqrt_precision_parameter (const unsigned p)

Sets the precision parameter used for rational square root calculations.

void set_rounding_for_PPL ()

Sets the FPU rounding mode so that the PPL abstractions based on floating point numbers work correctly.

void restore_pre_PPL_rounding ()

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

void initialize ()

Initializes the library.

void finalize ()

Finalizes the library.

dimension_type not_a_dimension ()

Returns a value that does not designate a valid dimension.

template<typename T>

Enable_If< Slow_Copy< T >
::value, void >::type swap (T &, T &)

Make sure swap() is specialized when needed.

dimension_type compute_capacity (dimension_type requested_size, dimension_type maximum_size)

Speculative allocation function.

dimension_type compute_capacity (dimension_type requested_size)

template<typename T>

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

void maybe_abandon ()

template<typename T, typename Policy>

void numer_denom (const Checked_Number< T, Policy > &from, Coefficient &num, Coefficient &den)

Extract the numerator and denominator components of from.

template<typename T, typename Policy>

void div_round_up (Checked_Number< T, Policy > &to, Coefficient_traits::const_reference x, Coefficient_traits::const_reference y)

Divides x by y into to, rounding the result towards plus infinity.

template<typename N>

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

Assigns to x the minimum between x and y.

template<typename N>

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

Assigns to x the maximum between x and y.

template<typename T, typename Policy>

bool is_even (const Checked_Number< T, Policy > &x)

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

template<typename T, typename Policy>

bool is_additive_inverse (const Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y)

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

void normalize2 (Coefficient_traits::const_reference x, Coefficient_traits::const_reference y, Coefficient &nx, Coefficient &ny)

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

bool is_canonical (const mpq_class &x)

Returns true if and only if x is in canonical form.

template<typename T>

T low_bits_mask (unsigned n)

Returns a mask for the lowest n bits,.

template<typename To, typename From>

Result maybe_assign (const To *&top, To &tmp, const From &from, Rounding_Dir dir)

Assigns to top a pointer to a location that holds the conversion, according to dir, of from to type To. When necessary, and only when necessary, the variable tmp is used to hold the result of conversion.

bool eq_restriction (const Interval_Restriction_None_Base &, const Interval_Restriction_None_Base)

template<typename T>

bool contains_restriction (const Interval_Restriction_None_Base &, const T &)

template<typename T>

bool assign_restriction (Interval_Restriction_None_Base &, const T &)

template<typename T1, typename T2>

bool join_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &)

template<typename T1, typename T2>

bool intersect_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &)

template<typename T1, typename T2>

bool diff_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &)

template<typename T>

bool neg_restriction (Interval_Restriction_None_Base &, const T &)

template<typename T1, typename T2>

bool add_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &)

template<typename T1, typename T2>

bool sub_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &)

template<typename T1, typename T2>

bool mul_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &)

template<typename T1, typename T2>

bool div_restriction (Interval_Restriction_None_Base &, const T1 &, const T2 &)

void output_restriction (std::ostream &, const Interval_Restriction_None_Base &)

template<typename T1, typename T2>

Enable_If< Is_Same_Or_Derived
< Interval_Restriction_Integer_Base,
T1 >::value
&&Is_Same_Or_Derived
< Interval_Restriction_Integer_Base,
T2 >::value, bool >::type eq_restriction (const T1 &x, const T2 &y)

template<typename T1, typename T2>

Enable_If< Is_Same_Or_Derived
< Interval_Restriction_Integer_Base,
T1 >::value
&&Is_Same_Or_Derived
< Interval_Restriction_Integer_Base,
T2 >::value, bool >::type contains_restriction (const T1 &x, const T2 &y)

template<typename Base, typename From>

bool assign_restriction (Interval_Restriction_Integer< Base > &to, const From &x)

template<typename Base, typename From1, typename From2>

bool join_restriction (Interval_Restriction_Integer< Base > &to, const From1 &x, const From2 &y)

template<typename Base, typename From1, typename From2>

bool intersect_restriction (Interval_Restriction_Integer< Base > &to, const From1 &x, const From2 &y)

template<typename Base, typename From1, typename From2>

bool diff_restriction (Interval_Restriction_Integer< Base > &to, const From1 &x, const From2 &)

template<typename Base, typename From>

bool neg_restriction (Interval_Restriction_Integer< Base > &to, const From &x)

template<typename Base, typename From1, typename From2>

bool add_restriction (Interval_Restriction_Integer< Base > &to, const From1 &x, const From2 &y)

template<typename Base, typename From1, typename From2>

bool sub_restriction (Interval_Restriction_Integer< Base > &to, const From1 &x, const From2 &y)

template<typename Base, typename From1, typename From2>

bool mul_restriction (Interval_Restriction_Integer< Base > &to, const From1 &x, const From2 &y)

template<typename Base, typename From1, typename From2>

bool div_restriction (Interval_Restriction_Integer< Base > &to, const From1 &, const From2 &)

template<typename Base>

void output_restriction (std::ostream &s, const Interval_Restriction_Integer< Base > &x)

template<typename T, typename Base>

bool set_unrestricted (Interval_Restriction_Integer_Modulo< T, Base > &to)

template<typename T, typename Base>

bool set_integer (Interval_Restriction_Integer_Modulo< T, Base > &to)

template<typename T, typename Base, typename From>

bool assign_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From &x)

template<typename T, typename Base, typename From1, typename From2>

bool join_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y)

template<typename T, typename Base, typename From1, typename From2>

bool intersect_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y)

template<typename T, typename Base, typename From1, typename From2>

bool diff_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y)

template<typename T, typename Base, typename From>

bool neg_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From &x)

template<typename T>

void addmod (T &to, const T &x, const T &y, const T &to_m, const T &y_m)

template<typename M, typename T>

bool assign_rem (M &rem, const T &n, const M &div)

template<typename T, typename Base, typename From1, typename From2>

bool add_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y)

template<typename T>

void submod (T &to, const T &x, const T &y, const T &to_m, const T &y_m)

template<typename T, typename Base, typename From1, typename From2>

bool sub_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y)

template<typename T>

void mulmod (T &to, const T &x, const T &y, const T &to_m)

template<typename T, typename Base, typename From1, typename From2>

bool mul_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y)

template<typename T, typename Base, typename From1, typename From2>

bool div_restriction (Interval_Restriction_Integer_Modulo< T, Base > &to, const From1 &x, const From2 &y)

template<typename T, typename Base>

void output_restriction (std::ostream &s, const Interval_Restriction_Integer_Modulo< T, Base > &x)

I_Result combine (Result l, Result u)

Result lower (I_Result r)

Result upper (I_Result r)

template<typename Info>

bool unrepresentability_error (I_Result r, const Info &)

template<typename Boundary, typename Info>

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

template<typename Boundary, typename Info>

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

template<typename Boundary, typename Info>

int is_infinity (const Interval< Boundary, Info > &x)

bool is_integer (const char *)

bool is_not_a_number (const char *)

template<typename T>

Enable_If< Is_Singleton< T >
::value||Is_Interval< T >
::value, bool >::type is_singleton_integer (const T &x)

template<typename T1, typename T2>

bool same_object (const T1 &, const T2 &)

template<typename T>

bool same_object (const T &x, const T &y)

template<typename T>

Enable_If< Is_Singleton< T >
::value||Is_Interval< T >
::value, bool >::type check_empty_arg (const T &x)

template<typename Boundary, typename Info>

I_Result check_empty_result (const Interval< Boundary, Info > &x, I_Result r)

template<typename T1, typename T2>

Enable_If<((Is_Singleton< T1 >
::value||Is_Interval< T1 >
::value)&&(Is_Singleton< T2 >
::value||Is_Interval< T2 >
::value)&&(Is_Interval< T1 >
::value||Is_Interval< T2 >
::value)), bool >::type operator== (const T1 &x, const T2 &y)

template<typename T1, typename T2>

Enable_If<((Is_Singleton< T1 >
::value||Is_Interval< T1 >
::value)&&(Is_Singleton< T2 >
::value||Is_Interval< T2 >
::value)&&(Is_Interval< T1 >
::value||Is_Interval< T2 >
::value)), bool >::type operator!= (const T1 &x, const T2 &y)

template<typename B, typename Info, typename T>

Enable_If< Is_Singleton< T >
::value, Interval< B, Info >
>::type operator+ (const Interval< B, Info > &x, const T &y)

template<typename B, typename Info, typename T>

Enable_If< Is_Singleton< T >
::value, Interval< B, Info >
>::type operator+ (const T &x, const Interval< B, Info > &y)

template<typename B, typename Info>

Interval< B, Info > operator+ (const Interval< B, Info > &x, const Interval< B, Info > &y)

template<typename B, typename Info, typename T>

Enable_If< Is_Singleton< T >
::value, Interval< B, Info >
>::type operator- (const Interval< B, Info > &x, const T &y)

template<typename B, typename Info, typename T>

Enable_If< Is_Singleton< T >
::value, Interval< B, Info >
>::type operator- (const T &x, const Interval< B, Info > &y)

template<typename B, typename Info>

Interval< B, Info > operator- (const Interval< B, Info > &x, const Interval< B, Info > &y)

template<typename B, typename Info, typename T>

Enable_If< Is_Singleton< T >
::value, Interval< B, Info >
>::type operator* (const Interval< B, Info > &x, const T &y)

template<typename B, typename Info, typename T>

Enable_If< Is_Singleton< T >
::value, Interval< B, Info >
>::type operator* (const T &x, const Interval< B, Info > &y)

template<typename B, typename Info>

Interval< B, Info > operator* (const Interval< B, Info > &x, const Interval< B, Info > &y)

template<typename B, typename Info, typename T>

Enable_If< Is_Singleton< T >
::value, Interval< B, Info >
>::type operator/ (const Interval< B, Info > &x, const T &y)

template<typename B, typename Info, typename T>

Enable_If< Is_Singleton< T >
::value, Interval< B, Info >
>::type operator/ (const T &x, const Interval< B, Info > &y)

template<typename B, typename Info>

Interval< B, Info > operator/ (const Interval< B, Info > &x, const Interval< B, Info > &y)

template<typename Boundary, typename Info>

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

template<typename ITV>

Poly_Con_Relation interval_relation (const ITV &i, const Constraint::Type constraint_type, Coefficient_traits::const_reference num, Coefficient_traits::const_reference den=1)

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

bool extract_interval_congruence (const Congruence &cg, dimension_type cg_space_dim, dimension_type &cg_num_vars, dimension_type &cg_only_var)

template<typename ITV>

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

template<typename ITV>

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

bool propagate_constraint_check_result (Result r, Ternary &open)

unsigned long isqrt (unsigned long x)

Returns the integer square root of x.

Relational Operators and Comparison Functions

template<typename T1, typename T2>

Enable_If
< Is_Native_Or_Checked< T1 >
::value &&Is_Native_Or_Checked
< T2 >::value, bool >::type equal (const T1 &x, const T2 &y)

template<typename T1, typename T2>

Enable_If
< Is_Native_Or_Checked< T1 >
::value &&Is_Native_Or_Checked
< T2 >::value, bool >::type not_equal (const T1 &x, const T2 &y)

template<typename T1, typename T2>

Enable_If
< Is_Native_Or_Checked< T1 >
::value &&Is_Native_Or_Checked
< T2 >::value, bool >::type greater_or_equal (const T1 &x, const T2 &y)

template<typename T1, typename T2>

Enable_If
< Is_Native_Or_Checked< T1 >
::value &&Is_Native_Or_Checked
< T2 >::value, bool >::type greater_than (const T1 &x, const T2 &y)

template<typename T1, typename T2>

Enable_If
< Is_Native_Or_Checked< T1 >
::value &&Is_Native_Or_Checked
< T2 >::value, bool >::type less_or_equal (const T1 &x, const T2 &y)

template<typename T1, typename T2>

Enable_If
< Is_Native_Or_Checked< T1 >
::value &&Is_Native_Or_Checked
< T2 >::value, bool >::type less_than (const T1 &x, const T2 &y)

Input-Output Operators

template<typename T>

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

Ascii dump for native or checked.

template<typename T>

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

Ascii load for native or checked.

Memory Size Inspection Functions

memory_size_type total_memory_in_bytes (const GMP_Integer &x)

memory_size_type external_memory_in_bytes (const GMP_Integer &x)

Memory Size Inspection Functions

template<typename T>

Enable_If< Is_Native< T >
::value, memory_size_type >
::type total_memory_in_bytes (const T &)

For native types, returns the total size in bytes of the memory occupied by the type of the (unused) parameter, i.e., 0.

template<typename T>

Enable_If< Is_Native< T >
::value, memory_size_type >
::type external_memory_in_bytes (const T &)

For native types, returns the size in bytes of the memory managed by the type of the (unused) parameter, i.e., 0.

memory_size_type total_memory_in_bytes (const mpz_class &x)

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

memory_size_type external_memory_in_bytes (const mpz_class &x)

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

memory_size_type total_memory_in_bytes (const mpq_class &x)

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

memory_size_type external_memory_in_bytes (const mpq_class &x)

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

Variables

const Throwable *volatile abandon_expensive_computations = 0

A pointer to an exception object.

Detailed Description

The entire library is confined to this namespace.

Typedef Documentation

typedef mpz_class Parma_Polyhedra_Library::GMP_Integer

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

Enumeration Type Documentation

enum Parma_Polyhedra_Library::I_Result

Enumerator:

I_EMPTY
I_MAYBE_EMPTY
I_SINGULARITIES

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

00038               {
00039   I_EMPTY = 0,
00040   /*
00041   I_L_EQ = V_EQ,
00042   I_L_GT = V_GT,
00043   I_L_GE = V_GE,
00044   I_U_EQ = V_EQ << 6,
00045   I_U_LT = V_LT << 6,
00046   I_U_LE = V_LE << 6,
00047   */
00048   I_MAYBE_EMPTY = 1 << 12,
00049   I_SINGULARITIES = 1 << 13
00050 };

enum Parma_Polyhedra_Library::Ternary

Enumerator:

T_YES
T_NO
T_MAYBE

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

00052 { T_YES, T_NO, T_MAYBE };

Function Documentation

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

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

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

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

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

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

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

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

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

Referenced by Parma_Polyhedra_Library::Constraint_System::affine_preimage(), Parma_Polyhedra_Library::Congruence_System::affine_preimage(), Parma_Polyhedra_Library::Scalar_Products::assign(), Parma_Polyhedra_Library::Scalar_Products::homogeneous_assign(), Parma_Polyhedra_Library::Grid::reduce_pc_with_pc(), Parma_Polyhedra_Library::Scalar_Products::reduced_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::relation_with(), Parma_Polyhedra_Library::BD_Shape< T >::relation_with(), and Parma_Polyhedra_Library::MIP_Problem::steepest_edge_exact_entering_index().

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

template<typename T, typename Base, typename From1, typename From2>

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

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

References addmod(), assign_r(), assign_rem(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder, set_integer(), and set_unrestricted().

00673                                                                                                   {
00674   typedef Restriction_Integer_Modulo<From1, T, Base> Rx;
00675   const typename Rx::type& rx = Rx::get(x);
00676   if (rx.divisor == 0)
00677     return set_unrestricted(to);
00678   typedef Restriction_Integer_Modulo<From2, T, Base> Ry;
00679   const typename Ry::type& ry = Ry::get(y);
00680   if (ry.divisor == 0)
00681     return set_unrestricted(to);
00682   Result r;
00683   DIRTY_TEMP(T, rem);
00684   if (is_singleton(x)) {
00685     if (is_singleton(y))
00686       return set_integer(to);
00687     if (!assign_rem(rem, f_lower(x), ry.divisor))
00688       return set_integer(to);
00689     r = assign_r(to.divisor, ry.divisor, ROUND_NOT_NEEDED);
00690     assert(r == V_EQ);
00691     addmod(to.remainder, rem, ry.remainder, to.divisor, ry.divisor);
00692   }
00693   else if (is_singleton(y)) {
00694     if (!assign_rem(rem, f_lower(y), rx.divisor))
00695       return set_integer(to);
00696     r = assign_r(to.divisor, rx.divisor, ROUND_NOT_NEEDED);
00697     assert(r == V_EQ);
00698     addmod(to.remainder, rx.remainder, rem, to.divisor, to.divisor);
00699   }
00700   else {
00701     r = gcd_assign_r(to.divisor, rx.divisor, ry.divisor, ROUND_NOT_NEEDED);
00702     assert(r == V_EQ);
00703     addmod(to.remainder, rx.remainder, ry.remainder, to.divisor, ry.divisor);
00704   }
00705   return true;
00706 }

template<typename Base, typename From1, typename From2>

bool Parma_Polyhedra_Library::add_restriction	(	Interval_Restriction_Integer< Base > &	to,
		const From1 &	x,
		const From2 &	y
	)			`[inline]`

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().

00275                                                                                         {
00276   to.set_integer(Restriction_Integer<From1, Base>::get(x).get_integer()
00277                  && Restriction_Integer<From2, Base>::get(y).get_integer());
00278   return true;
00279 }

template<typename T1, typename T2>

bool Parma_Polyhedra_Library::add_restriction	(	Interval_Restriction_None_Base &	,
		const T1 &	,
		const T2 &
	)			`[inline]`

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

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

00100                                                                        {
00101   return true;
00102 }

template<typename T>

void Parma_Polyhedra_Library::addmod	(	T &	to,
		const T &	x,
		const T &	y,
		const T &	to_m,
		const T &	y_m
	)			`[inline]`

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

Referenced by add_restriction().

00627                                                                    {
00628   Result r;
00629   if (std::numeric_limits<T>::is_bounded) {
00630     r = sub_assign_r(to, y_m, y, ROUND_NOT_NEEDED);
00631     assert(r == V_EQ);
00632     if (x <= to) {
00633       r = add_assign_r(to, x, y, ROUND_NOT_NEEDED);
00634       assert(r == V_EQ);
00635     }
00636     else {
00637       r = sub_assign_r(to, x, to, ROUND_NOT_NEEDED);
00638       assert(r == V_EQ);
00639     }
00640   }
00641   else {
00642     r = add_assign_r(to, x, y, ROUND_NOT_NEEDED);
00643     assert(r == V_EQ);
00644   }
00645   r = rem_assign_r(to, to, to_m, ROUND_NOT_NEEDED);
00646   assert(r == V_EQ);
00647 }

template<typename T>

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

Ascii dump for native or checked.

Referenced by Parma_Polyhedra_Library::Linear_Expression::ascii_dump(), Parma_Polyhedra_Library::Interval< Boundary, Info >::ascii_dump(), Parma_Polyhedra_Library::Generator::ascii_dump(), and Parma_Polyhedra_Library::Constraint::ascii_dump().

template<typename T>

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

Ascii load for native or checked.

Referenced by Parma_Polyhedra_Library::Linear_Expression::ascii_load(), Parma_Polyhedra_Library::Interval< Boundary, Info >::ascii_load(), Parma_Polyhedra_Library::Generator::ascii_load(), and Parma_Polyhedra_Library::Constraint::ascii_load().

template<typename To, typename From>

Enable_If<Is_Native_Or_Checked<To>::value && Is_Special<From>::value, Result>::type Parma_Polyhedra_Library::assign_r	(	To &	to,
		const From &	,
		Rounding_Dir	dir
	)			`[related]`

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

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

00211                                                 {
00212   return check_result(Checked::assign_special<typename Native_Checked_To_Wrapper<To>
00213                       ::Policy>(Native_Checked_To_Wrapper<To>::raw_value(to),
00214                                 From::code,
00215                                 rounding_dir(dir)),
00216                       dir);
00217 }

template<typename M, typename T>

bool Parma_Polyhedra_Library::assign_rem	(	M &	rem,
		const T &	n,
		const M &	div
	)			`[inline]`

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

References assign_r().

Referenced by add_restriction(), and sub_restriction().

00651                                              {
00652   DIRTY_TEMP(T, divisor);
00653   DIRTY_TEMP(T, remainder);
00654   Result r;
00655   r = assign_r(divisor, div, ROUND_CHECK);
00656   if (r != V_EQ)
00657     return false;
00658   r = rem_assign_r(remainder, n, divisor, ROUND_CHECK);
00659   if (r != V_EQ)
00660     return false;
00661   if (sgn(remainder) < 0) {
00662     r = add_assign_r(remainder, remainder, divisor, ROUND_CHECK);
00663     if (r != V_EQ)
00664       return false;
00665   }
00666   r = assign_r(rem, remainder, ROUND_CHECK);
00667   return r == V_EQ;
00668 }

template<typename T, typename Base, typename From>

bool Parma_Polyhedra_Library::assign_restriction	(	Interval_Restriction_Integer_Modulo< T, Base > &	to,
		const From &	x
	)			`[inline]`

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, and Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder.

00515                                                                                     {
00516   to.remainder = Restriction_Integer_Modulo<From, T, Base>::get(x).remainder;
00517   to.divisor = Restriction_Integer_Modulo<From, T, Base>::get(x).divisor;
00518   return true;
00519 }

template<typename Base, typename From>

bool Parma_Polyhedra_Library::assign_restriction	(	Interval_Restriction_Integer< Base > &	to,
		const From &	x
	)			`[inline]`

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().

00237                                                                           {
00238   to.set_integer(Restriction_Integer<From, Base>::get(x).get_integer());
00239   return true;
00240 }

template<typename T>

bool Parma_Polyhedra_Library::assign_restriction	(	Interval_Restriction_None_Base &	,
		const T &
	)			`[inline]`

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

Referenced by neg_restriction().

00070                                                               {
00071   return true;
00072 }

const char * Parma_Polyhedra_Library::banner ( )

Returns a character string containing the PPL banner.

The banner provides information about the PPL version, the licensing, the lack of any warranty whatsoever, the C++ compiler used to build the library, where to report bugs and where to look for further information.

Definition at line 98 of file version.cc.

References banner_string.

00098             {
00099   return banner_string;
00100 }

template<typename T>

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

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

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

00172                             {
00173   if (f_info(x).may_be_empty)
00174     return f_is_empty(x);
00175   else {
00176     assert(!f_is_empty(x));
00177     return false;
00178   }
00179 }

template<typename Boundary, typename Info>

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

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

References f_is_empty(), I_EMPTY, and I_MAYBE_EMPTY.

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

00183                                                                   {
00184   if (Info::check_empty_result && f_is_empty(x))
00185     return I_EMPTY;
00186   else
00187     return static_cast<I_Result>(r | I_MAYBE_EMPTY);
00188 }

Result Parma_Polyhedra_Library::check_result	(	Result	r,
		Rounding_Dir	dir
	)			`[inline]`

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

Referenced by Parma_Polyhedra_Library::Checked_Number< T, Policy >::assign_r(), assign_r(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number(), construct(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::input(), and Parma_Polyhedra_Library::Checked_Number< T, Policy >::output().

00045                                          {
00046   if (dir == ROUND_NOT_NEEDED && !is_special(r)) {
00047 #ifdef DEBUG_ROUND_NOT_NEEDED
00048     // FIXME: this is wrong. If an overflow happens the Result may be
00049     // V_LT or V_GT. What's the better way to cope with that?
00050     assert(r == V_EQ);
00051 #else
00052     return V_EQ;
00053 #endif
00054   }
00055   return r;
00056 }

int Parma_Polyhedra_Library::cmp	(	const GMP_Integer &	x,
		const GMP_Integer &	y
	)			`[related]`

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

Referenced by Parma_Polyhedra_Library::Polyhedron::add_and_minimize(), Parma_Polyhedra_Library::Checked::cmp_mp(), Parma_Polyhedra_Library::Linear_Row::compare(), and Parma_Polyhedra_Library::Linear_System::sort_pending_and_remove_duplicates().

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

void Parma_Polyhedra_Library::Coefficient_constants_finalize ( )

Finalizes the Coefficient constants.

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

void Parma_Polyhedra_Library::Coefficient_constants_initialize ( )

Initializes the Coefficient constants.

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

Coefficient_traits::const_reference Parma_Polyhedra_Library::Coefficient_one ( )

Returns a const reference to a Coefficient with value 1.

Referenced by Parma_Polyhedra_Library::Constraint::initialize().

Coefficient_traits::const_reference Parma_Polyhedra_Library::Coefficient_zero ( )

Returns a const reference to a Coefficient with value 0.

Referenced by Parma_Polyhedra_Library::Linear_Expression::coefficient(), Parma_Polyhedra_Library::Polyhedron::conversion(), Parma_Polyhedra_Library::Linear_Expression::initialize(), Parma_Polyhedra_Library::Constraint::operator<<(), and Parma_Polyhedra_Library::Congruence::operator<<().

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

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

00055                             {
00056   return static_cast<I_Result>(l | (u << 6));
00057 }

dimension_type Parma_Polyhedra_Library::compute_capacity ( dimension_type requested_size ) [inline]

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

00062                                                       {
00063   // Speculation factor 2.
00064   return 2*(requested_size + 1);
00065   // Speculation factor 1.5.
00066   // return requested_size + requested_size/2 + 1;
00067 }

dimension_type Parma_Polyhedra_Library::compute_capacity	(	dimension_type	requested_size,
		dimension_type	maximum_size
	)			`[inline]`

Speculative allocation function.

Returns:: The actual capacity to be allocated.

Parameters:

	requested_size	The number of elements we need.
	maximum_size	The maximum number of elements to be allocated. It is assumed to be no less than `requested_size`.

Computes a capacity given a requested size. Allows for speculative allocation aimed at reducing the number of reallocations enough to guarantee amortized constant insertion time for our vector-like data structures. In all cases, the speculative allocation will not exceed maximum_size.

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

00048                                                     {
00049   assert(requested_size <= maximum_size);
00050   // Speculation factor 2.
00051   return (requested_size < maximum_size / 2)
00052     ? 2*(requested_size + 1)
00053     : maximum_size;
00054   // Speculation factor 1.5.
00055   // return (maximum_size - requested_size > requested_size/2)
00056   //   ? requested_size + requested_size/2 + 1
00057   //   : maximum_size;
00058 }

Parma_Polyhedra_Library::COND	(	PPL_SUPPORTED_FLOAT	,
		DEF_CTOR(float)
	)

template<typename To, typename From>

Enable_If<Is_Native_Or_Checked<To>::value && Is_Special<From>::value, Result>::type Parma_Polyhedra_Library::construct	(	To &	to,
		const From &	,
		Rounding_Dir	dir
	)			`[related]`

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

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

Referenced by Parma_Polyhedra_Library::Linear_System::add_pending_row(), Parma_Polyhedra_Library::Matrix::add_zero_rows(), Parma_Polyhedra_Library::Linear_Row::construct(), Parma_Polyhedra_Library::DB_Row_Impl_Handler< T >::Impl::construct_upward_approximation(), Parma_Polyhedra_Library::DB_Matrix< T >::DB_Matrix(), Parma_Polyhedra_Library::DB_Matrix< T >::grow(), Parma_Polyhedra_Library::Matrix::Matrix(), Parma_Polyhedra_Library::Matrix::resize_no_copy(), and Parma_Polyhedra_Library::DB_Matrix< T >::resize_no_copy().

00221                                                  {
00222   return check_result(Checked::construct_special<typename Native_Checked_To_Wrapper<To>
00223                       ::Policy>(Native_Checked_To_Wrapper<To>::raw_value(to),
00224                                 From::code,
00225                                 rounding_dir(dir)),
00226                       dir);
00227 }

template<typename T1, typename T2>

Enable_If< Is_Same_Or_Derived< Interval_Restriction_Integer_Modulo_Base, T1 >::value &&Is_Same_Or_Derived< Interval_Restriction_Integer_Modulo_Base, T2 >::value, bool >::type Parma_Polyhedra_Library::contains_restriction	(	const T1 &	x,
		const T2 &	y
	)			`[inline]`

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

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

template<typename T>

bool Parma_Polyhedra_Library::contains_restriction	(	const Interval_Restriction_None_Base &	,
		const T &
	)			`[inline]`

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

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::contains(), join_restriction(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::strictly_contains().

00064                                                                       {
00065   return true;
00066 }

Parma_Polyhedra_Library::DEF_CTOR ( long double )

Parma_Polyhedra_Library::DEF_CTOR ( double )

template<typename T, typename Base, typename From1, typename From2>

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

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

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

template<typename Base, typename From1, typename From2>

bool Parma_Polyhedra_Library::diff_restriction	(	Interval_Restriction_Integer< Base > &	to,
		const From1 &	x,
		const From2 &
	)			`[inline]`

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().

00261                                                {
00262   to.set_integer(Restriction_Integer<From1, Base>::get(x).get_integer());
00263   return true;
00264 }

template<typename T1, typename T2>

bool Parma_Polyhedra_Library::diff_restriction	(	Interval_Restriction_None_Base &	,
		const T1 &	,
		const T2 &
	)			`[inline]`

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

00088                                                                         {
00089   return true;
00090 }

template<typename T, typename Base, typename From1, typename From2>

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

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

References set_unrestricted().

00847                                                                                                   {
00848   if (is_singleton(y)) {
00849     if (is_singleton(x)) {
00850       // FIXME: to be written
00851     }
00852   }
00853   return set_unrestricted(to);
00854 }

template<typename Base, typename From1, typename From2>

bool Parma_Polyhedra_Library::div_restriction	(	Interval_Restriction_Integer< Base > &	to,
		const From1 &	,
		const From2 &
	)			`[inline]`

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().

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

template<typename T1, typename T2>

bool Parma_Polyhedra_Library::div_restriction	(	Interval_Restriction_None_Base &	,
		const T1 &	,
		const T2 &
	)			`[inline]`

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

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

00118                                                                        {
00119   return true;
00120 }

template<typename T, typename Policy>

void Parma_Polyhedra_Library::div_round_up	(	Checked_Number< T, Policy > &	to,
		Coefficient_traits::const_reference	x,
		Coefficient_traits::const_reference	y
	)			`[inline]`

Divides x by y into to, rounding the result towards plus infinity.

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

References assign_r().

00066                                                   {
00067   DIRTY_TEMP0(mpq_class, qx);
00068   DIRTY_TEMP0(mpq_class, qy);
00069   // Note: this code assumes that a Coefficient is always convertible
00070   // to an mpq_class without loss of precision.
00071   assign_r(qx, x, ROUND_NOT_NEEDED);
00072   assign_r(qy, y, ROUND_NOT_NEEDED);
00073   div_assign_r(qx, qx, qy, ROUND_NOT_NEEDED);
00074   assign_r(to, qx, ROUND_UP);
00075 }

template<typename T1, typename T2>

Enable_If< Is_Same_Or_Derived< Interval_Restriction_Integer_Modulo_Base, T1 >::value &&Is_Same_Or_Derived< Interval_Restriction_Integer_Modulo_Base, T2 >::value, bool >::type Parma_Polyhedra_Library::eq_restriction	(	const T1 &	x,
		const T2 &	y
	)			`[inline]`

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

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

bool Parma_Polyhedra_Library::eq_restriction	(	const Interval_Restriction_None_Base &	,
		const	Interval_Restriction_None_Base
	)			`[inline]`

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

Referenced by operator==(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::strictly_contains().

00058                                                                                             {
00059   return true;
00060 }

template<typename T1, typename T2>

Enable_If<Is_Native_Or_Checked<T1>::value && Is_Native_Or_Checked<T2>::value, bool>::type Parma_Polyhedra_Library::equal	(	const T1 &	x,
		const T2 &	y
	)			`[inline]`

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

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

00082                                                                              {
00083   assert(y % z == 0);
00084   mpz_divexact(x.get_mpz_t(), y.get_mpz_t(), z.get_mpz_t());
00085 }

template<typename T, typename Policy>

void Parma_Polyhedra_Library::exact_div_assign	(	Checked_Number< T, Policy > &	x,
		const Checked_Number< T, Policy > &	y,
		const Checked_Number< T, Policy > &	z
	)			`[related]`

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

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

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

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

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

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

00094                                              {
00095   return external_memory_in_bytes(x.get_num())
00096     + external_memory_in_bytes(x.get_den());
00097 }

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

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

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

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

template<typename T>

Enable_If< Is_Native< T >::value, memory_size_type >::type Parma_Polyhedra_Library::external_memory_in_bytes ( const T & ) [inline]

For native types, returns the size in bytes of the memory managed by the type of the (unused) parameter, i.e., 0.

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

00072                                    {
00073   return 0;
00074 }

memory_size_type Parma_Polyhedra_Library::external_memory_in_bytes ( const GMP_Integer & x )

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::external_memory_in_bytes(), and Parma_Polyhedra_Library::DB_Row_Impl_Handler< T >::Impl::external_memory_in_bytes().

bool Parma_Polyhedra_Library::extract_interval_congruence	(	const Congruence &	cg,
		dimension_type	cg_space_dim,
		dimension_type &	cg_num_vars,
		dimension_type &	cg_only_var
	)

Definition at line 54 of file Box.cc.

References Parma_Polyhedra_Library::Congruence::coefficient(), Parma_Polyhedra_Library::Congruence::is_equality(), and Parma_Polyhedra_Library::Congruence::space_dimension().

Referenced by Parma_Polyhedra_Library::Box< ITV >::add_congruence_no_check(), and Parma_Polyhedra_Library::Box< ITV >::refine_no_check().

00057                                                               {
00058   // Check for preconditions.
00059   assert(cg.space_dimension() == cg_space_dim);
00060   assert(cg_num_vars == 0 && cg_only_var == 0);
00061   // Only equality congruences can be intervals.
00062   assert(cg.is_equality());
00063 
00064   // Collect the non-zero components of `cg'.
00065   for (dimension_type i = cg_space_dim; i-- > 0; )
00066     if (cg.coefficient(Variable(i)) != 0) {
00067       if (cg_num_vars == 0) {
00068         cg_only_var = i;
00069         ++cg_num_vars;
00070       }
00071       else
00072         // Congruence `cg' is not an interval congruence.
00073         return false;
00074     }
00075   return true;
00076 }

template<typename Boundary, typename Info>

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

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

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

Referenced by check_empty_arg(), check_empty_result(), and Parma_Polyhedra_Library::Interval_NS::f_is_singleton().

00051                                               {
00052   return x.is_empty();
00053 }

template<typename Boundary, typename Info>

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

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

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

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

00056                                                   {
00057   return x.is_singleton();
00058 }

template<typename T>

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

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

00371                   {
00372   return to.OK();
00373 }

void Parma_Polyhedra_Library::finalize ( ) [inline]

Finalizes the library.

Definition at line 55 of file initializer.hh.

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

00055            {
00056 #ifdef PPL_NO_AUTOMATIC_INITIALIZATION
00057   assert(Parma_Polyhedra_Library_initializer_p != 0);
00058   delete Parma_Polyhedra_Library_initializer_p;
00059   Parma_Polyhedra_Library_initializer_p = 0;
00060 #endif
00061 }

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

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

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

void Parma_Polyhedra_Library::gcdext_assign	(	GMP_Integer &	x,
		GMP_Integer &	s,
		GMP_Integer &	t,
		const GMP_Integer &	y,
		const GMP_Integer &	z
	)			`[related]`

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

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

00060                                                           {
00061   mpz_gcdext(x.get_mpz_t(),
00062              s.get_mpz_t(), t.get_mpz_t(),
00063              y.get_mpz_t(), z.get_mpz_t());
00064 }

template<typename T1, typename T2>

Enable_If<Is_Native_Or_Checked<T1>::value && Is_Native_Or_Checked<T2>::value, bool>::type Parma_Polyhedra_Library::greater_or_equal	(	const T1 &	x,
		const T2 &	y
	)			`[inline]`

template<typename T1, typename T2>

Enable_If<Is_Native_Or_Checked<T1>::value && Is_Native_Or_Checked<T2>::value, bool>::type Parma_Polyhedra_Library::greater_than	(	const T1 &	x,
		const T2 &	y
	)			`[inline]`

void Parma_Polyhedra_Library::initialize ( ) [inline]

Initializes the library.

Definition at line 46 of file initializer.hh.

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

00046              {
00047 #ifdef PPL_NO_AUTOMATIC_INITIALIZATION
00048   if (Parma_Polyhedra_Library_initializer_p == 0)
00049     Parma_Polyhedra_Library_initializer_p = new Init();
00050 #endif
00051 }

template<typename T, typename Base, typename From1, typename From2>

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

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder, and set_integer().

00574                                                                                                         {
00575   typedef Restriction_Integer_Modulo<From1, T, Base> Rx;
00576   const typename Rx::type& rx = Rx::get(x);
00577   typedef Restriction_Integer_Modulo<From2, T, Base> Ry;
00578   const typename Ry::type& ry = Ry::get(y);
00579   if (rx.divisor == 0) {
00580     to.remainder = ry.remainder;
00581     to.divisor = ry.divisor;
00582     return true;
00583   }
00584   if (ry.divisor == 0) {
00585     to.remainder = rx.remainder;
00586     to.divisor = rx.divisor;
00587     return true;
00588   }
00589   DIRTY_TEMP(T, g);
00590   Result r;
00591   r = gcd_assign_r(g, rx.divisor, ry.divisor, ROUND_DIRECT);
00592   if (r != V_EQ)
00593     return set_integer(to);
00594   DIRTY_TEMP(T, d);
00595   if (rx.remainder > ry.remainder)
00596     r = sub_assign_r(d, rx.remainder, ry.remainder, ROUND_DIRECT);
00597   else
00598     r = sub_assign_r(d, ry.remainder, rx.remainder, ROUND_DIRECT);
00599   if (r != V_EQ)
00600     return set_integer(to);
00601   r = div_assign_r(d, d, g, ROUND_DIRECT);
00602   if (r != V_EQ)
00603     return false;
00604   r = lcm_assign_r(to.divisor, rx.divisor, ry.divisor, ROUND_DIRECT);
00605   if (r != V_EQ)
00606     return set_integer(to);
00607   // FIXME: to be completed
00608   return true;
00609 }

template<typename Base, typename From1, typename From2>

bool Parma_Polyhedra_Library::intersect_restriction	(	Interval_Restriction_Integer< Base > &	to,
		const From1 &	x,
		const From2 &	y
	)			`[inline]`

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().

00252                                                                                               {
00253   to.set_integer(Restriction_Integer<From1, Base>::get(x).get_integer()
00254                  || Restriction_Integer<From2, Base>::get(y).get_integer());
00255   return true;
00256 }

template<typename T1, typename T2>

bool Parma_Polyhedra_Library::intersect_restriction	(	Interval_Restriction_None_Base &	,
		const T1 &	,
		const T2 &
	)			`[inline]`

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

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign().

00082                                                                              {
00083   return true;
00084 }

template<typename ITV>

Poly_Con_Relation Parma_Polyhedra_Library::interval_relation	(	const ITV &	i,
		const Constraint::Type	constraint_type,
		Coefficient_traits::const_reference	num,
		Coefficient_traits::const_reference	den = `1`
	)			`[inline]`

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

Parameters:

	i	The interval;
	constraint_type	The constraint type;
	num	The numerator of the constraint bound;
	den	The denominator of the constraint bound

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

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

References assign_r(), Parma_Polyhedra_Library::Constraint::EQUALITY, Parma_Polyhedra_Library::Poly_Con_Relation::is_disjoint(), Parma_Polyhedra_Library::Poly_Con_Relation::is_included(), Parma_Polyhedra_Library::Constraint::NONSTRICT_INEQUALITY, Parma_Polyhedra_Library::Poly_Con_Relation::saturates(), Parma_Polyhedra_Library::Constraint::STRICT_INEQUALITY, and Parma_Polyhedra_Library::Poly_Con_Relation::strictly_intersects().

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

00616                                                          {
00617 
00618   if (i.is_universe())
00619     return Poly_Con_Relation::strictly_intersects();
00620 
00621   DIRTY_TEMP0(mpq_class, bound);
00622   assign_r(bound.get_num(), num, ROUND_NOT_NEEDED);
00623   assign_r(bound.get_den(), den, ROUND_NOT_NEEDED);
00624   bound.canonicalize();
00625   neg_assign_r(bound, bound, ROUND_NOT_NEEDED);
00626   const bool is_lower_bound = (den > 0);
00627 
00628   DIRTY_TEMP0(mpq_class, bound_diff);
00629   if (constraint_type == Constraint::EQUALITY) {
00630     if (i.lower_is_unbounded()) {
00631       assert(!i.upper_is_unbounded());
00632       assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED);
00633       sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
00634       switch (sgn(bound_diff)) {
00635       case 1:
00636         return Poly_Con_Relation::strictly_intersects();
00637       case 0:
00638         return i.upper_is_open()
00639           ? Poly_Con_Relation::is_disjoint()
00640           : Poly_Con_Relation::strictly_intersects();
00641       case -1:
00642         return Poly_Con_Relation::is_disjoint();
00643       }
00644     }
00645     else {
00646       assign_r(bound_diff, i.lower(), ROUND_NOT_NEEDED);
00647       sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
00648       switch (sgn(bound_diff)) {
00649       case 1:
00650         return Poly_Con_Relation::is_disjoint();
00651       case 0:
00652         if (i.lower_is_open())
00653           return Poly_Con_Relation::is_disjoint();
00654         if (i.is_singleton())
00655           return Poly_Con_Relation::is_included()
00656             && Poly_Con_Relation::saturates();
00657         return Poly_Con_Relation::strictly_intersects();
00658       case -1:
00659         if (i.upper_is_unbounded())
00660           return Poly_Con_Relation::strictly_intersects();
00661         else {
00662           assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED);
00663           sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
00664           switch (sgn(bound_diff)) {
00665           case 1:
00666             return Poly_Con_Relation::strictly_intersects();
00667           case 0:
00668             if (i.upper_is_open())
00669               return Poly_Con_Relation::is_disjoint();
00670             else
00671               return Poly_Con_Relation::strictly_intersects();
00672           case -1:
00673             return Poly_Con_Relation::is_disjoint();
00674           }
00675         }
00676       }
00677     }
00678   }
00679 
00680   assert(constraint_type != Constraint::EQUALITY);
00681   if (is_lower_bound) {
00682     if (i.lower_is_unbounded()) {
00683       assert(!i.upper_is_unbounded());
00684       assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED);
00685       sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
00686       switch (sgn(bound_diff)) {
00687       case 1:
00688         return Poly_Con_Relation::strictly_intersects();
00689       case 0:
00690         if (constraint_type == Constraint::STRICT_INEQUALITY
00691             || i.upper_is_open())
00692           return Poly_Con_Relation::is_disjoint();
00693         else
00694           return Poly_Con_Relation::strictly_intersects();
00695       case -1:
00696         return Poly_Con_Relation::is_disjoint();
00697       }
00698     }
00699     else {
00700       assign_r(bound_diff, i.lower(), ROUND_NOT_NEEDED);
00701       sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
00702       switch (sgn(bound_diff)) {
00703       case 1:
00704         return Poly_Con_Relation::is_included();
00705       case 0:
00706         if (constraint_type == Constraint::NONSTRICT_INEQUALITY
00707             || i.lower_is_open()) {
00708           Poly_Con_Relation result = Poly_Con_Relation::is_included();
00709           if (i.is_singleton())
00710             result = result && Poly_Con_Relation::saturates();
00711           return result;
00712         }
00713         else {
00714           assert(constraint_type == Constraint::STRICT_INEQUALITY
00715                  && !i.lower_is_open());
00716           if (i.is_singleton())
00717             return Poly_Con_Relation::is_disjoint()
00718               && Poly_Con_Relation::saturates();
00719           else
00720             return Poly_Con_Relation::strictly_intersects();
00721         }
00722       case -1:
00723         if (i.upper_is_unbounded())
00724           return Poly_Con_Relation::strictly_intersects();
00725         else {
00726           assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED);
00727           sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
00728           switch (sgn(bound_diff)) {
00729           case 1:
00730             return Poly_Con_Relation::strictly_intersects();
00731           case 0:
00732             if (constraint_type == Constraint::STRICT_INEQUALITY
00733                 || i.upper_is_open())
00734               return Poly_Con_Relation::is_disjoint();
00735             else
00736               return Poly_Con_Relation::strictly_intersects();
00737           case -1:
00738             return Poly_Con_Relation::is_disjoint();
00739           }
00740         }
00741       }
00742     }
00743   }
00744   else {
00745     // `c' is an upper bound.
00746     if (i.upper_is_unbounded())
00747       return Poly_Con_Relation::strictly_intersects();
00748     else {
00749       assign_r(bound_diff, i.upper(), ROUND_NOT_NEEDED);
00750       sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
00751       switch (sgn(bound_diff)) {
00752       case -1:
00753         return Poly_Con_Relation::is_included();
00754       case 0:
00755         if (constraint_type == Constraint::NONSTRICT_INEQUALITY
00756             || i.upper_is_open()) {
00757           Poly_Con_Relation result = Poly_Con_Relation::is_included();
00758           if (i.is_singleton())
00759             result = result && Poly_Con_Relation::saturates();
00760           return result;
00761         }
00762         else {
00763           assert(constraint_type == Constraint::STRICT_INEQUALITY
00764                  && !i.upper_is_open());
00765           if (i.is_singleton())
00766             return Poly_Con_Relation::is_disjoint()
00767               && Poly_Con_Relation::saturates();
00768           else
00769             return Poly_Con_Relation::strictly_intersects();
00770         }
00771       case 1:
00772         if (i.lower_is_unbounded())
00773           return Poly_Con_Relation::strictly_intersects();
00774         else {
00775           assign_r(bound_diff, i.lower(), ROUND_NOT_NEEDED);
00776           sub_assign_r(bound_diff, bound_diff, bound, ROUND_NOT_NEEDED);
00777           switch (sgn(bound_diff)) {
00778           case -1:
00779             return Poly_Con_Relation::strictly_intersects();
00780           case 0:
00781             if (constraint_type == Constraint::STRICT_INEQUALITY
00782                 || i.lower_is_open())
00783               return Poly_Con_Relation::is_disjoint();
00784             else
00785               return Poly_Con_Relation::strictly_intersects();
00786           case 1:
00787             return Poly_Con_Relation::is_disjoint();
00788           }
00789         }
00790       }
00791     }
00792   }
00793 
00794   // Quiet a compiler warning: this program point is unreachable.
00795   throw std::runtime_error("PPL internal error");
00796 }

template<typename T, typename Policy>

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

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

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

00102                                                         {
00103   Checked_Number<T, Policy> negated_x;
00104   return neg_assign_r(negated_x, x, ROUND_DIRECT) == V_EQ
00105     && negated_x == y;
00106 }

bool Parma_Polyhedra_Library::is_canonical ( const mpq_class & x ) [inline]

Returns true if and only if x is in canonical form.

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

Referenced by Parma_Polyhedra_Library::Box< ITV >::Box(), Parma_Polyhedra_Library::Polyhedron::contains_integer_point(), Parma_Polyhedra_Library::Box< ITV >::max_min(), and Parma_Polyhedra_Library::MIP_Problem::solve_mip().

00109                                  {
00110   if (x.get_den() <= 0)
00111     return false;
00112   DIRTY_TEMP0(mpq_class, temp);
00113   temp = x;
00114   temp.canonicalize();
00115   return temp.get_num() == x.get_num();
00116 }

template<typename T, typename Policy>

bool Parma_Polyhedra_Library::is_even ( const Checked_Number< T, Policy > & x ) [inline]

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

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

References is_integer().

Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::tight_coherence_would_make_empty().

00093                                             {
00094   Checked_Number<T, Policy> half_x;
00095   return div2exp_assign_r(half_x, x, 1, ROUND_DIRECT) == V_EQ
00096     && is_integer(half_x);
00097 }

template<typename Boundary, typename Info>

int Parma_Polyhedra_Library::is_infinity ( const Interval< Boundary, Info > & x ) [inline]

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

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

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

template<typename T>

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

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

References Parma_Polyhedra_Library::Checked_Number< T, Policy >::is_minus_infinity(), and Parma_Polyhedra_Library::Checked_Number< T, Policy >::is_plus_infinity().

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

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

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

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

Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::contains_integer_point(), Parma_Polyhedra_Library::BD_Shape< T >::contains_integer_point(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::tight_coherence_would_make_empty().

00141                         {
00142   // FIXME:
00143   return false;
00144 }

template<typename T>

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

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

References raw_value().

Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::contains_integer_point(), Parma_Polyhedra_Library::BD_Shape< T >::contains_integer_point(), Parma_Polyhedra_Library::Restriction_Integer_Modulo< From, T, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_None_Base, typename From::info_type >::value >::type >::get(), Parma_Polyhedra_Library::Restriction_Integer_Modulo< From, T, Base, typename Enable_If< Is_Native_Or_Checked< From >::value >::type >::get(), Parma_Polyhedra_Library::Restriction_Integer< From, Base, typename Enable_If< Is_Same_Or_Derived< Interval_Restriction_None_Base, typename From::info_type >::value >::type >::get(), Parma_Polyhedra_Library::Restriction_Integer< From, Base, typename Enable_If< Is_Native_Or_Checked< From >::value >::type >::get(), is_even(), is_singleton_integer(), and Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::restrict().

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

template<typename T, typename Policy>

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

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

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

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

template<typename T>

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

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

References raw_value().

Referenced by numer_denom(), Parma_Polyhedra_Library::Octagonal_Shape< T >::OK(), Parma_Polyhedra_Library::Interval< Boundary, Info >::OK(), and Parma_Polyhedra_Library::BD_Shape< T >::OK().

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

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

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

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

template<typename T, typename Policy>

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

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

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

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

template<typename T>

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

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

References raw_value().

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

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

template<typename T, typename Policy>

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

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

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

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

template<typename T>

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

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

References raw_value().

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

template<typename T>

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

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

References Parma_Polyhedra_Library::Interval_NS::f_lower(), is_integer(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::is_singleton().

00154                                  {
00155   return is_singleton(x) && is_integer(f_lower(x));
00156 }

unsigned long Parma_Polyhedra_Library::isqrt ( unsigned long x ) [inline]

Returns the integer square root of x.

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

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

00405                        {
00406   unsigned long r = 0;
00407   for (unsigned long t = 0x40000000; t; t >>= 2) {
00408     unsigned long s = r + t;
00409     if (s <= x) {
00410       x -= s;
00411       r = s + t;
00412     }
00413     r >>= 1;
00414   }
00415   return r;
00416 }

template<typename T, typename Base, typename From1, typename From2>

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

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

References assign_r(), contains_restriction(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder, set_integer(), and set_unrestricted().

00523                                                                                                    {
00524   typedef Restriction_Integer_Modulo<From1, T, Base> Rx;
00525   const typename Rx::type& rx = Rx::get(x);
00526   if (rx.divisor == 0)
00527     return set_unrestricted(to);
00528   typedef Restriction_Integer_Modulo<From2, T, Base> Ry;
00529   const typename Ry::type& ry = Ry::get(y);
00530   if (ry.divisor == 0)
00531     return set_unrestricted(to);
00532   else if (rx.divisor == 1 && ry.divisor == 1
00533       && is_singleton(x) && is_singleton(y)) {
00534     DIRTY_TEMP(typename Boundary_Value<From1>::type, a);
00535     DIRTY_TEMP(typename Boundary_Value<From2>::type, b);
00536     Result r;
00537     r = abs_assign_r(a, f_lower(x), ROUND_CHECK);
00538     if (r != V_EQ)
00539       return set_integer(to);
00540     r = abs_assign_r(b, f_lower(y), ROUND_CHECK);
00541     if (r != V_EQ)
00542       return set_integer(to);
00543     if (a > b)
00544       r = sub_assign_r(a, a, b, ROUND_CHECK);
00545     else
00546       r = sub_assign_r(a, b, a, ROUND_CHECK);
00547     if (r != V_EQ)
00548       return set_integer(to);
00549     r = assign_r(to.divisor, a, ROUND_CHECK);
00550     if (r != V_EQ)
00551       return set_integer(to);
00552     r = rem_assign_r(b, b, a, ROUND_CHECK);
00553     if (r != V_EQ)
00554       return set_integer(to);
00555     r = assign_r(to.remainder, b, ROUND_CHECK);
00556     if (r != V_EQ)
00557       return set_integer(to);
00558   }
00559   else if (contains_restriction(rx, ry)) {
00560     to.remainder = rx.remainder;
00561     to.divisor = rx.divisor;
00562   }
00563   else if (contains_restriction(ry, rx)) {
00564     to.remainder = ry.remainder;
00565     to.divisor = ry.divisor;
00566   }
00567   else
00568     return set_integer(to);
00569   return true;
00570 }

template<typename Base, typename From1, typename From2>

bool Parma_Polyhedra_Library::join_restriction	(	Interval_Restriction_Integer< Base > &	to,
		const From1 &	x,
		const From2 &	y
	)			`[inline]`

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().

00244                                                                                          {
00245   to.set_integer(Restriction_Integer<From1, Base>::get(x).get_integer()
00246                  && Restriction_Integer<From2, Base>::get(y).get_integer());
00247   return true;
00248 }

template<typename T1, typename T2>

bool Parma_Polyhedra_Library::join_restriction	(	Interval_Restriction_None_Base &	,
		const T1 &	,
		const T2 &
	)			`[inline]`

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

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign().

00076                                                                         {
00077   return true;
00078 }

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

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

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

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

template<typename T1, typename T2>

Enable_If<Is_Native_Or_Checked<T1>::value && Is_Native_Or_Checked<T2>::value, bool>::type Parma_Polyhedra_Library::less_or_equal	(	const T1 &	x,
		const T2 &	y
	)			`[inline]`

template<typename T1, typename T2>

Enable_If<Is_Native_Or_Checked<T1>::value && Is_Native_Or_Checked<T2>::value, bool>::type Parma_Polyhedra_Library::less_than	(	const T1 &	x,
		const T2 &	y
	)			`[inline]`

template<typename T>

T Parma_Polyhedra_Library::low_bits_mask ( unsigned n ) [inline]

Returns a mask for the lowest n bits,.

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

00044                                 {
00045   assert(n < unsigned(std::numeric_limits<T>::digits));
00046   return n == 0 ? 0 : ~(~(T(0u)) << n);
00047 }

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

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

Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::relation_with(), Parma_Polyhedra_Library::Box< ITV >::relation_with(), Parma_Polyhedra_Library::BD_Shape< T >::relation_with(), and unrepresentability_error().

00060                   {
00061   return static_cast<Result>(r & 63);
00062 }

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 86 of file math_utilities.inlines.hh.

Referenced by Parma_Polyhedra_Library::BD_Shape< T >::BD_Shape(), Parma_Polyhedra_Library::Octagonal_Shape< T >::fold_space_dimensions(), Parma_Polyhedra_Library::BD_Shape< T >::fold_space_dimensions(), Parma_Polyhedra_Library::Interval< Boundary, Info >::intersect_assign(), Parma_Polyhedra_Library::Interval< Boundary, Info >::join_assign(), Parma_Polyhedra_Library::Octagonal_Shape< T >::Octagonal_Shape(), and Parma_Polyhedra_Library::Octagonal_Shape< T >::upper_bound_assign().

00086                              {
00087   if (x < y)
00088     x = y;
00089 }

void Parma_Polyhedra_Library::maybe_abandon ( ) [related]

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

References abandon_expensive_computations.

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

00041                 {
00042   if (const Throwable* p = abandon_expensive_computations)
00043     p->throw_me();
00044 }

template<typename To, typename From>

Result Parma_Polyhedra_Library::maybe_assign	(	const To *&	top,
		To &	tmp,
		const From &	from,
		Rounding_Dir	dir
	)			`[inline]`

Assigns to top a pointer to a location that holds the conversion, according to dir, of from to type To. When necessary, and only when necessary, the variable tmp is used to hold the result of conversion.

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

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

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

template<typename T>

int Parma_Polyhedra_Library::maybe_check_fpu_inexact ( ) [inline]

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

00825                           {
00826   if (FPU_Related<T>::value)
00827     return fpu_check_inexact();
00828   else
00829     return 0;
00830 }

template<typename T>

void Parma_Polyhedra_Library::maybe_reset_fpu_inexact ( ) [inline]

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

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

template<typename N>

void Parma_Polyhedra_Library::min_assign	(	N &	x,
		const N &	y
	)			`[inline]`

Assigns to x the minimum between x and y.

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

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

00079                              {
00080   if (x > y)
00081     x = y;
00082 }

template<typename T>

T Parma_Polyhedra_Library::minus_infinity ( ) [inline]

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

References MINUS_INFINITY.

00798                  {
00799   return MINUS_INFINITY;
00800 }

template<typename T, typename Base, typename From1, typename From2>

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

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

References assign_r(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, Parma_Polyhedra_Library::Interval_NS::f_lower(), mulmod(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder, set_integer(), and set_unrestricted().

00794                                                                                                   {
00795   typedef Restriction_Integer_Modulo<From1, T, Base> Rx;
00796   const typename Rx::type& rx = Rx::get(x);
00797   if (rx.divisor == 0)
00798     return set_unrestricted(to);
00799   typedef Restriction_Integer_Modulo<From2, T, Base> Ry;
00800   const typename Ry::type& ry = Ry::get(y);
00801   if (ry.divisor == 0)
00802     return set_unrestricted(to);
00803   Result r;
00804   DIRTY_TEMP(T, mul);
00805   if (is_singleton(x)) {
00806     if (is_singleton(y))
00807       return set_integer(to);
00808     DIRTY_TEMP(typename Boundary_Value<From1>::type, n);
00809     r = abs_assign_r(n, f_lower(x), ROUND_CHECK);
00810     if (r != V_EQ)
00811       return set_integer(to);
00812     r = assign_r(mul, n, ROUND_CHECK);
00813     if (r != V_EQ)
00814       return set_integer(to);
00815     r = mul_assign_r(to.remainder, mul, ry.remainder, ROUND_NOT_NEEDED);
00816     if (r != V_EQ)
00817       return set_integer(to);
00818     r = mul_assign_r(to.divisor, mul, ry.divisor, ROUND_NOT_NEEDED);
00819     if (r != V_EQ)
00820       return set_integer(to);
00821   }
00822   else if (is_singleton(y)) {
00823     DIRTY_TEMP(typename Boundary_Value<From2>::type, n);
00824     r = abs_assign_r(n, f_lower(y), ROUND_CHECK);
00825     if (r != V_EQ)
00826       return set_integer(to);
00827     r = assign_r(mul, n, ROUND_CHECK);
00828     if (r != V_EQ)
00829       return set_integer(to);
00830     r = mul_assign_r(to.remainder, rx.remainder, mul, ROUND_NOT_NEEDED);
00831     if (r != V_EQ)
00832       return set_integer(to);
00833     r = mul_assign_r(to.divisor, rx.divisor, mul, ROUND_NOT_NEEDED);
00834     if (r != V_EQ)
00835       return set_integer(to);
00836   }
00837   else {
00838     r = gcd_assign_r(to.divisor, rx.divisor, ry.divisor, ROUND_NOT_NEEDED);
00839     assert(r == V_EQ);
00840     mulmod(to.remainder, rx.remainder, ry.remainder, to.divisor);
00841   }
00842   return true;
00843 }

template<typename Base, typename From1, typename From2>

bool Parma_Polyhedra_Library::mul_restriction	(	Interval_Restriction_Integer< Base > &	to,
		const From1 &	x,
		const From2 &	y
	)			`[inline]`

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().

00291                                                                                         {
00292   to.set_integer(Restriction_Integer<From1, Base>::get(x).get_integer()
00293                  && Restriction_Integer<From2, Base>::get(y).get_integer());
00294   return true;
00295 }

template<typename T1, typename T2>

bool Parma_Polyhedra_Library::mul_restriction	(	Interval_Restriction_None_Base &	,
		const T1 &	,
		const T2 &
	)			`[inline]`

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

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

00112                                                                        {
00113   return true;
00114 }

template<typename T>

void Parma_Polyhedra_Library::mulmod	(	T &	to,
		const T &	x,
		const T &	y,
		const T &	to_m
	)			`[inline]`

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

References assign_r().

Referenced by mul_restriction().

00765                                                      {
00766   Result r;
00767   if (std::numeric_limits<T>::is_bounded) {
00768     DIRTY_TEMP0(mpz_class, a);
00769     DIRTY_TEMP0(mpz_class, b);
00770     r = assign_r(a, x, ROUND_NOT_NEEDED);
00771     assert(r == V_EQ);
00772     r = assign_r(b, y, ROUND_NOT_NEEDED);
00773     assert(r == V_EQ);
00774     r = mul_assign_r(a, a, b, ROUND_NOT_NEEDED);
00775     assert(r == V_EQ);
00776     r = assign_r(b, to_m, ROUND_NOT_NEEDED);
00777     assert(r == V_EQ);
00778     r = rem_assign_r(a, a, b, ROUND_NOT_NEEDED);
00779     assert(r == V_EQ);
00780     r = assign_r(to, a, ROUND_NOT_NEEDED);
00781     assert(r == V_EQ);
00782   }
00783   else {
00784     r = mul_assign_r(to, x, y, ROUND_NOT_NEEDED);
00785     assert(r == V_EQ);
00786     r = rem_assign_r(to, to, to_m, ROUND_NOT_NEEDED);
00787     assert(r == V_EQ);
00788   }
00789 }

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

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

Referenced by Parma_Polyhedra_Library::Linear_System::back_substitute(), and Parma_Polyhedra_Library::Interval< Boundary, Info >::neg_assign().

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

void Parma_Polyhedra_Library::neg_assign ( GMP_Integer & x ) [related]

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

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

template<typename T, typename Base, typename From>

bool Parma_Polyhedra_Library::neg_restriction	(	Interval_Restriction_Integer_Modulo< T, Base > &	to,
		const From &	x
	)			`[inline]`

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

References assign_restriction().

00621                                                                                  {
00622   return assign_restriction(to, x);
00623 }

template<typename Base, typename From>

bool Parma_Polyhedra_Library::neg_restriction	(	Interval_Restriction_Integer< Base > &	to,
		const From &	x
	)			`[inline]`

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().

00268                                                                        {
00269   to.set_integer(Restriction_Integer<From, Base>::get(x).get_integer());
00270   return true;
00271 }

template<typename T>

bool Parma_Polyhedra_Library::neg_restriction	(	Interval_Restriction_None_Base &	,
		const T &
	)			`[inline]`

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

Referenced by Parma_Polyhedra_Library::Interval< Boundary, Info >::neg_assign().

00094                                                            {
00095   return true;
00096 }

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

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

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

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

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

Referenced by Parma_Polyhedra_Library::Polyhedron::conversion(), Parma_Polyhedra_Library::MIP_Problem::evaluate_objective_function(), Parma_Polyhedra_Library::MIP_Problem::linear_combine(), and Parma_Polyhedra_Library::Linear_Row::linear_combine().

00035                                              {
00036   TEMP_INTEGER(gcd);
00037   gcd_assign(gcd, x, y);
00038   exact_div_assign(nx, x, gcd);
00039   exact_div_assign(ny, y, gcd);
00040 }

dimension_type Parma_Polyhedra_Library::not_a_dimension ( ) [inline]

Returns a value that does not designate a valid dimension.

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

Referenced by Parma_Polyhedra_Library::Polyhedron::map_space_dimensions(), Parma_Polyhedra_Library::Grid::map_space_dimensions(), and Parma_Polyhedra_Library::Variable::max_space_dimension().

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

template<typename T>

T Parma_Polyhedra_Library::not_a_number ( ) [inline]

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

References NOT_A_NUMBER.

00804                {
00805   return NOT_A_NUMBER;
00806 }

template<typename T1, typename T2>

Enable_If<Is_Native_Or_Checked<T1>::value && Is_Native_Or_Checked<T2>::value, bool>::type Parma_Polyhedra_Library::not_equal	(	const T1 &	x,
		const T2 &	y
	)			`[inline]`

template<typename T, typename Policy>

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

Extract the numerator and denominator components of from.

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

References assign_r(), is_minus_infinity(), is_not_a_number(), and is_plus_infinity().

Referenced by Parma_Polyhedra_Library::Octagonal_Shape< T >::constraints(), Parma_Polyhedra_Library::BD_Shape< T >::constraints(), Parma_Polyhedra_Library::Octagonal_Shape< T >::max_min(), Parma_Polyhedra_Library::BD_Shape< T >::max_min(), Parma_Polyhedra_Library::Octagonal_Shape< T >::minimized_congruences(), Parma_Polyhedra_Library::BD_Shape< T >::minimized_congruences(), Parma_Polyhedra_Library::BD_Shape< T >::minimized_constraints(), Parma_Polyhedra_Library::Octagonal_Shape< T >::relation_with(), and Parma_Polyhedra_Library::BD_Shape< T >::relation_with().

00052                                                 {
00053   assert(!is_not_a_number(from)
00054          && !is_minus_infinity(from)
00055          && !is_plus_infinity(from));
00056   DIRTY_TEMP0(mpq_class, q);
00057   assign_r(q, from, ROUND_NOT_NEEDED);
00058   num = q.get_num();
00059   den = q.get_den();
00060 }

template<typename ITV>

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

Definition at line 260 of file Box.inlines.hh.

Referenced by Parma_Polyhedra_Library::Grid_Generator_System::const_iterator::operator!=().

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

template<typename T1, typename T2>

Enable_If<((Is_Singleton<T1>::value \|\| Is_Interval<T1>::value) && (Is_Singleton<T2>::value \|\| Is_Interval<T2>::value) && (Is_Interval<T1>::value \|\| Is_Interval<T2>::value)), bool>::type Parma_Polyhedra_Library::operator!=	(	const T1 &	x,
		const T2 &	y
	)			`[related]`

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

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

template<typename B, typename Info>

Interval<B, Info> Parma_Polyhedra_Library::operator*	(	const Interval< B, Info > &	x,
		const Interval< B, Info > &	y
	)			`[inline]`

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

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

Referenced by Parma_Polyhedra_Library::Grid_Generator_System::const_iterator::operator*().

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

template<typename B, typename Info, typename T>

Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator*	(	const T &	x,
		const Interval< B, Info > &	y
	)			`[inline]`

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

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

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

template<typename B, typename Info, typename T>

Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator*	(	const Interval< B, Info > &	x,
		const T &	y
	)			`[inline]`

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

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

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

template<typename B, typename Info>

Interval<B, Info> Parma_Polyhedra_Library::operator+	(	const Interval< B, Info > &	x,
		const Interval< B, Info > &	y
	)			`[inline]`

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

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

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

template<typename B, typename Info, typename T>

Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator+	(	const T &	x,
		const Interval< B, Info > &	y
	)			`[inline]`

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

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

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

template<typename B, typename Info, typename T>

Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator+	(	const Interval< B, Info > &	x,
		const T &	y
	)			`[inline]`

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

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

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

template<typename B, typename Info>

Interval<B, Info> Parma_Polyhedra_Library::operator-	(	const Interval< B, Info > &	x,
		const Interval< B, Info > &	y
	)			`[inline]`

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

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

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

template<typename B, typename Info, typename T>

Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator-	(	const T &	x,
		const Interval< B, Info > &	y
	)			`[inline]`

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

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

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

template<typename B, typename Info, typename T>

Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator-	(	const Interval< B, Info > &	x,
		const T &	y
	)			`[inline]`

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

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

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

template<typename B, typename Info>

Interval<B, Info> Parma_Polyhedra_Library::operator/	(	const Interval< B, Info > &	x,
		const Interval< B, Info > &	y
	)			`[inline]`

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

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

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

template<typename B, typename Info, typename T>

Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator/	(	const T &	x,
		const Interval< B, Info > &	y
	)			`[inline]`

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

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

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

template<typename B, typename Info, typename T>

Enable_If<Is_Singleton<T>::value, Interval<B, Info> >::type Parma_Polyhedra_Library::operator/	(	const Interval< B, Info > &	x,
		const T &	y
	)			`[inline]`

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

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

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

template<typename Boundary, typename Info>

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

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

References check_empty_arg(), and output_restriction().

01141                                                               {
01142   // assert(x.OK());
01143   if (check_empty_arg(x))
01144     return os << "[]";
01145   if (x.is_singleton()) {
01146     output(os, x.lower(), Numeric_Format(), ROUND_NOT_NEEDED);
01147     return os;
01148   }
01149   os << (x.lower_is_open() ? "(" : "[");
01150   if (x.info().get_boundary_property(LOWER, SPECIAL))
01151     os << "-inf";
01152   else
01153     output(os, x.lower(), Numeric_Format(), ROUND_NOT_NEEDED);
01154   os << ", ";
01155   if (x.info().get_boundary_property(UPPER, SPECIAL))
01156     os << "+inf";
01157   else
01158     output(os, x.upper(), Numeric_Format(), ROUND_NOT_NEEDED);
01159   os << (x.upper_is_open() ? ")" : "]");
01160   output_restriction(os, x.info());
01161   return os;
01162 }

template<typename ITV>

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

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

References Parma_Polyhedra_Library::Box< ITV >::is_empty(), Parma_Polyhedra_Library::Box< ITV >::seq, and Parma_Polyhedra_Library::Box< ITV >::space_dimension().

Referenced by Parma_Polyhedra_Library::Grid_Generator_System::const_iterator::operator==().

00562                                                  {
00563   const dimension_type x_space_dim = x.space_dimension();
00564   if (x_space_dim != y.space_dimension())
00565     return false;
00566 
00567   if (x.is_empty())
00568     return y.is_empty();
00569 
00570   if (y.is_empty())
00571     return x.is_empty();
00572 
00573   for (dimension_type k = x_space_dim; k-- > 0; )
00574     if (x.seq[k] != y.seq[k])
00575       return false;
00576   return true;
00577 }

template<typename T1, typename T2>

Enable_If<((Is_Singleton<T1>::value \|\| Is_Interval<T1>::value) && (Is_Singleton<T2>::value \|\| Is_Interval<T2>::value) && (Is_Interval<T1>::value \|\| Is_Interval<T2>::value)), bool>::type Parma_Polyhedra_Library::operator==	(	const T1 &	x,
		const T2 &	y
	)			`[related]`

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

References check_empty_arg(), Parma_Polyhedra_Library::Checked::eq(), eq_restriction(), Parma_Polyhedra_Library::Interval_NS::f_info(), Parma_Polyhedra_Library::Interval_NS::f_lower(), f_OK(), and Parma_Polyhedra_Library::Interval_NS::f_upper().

00195                                      {
00196   assert(f_OK(x));
00197   assert(f_OK(y));
00198   if (check_empty_arg(x))
00199     return check_empty_arg(y);
00200   else if (check_empty_arg(y))
00201     return false;
00202   return eq_restriction(f_info(x), f_info(y))
00203     && eq(LOWER, f_lower(x), f_info(x), LOWER, f_lower(y), f_info(y))
00204     && eq(UPPER, f_upper(x), f_info(x), UPPER, f_upper(y), f_info(y));
00205 }

template<typename T, typename Base>

void Parma_Polyhedra_Library::output_restriction	(	std::ostream &	s,
		const Interval_Restriction_Integer_Modulo< T, Base > &	x
	)			`[inline]`

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, and Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder.

00858                                                                                          {
00859   if (x.divisor == 1)
00860     s << "i";
00861   else if (x.divisor != 0)
00862     s << "{" << x.remainder << "%" << x.divisor << "}";
00863 }

template<typename Base>

void Parma_Polyhedra_Library::output_restriction	(	std::ostream &	s,
		const Interval_Restriction_Integer< Base > &	x
	)			`[inline]`

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::get_integer().

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

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

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

Referenced by operator<<().

00123                                                                        {
00124 }

template<typename T>

T Parma_Polyhedra_Library::plus_infinity ( ) [inline]

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

References PLUS_INFINITY.

00792                 {
00793   return PLUS_INFINITY;
00794 }

bool Parma_Polyhedra_Library::@202::propagate_constraint_check_result	(	Result	r,
		Ternary &	open
	)			`[inline, static]`

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

References T_MAYBE, T_NO, and T_YES.

Referenced by Parma_Polyhedra_Library::Box< ITV >::propagate_constraint_no_check().

01932                                                            {
01933   switch (r) {
01934   case V_NEG_OVERFLOW:
01935   case V_POS_OVERFLOW:
01936   case V_UNKNOWN_NEG_OVERFLOW:
01937   case V_UNKNOWN_POS_OVERFLOW:
01938     return true;
01939   case V_LT:
01940   case V_GT:
01941     open = T_YES;
01942     return false;
01943   case V_LE:
01944   case V_GE:
01945     if (open == T_NO)
01946       open = T_MAYBE;
01947     return false;
01948   case V_EQ:
01949     return false;
01950   default:
01951     assert(false);
01952     return true;
01953   }
01954 }

unsigned Parma_Polyhedra_Library::rational_sqrt_precision_parameter ( ) [inline]

Returns the precision parameter used for rational square root calculations.

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

References Parma_Polyhedra_Library::Checked::rational_sqrt_precision_parameter.

00454                                     {
00455   return Checked::rational_sqrt_precision_parameter;
00456 }

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

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

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

00103                           {
00104   return x;
00105 }

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

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

Referenced by assign().

00098                                 {
00099   return x;
00100 }

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

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

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

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

void Parma_Polyhedra_Library::restore_pre_PPL_rounding ( ) [inline]

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

After calling this function it is absolutely necessary to call set_rounding_for_PPL() before using any PPL abstractions based on floating point numbers. This is performed automatically at finalization-time.

Definition at line 39 of file Init.inlines.hh.

References Parma_Polyhedra_Library::Init::old_rounding_direction.

00039                            {
00040 #if PPL_CAN_CONTROL_FPU
00041   fpu_set_rounding_direction(Init::old_rounding_direction);
00042 #endif
00043 }

Rounding_Dir Parma_Polyhedra_Library::rounding_dir ( Rounding_Dir dir ) [inline]

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

Referenced by Parma_Polyhedra_Library::Checked_Number< T, Policy >::assign_r(), assign_r(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number(), construct(), Parma_Polyhedra_Library::Checked_Number< T, Policy >::input(), and Parma_Polyhedra_Library::Checked_Number< T, Policy >::output().

00033                                {
00034   if (dir == ROUND_NOT_NEEDED) {
00035 #ifdef DEBUG_ROUND_NOT_NEEDED
00036     return ROUND_DIRECT & ROUND_FPU_CHECK_INEXACT;
00037 #else
00038     return ROUND_IGNORE;
00039 #endif
00040   }
00041   return dir;
00042 }

template<typename T>

bool Parma_Polyhedra_Library::same_object	(	const T &	x,
		const T &	y
	)			`[inline]`

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

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

template<typename T1, typename T2>

bool Parma_Polyhedra_Library::same_object	(	const T1 &	,
		const T2 &
	)			`[inline]`

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

00160                                   {
00161   return false;
00162 }

template<typename T, typename Base>

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

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, and Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder.

Referenced by add_restriction(), intersect_restriction(), join_restriction(), mul_restriction(), and sub_restriction().

00507                                                               {
00508   to.remainder = 0;
00509   to.divisor = 1;
00510   return true;
00511 }

void Parma_Polyhedra_Library::set_rational_sqrt_precision_parameter ( const unsigned p ) [inline]

Sets the precision parameter used for rational square root calculations.

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

Exceptions:

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

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

References Parma_Polyhedra_Library::Checked::rational_sqrt_precision_parameter.

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

00467                                                         {
00468   if (p <= INT_MAX)
00469     Checked::rational_sqrt_precision_parameter = p;
00470   else
00471     throw std::invalid_argument("PPL::set_rational_sqrt_precision_parameter(p)"
00472                                 " with p > INT_MAX");
00473 }

void Parma_Polyhedra_Library::set_rounding_for_PPL ( ) [inline]

Sets the FPU rounding mode so that the PPL abstractions based on floating point numbers work correctly.

This is performed automatically at initialization-time. Calling this function is needed only if restore_pre_PPL_rounding() has been previously called.

Definition at line 32 of file Init.inlines.hh.

00032                        {
00033 #if PPL_CAN_CONTROL_FPU
00034     fpu_set_rounding_direction(round_fpu_dir(ROUND_DIRECT));
00035 #endif
00036 }

template<typename T, typename Base>

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

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, and Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder.

Referenced by add_restriction(), div_restriction(), join_restriction(), mul_restriction(), and sub_restriction().

00499                                                                    {
00500   to.remainder = 0;
00501   to.divisor = 0;
00502   return true;
00503 }

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

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

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

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

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

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

template<typename T, typename Base, typename From1, typename From2>

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

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

References assign_r(), assign_rem(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::divisor, Parma_Polyhedra_Library::Interval_NS::f_lower(), Parma_Polyhedra_Library::Interval_Restriction_Integer_Modulo< T, Base >::remainder, set_integer(), set_unrestricted(), and submod().

00728                                                                                                   {
00729   typedef Restriction_Integer_Modulo<From1, T, Base> Rx;
00730   const typename Rx::type& rx = Rx::get(x);
00731   if (rx.divisor == 0)
00732     return set_unrestricted(to);
00733   typedef Restriction_Integer_Modulo<From2, T, Base> Ry;
00734   const typename Ry::type& ry = Ry::get(y);
00735   if (ry.divisor == 0)
00736     return set_unrestricted(to);
00737   Result r;
00738   DIRTY_TEMP(T, rem);
00739   if (is_singleton(x)) {
00740     if (is_singleton(y))
00741       return set_integer(to);
00742     if (!assign_rem(rem, f_lower(x), ry.divisor))
00743       return set_integer(to);
00744     r = assign_r(to.divisor, ry.divisor, ROUND_NOT_NEEDED);
00745     assert(r == V_EQ);
00746     submod(to.remainder, rem, ry.remainder, to.divisor, ry.divisor);
00747   }
00748   else if (is_singleton(y)) {
00749     if (!assign_rem(rem, f_lower(y), rx.divisor))
00750       return set_integer(to);
00751     r = assign_r(to.divisor, rx.divisor, ROUND_NOT_NEEDED);
00752     assert(r == V_EQ);
00753     submod(to.remainder, rx.remainder, rem, to.divisor, to.divisor);
00754   }
00755   else {
00756     r = gcd_assign_r(to.divisor, rx.divisor, ry.divisor, ROUND_NOT_NEEDED);
00757     assert(r == V_EQ);
00758     submod(to.remainder, rx.remainder, ry.remainder, to.divisor, ry.divisor);
00759   }
00760   return true;
00761 }

template<typename Base, typename From1, typename From2>

bool Parma_Polyhedra_Library::sub_restriction	(	Interval_Restriction_Integer< Base > &	to,
		const From1 &	x,
		const From2 &	y
	)			`[inline]`

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

References Parma_Polyhedra_Library::Interval_Restriction_Integer< Base >::set_integer().

00283                                                                                         {
00284   to.set_integer(Restriction_Integer<From1, Base>::get(x).get_integer()
00285                  && Restriction_Integer<From2, Base>::get(y).get_integer());
00286   return true;
00287 }

template<typename T1, typename T2>

bool Parma_Polyhedra_Library::sub_restriction	(	Interval_Restriction_None_Base &	,
		const T1 &	,
		const T2 &
	)			`[inline]`

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

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

00106                                                                        {
00107   return true;
00108 }

template<typename T>

void Parma_Polyhedra_Library::submod	(	T &	to,
		const T &	x,
		const T &	y,
		const T &	to_m,
		const T &	y_m
	)			`[inline]`

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

Referenced by sub_restriction().

00710                                                                    {
00711   Result r;
00712   if (x >= y) {
00713     r = sub_assign_r(to, x, y, ROUND_NOT_NEEDED);
00714     assert(r == V_EQ);
00715   }
00716   else {
00717     r = sub_assign_r(to, y_m, y, ROUND_NOT_NEEDED);
00718     assert(r == V_EQ);
00719     r = add_assign_r(to, x, to, ROUND_NOT_NEEDED);
00720     assert(r == V_EQ);
00721   }
00722   r = rem_assign_r(to, to, to_m, ROUND_NOT_NEEDED);
00723   assert(r == V_EQ);
00724 }

template<typename T>

Enable_If<Slow_Copy<T>::value, void>::type Parma_Polyhedra_Library::swap	(	T &	,
		T &
	)			`[inline]`

Make sure swap() is specialized when needed.

This will cause a compile-time error whenever a specialization for T is beneficial but missing.

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

References COMPILE_TIME_CHECK.

00050              {
00051   COMPILE_TIME_CHECK(!Slow_Copy<T>::value, "missing swap specialization");
00052 }

void Parma_Polyhedra_Library::throw_result_exception ( Result r )

Definition at line 29 of file Checked_Number.cc.

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

00029                                  {
00030   switch (r) {
00031   case V_LT:
00032     throw std::logic_error("Exact result is less than computed one.");
00033   case V_LE:
00034     throw std::logic_error("Exact result is less than or equal to "
00035                            "computed one.");
00036   case V_GT:
00037     throw std::logic_error("Exact result is greater than computed one.");
00038   case V_GE:
00039     throw std::logic_error("Exact result is greater than or equal to "
00040                            "computed one.");
00041   case V_NE:
00042     throw std::logic_error("Exact result is less than or greater than "
00043                            "computed one.");
00044   case V_LGE:
00045     throw std::logic_error("Exact result is less than, greater than or "
00046                            "equal to computed one.");
00047   case VC_MINUS_INFINITY:
00048     throw std::overflow_error("Minus infinity.");
00049   case V_NEG_OVERFLOW:
00050     throw std::overflow_error("Negative overflow.");
00051   case V_UNKNOWN_NEG_OVERFLOW:
00052     throw std::overflow_error("Unknown result due to negative overflow.");
00053   case VC_PLUS_INFINITY:
00054     throw std::overflow_error("Plus infinity.");
00055   case V_POS_OVERFLOW:
00056     throw std::overflow_error("Positive overflow.");
00057   case V_UNKNOWN_POS_OVERFLOW:
00058     throw std::overflow_error("Unknown result due to positive overflow.");
00059   case V_CVT_STR_UNK:
00060     throw std::domain_error("Invalid numeric string.");
00061   case V_DIV_ZERO:
00062     throw std::domain_error("Division by zero.");
00063   case V_INF_ADD_INF:
00064     throw std::domain_error("Infinities addition.");
00065   case V_INF_DIV_INF:
00066     throw std::domain_error("Infinities division.");
00067   case V_INF_MOD:
00068     throw std::domain_error("Remainder of division of infinity.");
00069   case V_INF_MUL_ZERO:
00070     throw std::domain_error("Multiplication of infinity and zero.");
00071   case V_INF_SUB_INF:
00072     throw std::domain_error("Subtraction of infinities.");
00073   case V_MOD_ZERO:
00074     throw std::domain_error("Remainder of division by zero.");
00075   case V_SQRT_NEG:
00076     throw std::domain_error("Square root of negative number.");
00077   case V_UNORD_COMP:
00078     throw std::domain_error("Unordered comparison.");
00079   default:
00080     throw std::logic_error("Unexpected result.");
00081   }
00082 }

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

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

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

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

00100                                           {
00101   return sizeof(x) + external_memory_in_bytes(x);
00102 }

memory_size_type Parma_Polyhedra_Library::total_memory_in_bytes ( const mpz_class & x ) [inline]

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

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

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

00089                                           {
00090   return sizeof(x) + external_memory_in_bytes(x);
00091 }

template<typename T>

Enable_If< Is_Native< T >::value, memory_size_type >::type Parma_Polyhedra_Library::total_memory_in_bytes ( const T & ) [inline]

For native types, returns the total size in bytes of the memory occupied by the type of the (unused) parameter, i.e., 0.

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

00079                                 {
00080   return sizeof(T);
00081 }

memory_size_type Parma_Polyhedra_Library::total_memory_in_bytes ( const GMP_Integer & x )

template<typename Info>

bool Parma_Polyhedra_Library::unrepresentability_error	(	I_Result	r,
		const Info &
	)			`[inline]`

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

References lower(), and upper().

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

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

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

Referenced by unrepresentability_error().

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

const char * Parma_Polyhedra_Library::version ( )

Returns a character string containing the PPL version.

Definition at line 93 of file version.cc.

References version_string.

00093              {
00094   return version_string;
00095 }

unsigned Parma_Polyhedra_Library::version_beta ( )

Returns the beta number of the PPL version.

Definition at line 88 of file version.cc.

References PPL_VERSION_BETA.

00088                   {
00089   return PPL_VERSION_BETA;
00090 }

unsigned Parma_Polyhedra_Library::version_major ( )

Returns the major number of the PPL version.

Definition at line 73 of file version.cc.

References PPL_VERSION_MAJOR.

00073                    {
00074   return PPL_VERSION_MAJOR;
00075 }

unsigned Parma_Polyhedra_Library::version_minor ( )

Returns the minor number of the PPL version.

Definition at line 78 of file version.cc.

References PPL_VERSION_MINOR.

00078                    {
00079   return PPL_VERSION_MINOR;
00080 }

unsigned Parma_Polyhedra_Library::version_revision ( )

Returns the revision number of the PPL version.

Definition at line 83 of file version.cc.

References PPL_VERSION_REVISION.

00083                       {
00084   return PPL_VERSION_REVISION;
00085 }

Parma_Polyhedra_Library Namespace Reference [C++ Language Interface]

Classes

Namespaces

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Parma_Polyhedra_Library Namespace Reference
[C++ Language Interface]