Parma_Polyhedra_Library::Checked_Number< T, Policy > Class Template Reference
[C++ Language Interface]

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

#include <Checked_Number.defs.hh>

List of all members.

Public Member Functions

bool OK () const
 Checks if all the invariants are satisfied.
Result classify (bool nan=true, bool inf=true, bool sign=true) const
 Classifies *this.
Constructors

 Checked_Number ()
 Default constructor.
 Checked_Number (const Checked_Number &y)
 Copy constructor.
template<typename From , typename From_Policy >
 Checked_Number (const Checked_Number< From, From_Policy > &y, Rounding_Dir dir)
 Direct initialization from a Checked_Number and rounding mode.
 Checked_Number (char y, Rounding_Dir dir)
 Direct initialization from a plain char and rounding mode.
 Checked_Number (signed char y, Rounding_Dir dir)
 Direct initialization from a signed char and rounding mode.
 Checked_Number (signed short y, Rounding_Dir dir)
 Direct initialization from a signed short and rounding mode.
 Checked_Number (signed int y, Rounding_Dir dir)
 Direct initialization from a signed int and rounding mode.
 Checked_Number (signed long y, Rounding_Dir dir)
 Direct initialization from a signed long and rounding mode.
 Checked_Number (signed long long y, Rounding_Dir dir)
 Direct initialization from a signed long long and rounding mode.
 Checked_Number (unsigned char y, Rounding_Dir dir)
 Direct initialization from an unsigned char and rounding mode.
 Checked_Number (unsigned short y, Rounding_Dir dir)
 Direct initialization from an unsigned short and rounding mode.
 Checked_Number (unsigned int y, Rounding_Dir dir)
 Direct initialization from an unsigned int and rounding mode.
 Checked_Number (unsigned long y, Rounding_Dir dir)
 Direct initialization from an unsigned long and rounding mode.
 Checked_Number (unsigned long long y, Rounding_Dir dir)
 Direct initialization from an unsigned long long and rounding mode.
 Checked_Number (const mpq_class &y, Rounding_Dir dir)
 Direct initialization from a rational and rounding mode.
 Checked_Number (const mpz_class &y, Rounding_Dir dir)
 Direct initialization from an unbounded integer and rounding mode.
 Checked_Number (const char *y, Rounding_Dir dir)
 Direct initialization from a C string and rounding mode.
template<typename From >
 Checked_Number (const From &, Rounding_Dir dir, typename Enable_If< Is_Special< From >::value, bool >::type ignored=false)
 Direct initialization from special and rounding mode.
template<typename From , typename From_Policy >
 Checked_Number (const Checked_Number< From, From_Policy > &y)
 Direct initialization from a Checked_Number, default rounding mode.
 Checked_Number (char y)
 Direct initialization from a plain char, default rounding mode.
 Checked_Number (signed char y)
 Direct initialization from a signed char, default rounding mode.
 Checked_Number (signed short y)
 Direct initialization from a signed short, default rounding mode.
 Checked_Number (signed int y)
 Direct initialization from a signed int, default rounding mode.
 Checked_Number (signed long y)
 Direct initialization from a signed long, default rounding mode.
 Checked_Number (signed long long y)
 Direct initialization from a signed long long, default rounding mode.
 Checked_Number (unsigned char y)
 Direct initialization from an unsigned char, default rounding mode.
 Checked_Number (unsigned short y)
 Direct initialization from an unsigned short, default rounding mode.
 Checked_Number (unsigned int y)
 Direct initialization from an unsigned int, default rounding mode.
 Checked_Number (unsigned long y)
 Direct initialization from an unsigned long, default rounding mode.
 Checked_Number (unsigned long long y)
 Direct initialization from an unsigned long long, default rounding mode.
 Checked_Number (float y)
 Direct initialization from a float, default rounding mode.
 Checked_Number (double y)
 Direct initialization from a double, default rounding mode.
 Checked_Number (long double y)
 Direct initialization from a long double, default rounding mode.
 Checked_Number (const mpq_class &y)
 Direct initialization from a rational, default rounding mode.
 Checked_Number (const mpz_class &y)
 Direct initialization from an unbounded integer, default rounding mode.
 Checked_Number (const char *y)
 Direct initialization from a C string, default rounding mode.
template<typename From >
 Checked_Number (const From &, typename Enable_If< Is_Special< From >::value, bool >::type ignored=false)
 Direct initialization from special, default rounding mode.
Accessors and Conversions

 operator T () const
 Conversion operator: returns a copy of the underlying numeric value.
T & raw_value ()
 Returns a reference to the underlying numeric value.
const T & raw_value () const
 Returns a const reference to the underlying numeric value.
Assignment Operators

Checked_Numberoperator= (const Checked_Number &y)
 Assignment operator.
template<typename From >
Checked_Numberoperator= (const From &y)
 Assignment operator.
template<typename From_Policy >
Checked_Numberoperator+= (const Checked_Number< T, From_Policy > &y)
 Add and assign operator.
Checked_Numberoperator+= (const T &y)
 Add and assign operator.
template<typename From >
Enable_If
< Is_Native_Or_Checked< From >
::value, Checked_Number< T,
Policy > & >::type 
operator+= (const From &y)
 Add and assign operator.
template<typename From_Policy >
Checked_Numberoperator-= (const Checked_Number< T, From_Policy > &y)
 Subtract and assign operator.
Checked_Numberoperator-= (const T &y)
 Subtract and assign operator.
template<typename From >
Enable_If
< Is_Native_Or_Checked< From >
::value, Checked_Number< T,
Policy > & >::type 
operator-= (const From &y)
 Subtract and assign operator.
template<typename From_Policy >
Checked_Numberoperator*= (const Checked_Number< T, From_Policy > &y)
 Multiply and assign operator.
Checked_Numberoperator*= (const T &y)
 Multiply and assign operator.
template<typename From >
Enable_If
< Is_Native_Or_Checked< From >
::value, Checked_Number< T,
Policy > & >::type 
operator*= (const From &y)
 Multiply and assign operator.
template<typename From_Policy >
Checked_Numberoperator/= (const Checked_Number< T, From_Policy > &y)
 Divide and assign operator.
Checked_Numberoperator/= (const T &y)
 Divide and assign operator.
template<typename From >
Enable_If
< Is_Native_Or_Checked< From >
::value, Checked_Number< T,
Policy > & >::type 
operator/= (const From &y)
 Divide and assign operator.
template<typename From_Policy >
Checked_Numberoperator%= (const Checked_Number< T, From_Policy > &y)
 Compute remainder and assign operator.
Checked_Numberoperator%= (const T &y)
 Compute remainder and assign operator.
template<typename From >
Enable_If
< Is_Native_Or_Checked< From >
::value, Checked_Number< T,
Policy > & >::type 
operator%= (const From &y)
 Compute remainder and assign operator.
Increment and Decrement Operators

Checked_Numberoperator++ ()
 Pre-increment operator.
Checked_Number operator++ (int)
 Post-increment operator.
Checked_Numberoperator-- ()
 Pre-decrement operator.
Checked_Number operator-- (int)
 Post-decrement operator.

Private Attributes

v
 The underlying numeric value.

Related Functions

(Note that these are not member functions.)



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_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_integer (const T &x)
template<typename To , typename From >
Enable_If
< Is_Native_Or_Checked< To >
::value &&Is_Special< From >
::value, Result >::type 
construct (To &to, const From &x, Rounding_Dir dir)
template<typename To , typename From >
Enable_If
< Is_Native_Or_Checked< To >
::value &&Is_Special< From >
::value, Result >::type 
assign_r (To &to, const From &x, Rounding_Dir dir)
template<typename To >
Enable_If
< Is_Native_Or_Checked< To >
::value, Result >::type 
assign_r (To &to, const char *x, Rounding_Dir dir)
template<typename To , typename To_Policy >
Enable_If
< Is_Native_Or_Checked< To >
::value, Result >::type 
assign_r (To &to, char *x, Rounding_Dir dir)
template<typename T , typename Policy >
void swap (Checked_Number< T, Policy > &x, Checked_Number< T, Policy > &y)
 Swaps x with y.
template<typename T , typename Policy >
const T & raw_value (const Checked_Number< T, Policy > &x)
template<typename T , typename Policy >
T & raw_value (Checked_Number< T, Policy > &x)
Memory Size Inspection Functions

template<typename T , typename Policy >
size_t total_memory_in_bytes (const Checked_Number< T, Policy > &x)
 Returns the total size in bytes of the memory occupied by x.
template<typename T , typename Policy >
memory_size_type external_memory_in_bytes (const Checked_Number< T, Policy > &x)
 Returns the size in bytes of the memory managed by x.
Arithmetic Operators

template<typename T , typename Policy >
Checked_Number< T, Policy > operator+ (const Checked_Number< T, Policy > &x)
 Unary plus operator.
template<typename T , typename Policy >
Checked_Number< T, Policy > operator- (const Checked_Number< T, Policy > &x)
 Unary minus operator.
template<typename T , typename Policy >
void floor_assign (Checked_Number< T, Policy > &x)
 Assigns to x largest integral value not greater than x.
template<typename T , typename Policy >
void floor_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y)
 Assigns to x largest integral value not greater than y.
template<typename T , typename Policy >
void ceil_assign (Checked_Number< T, Policy > &x)
 Assigns to x smallest integral value not less than x.
template<typename T , typename Policy >
void ceil_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y)
 Assigns to x smallest integral value not less than y.
template<typename T , typename Policy >
void trunc_assign (Checked_Number< T, Policy > &x)
 Round x to the nearest integer not larger in absolute value.
template<typename T , typename Policy >
void trunc_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y)
 Assigns to x the value of y rounded to the nearest integer not larger in absolute value.
template<typename T , typename Policy >
void neg_assign (Checked_Number< T, Policy > &x)
 Assigns to x its negation.
template<typename T , typename Policy >
void neg_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y)
 Assigns to x the negation of y.
template<typename T , typename Policy >
void abs_assign (Checked_Number< T, Policy > &x)
 Assigns to x its absolute value.
template<typename T , typename Policy >
void abs_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y)
 Assigns to x the absolute value of y.
template<typename T , typename Policy >
void add_mul_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y, const Checked_Number< T, Policy > &z)
 Assigns to x the value x + y * z.
template<typename T , typename Policy >
void sub_mul_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y, const Checked_Number< T, Policy > &z)
 Assigns to x the value x - y * z.
template<typename T , typename Policy >
void gcd_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y, const Checked_Number< T, Policy > &z)
 Assigns to x the greatest common divisor of y and z.
template<typename T , typename Policy >
void gcdext_assign (Checked_Number< T, Policy > &x, Checked_Number< T, Policy > &s, Checked_Number< T, Policy > &t, const Checked_Number< T, Policy > &y, const Checked_Number< T, Policy > &z)
 Assigns to x the greatest common divisor of y and z, setting s and t such that s*y + t*z = x = gcd(y, z).
template<typename T , typename Policy >
void lcm_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y, const Checked_Number< T, Policy > &z)
 Assigns to x the least common multiple of y and z.
template<typename T , typename Policy >
void mul_2exp_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y, unsigned int exp)
 Assigns to x the value $ y \cdot 2^\mathtt{exp} $.
template<typename T , typename Policy >
void div_2exp_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y, unsigned int exp)
 Assigns to x the value $ y / 2^\mathtt{exp} $.
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)
 If z divides y, assigns to x the quotient of the integer division of y and z.
template<typename T , typename Policy >
void sqrt_assign (Checked_Number< T, Policy > &x, const Checked_Number< T, Policy > &y)
 Assigns to x the integer square root of y.
Relational Operators and Comparison Functions

template<typename T1 , typename T2 >
Enable_If
< Is_Native_Or_Checked< T1 >
::value &&Is_Native_Or_Checked
< T2 >::value &&(Is_Checked
< T1 >::value||Is_Checked< T2 >
::value), bool >::type 
operator== (const T1 &x, const T2 &y)
 Equality operator.
template<typename T1 , typename T2 >
Enable_If
< Is_Native_Or_Checked< T1 >
::value &&Is_Native_Or_Checked
< T2 >::value &&(Is_Checked
< T1 >::value||Is_Checked< T2 >
::value), bool >::type 
operator!= (const T1 &x, const T2 &y)
 Disequality operator.
template<typename T1 , typename T2 >
Enable_If
< Is_Native_Or_Checked< T1 >
::value &&Is_Native_Or_Checked
< T2 >::value &&(Is_Checked
< T1 >::value||Is_Checked< T2 >
::value), bool >::type 
operator>= (const T1 &x, const T2 &y)
 Greater than or equal to operator.
template<typename T1 , typename T2 >
Enable_If
< Is_Native_Or_Checked< T1 >
::value &&Is_Native_Or_Checked
< T2 >::value &&(Is_Checked
< T1 >::value||Is_Checked< T2 >
::value), bool >::type 
operator> (const T1 &x, const T2 &y)
 Greater than operator.
template<typename T1 , typename T2 >
Enable_If
< Is_Native_Or_Checked< T1 >
::value &&Is_Native_Or_Checked
< T2 >::value &&(Is_Checked
< T1 >::value||Is_Checked< T2 >
::value), bool >::type 
operator<= (const T1 &x, const T2 &y)
 Less than or equal to operator.
template<typename T1 , typename T2 >
Enable_If
< Is_Native_Or_Checked< T1 >
::value &&Is_Native_Or_Checked
< T2 >::value &&(Is_Checked
< T1 >::value||Is_Checked< T2 >
::value), bool >::type 
operator< (const T1 &x, const T2 &y)
 Less than operator.
template<typename From >
Enable_If
< Is_Native_Or_Checked< From >
::value, int >::type 
sgn (const From &x)
 Returns $-1$, $0$ or $1$ depending on whether the value of x is negative, zero or positive, respectively.
template<typename From1 , typename From2 >
Enable_If
< Is_Native_Or_Checked< From1 >
::value &&Is_Native_Or_Checked
< From2 >::value, int >::type 
cmp (const From1 &x, const From2 &y)
 Returns a negative, zero or positive value depending on whether x is lower than, equal to or greater than y, respectively.
Input-Output Operators

template<typename T >
Enable_If
< Is_Native_Or_Checked< T >
::value, Result >::type 
output (std::ostream &os, const T &x, const Numeric_Format &fmt, Rounding_Dir dir)
template<typename T , typename Policy >
std::ostream & operator<< (std::ostream &os, const Checked_Number< T, Policy > &x)
 Output operator.
template<typename T >
Enable_If
< Is_Native_Or_Checked< T >
::value, Result >::type 
input (T &x, std::istream &is, Rounding_Dir dir)
 Input function.
template<typename T , typename Policy >
std::istream & operator>> (std::istream &is, Checked_Number< T, Policy > &x)
 Input operator.

Detailed Description

template<typename T, typename Policy>
class Parma_Polyhedra_Library::Checked_Number< T, Policy >

A wrapper for numeric types implementing a given policy.

The wrapper and related functions implement an interface which is common to all kinds of coefficient types, therefore allowing for a uniform coding style. This class also implements the policy encoded by the second template parameter. The default policy is to perform the detection of overflow errors.

Definition at line 159 of file Checked_Number.defs.hh.


Constructor & Destructor Documentation

template<typename T , typename Policy >
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number (  )  [inline]

Default constructor.

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

00073  : v(0) {
00074 }

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

Copy constructor.

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

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

00078                                                                  {
00079   // TODO: avoid default construction of value member.
00080   Checked::copy<Policy, Policy>(v, y.raw_value());
00081 }

template<typename T , typename Policy >
template<typename From , typename From_Policy >
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const Checked_Number< From, From_Policy > &  y,
Rounding_Dir  dir 
) [inline]

Direct initialization from a Checked_Number and rounding mode.

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

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

00088                                    {
00089   // TODO: avoid default construction of value member.
00090   Policy::handle_result(check_result(Checked::assign_ext<Policy, From_Policy>
00091                                      (v,
00092                                       y.raw_value(),
00093                                       rounding_dir(dir)),
00094                                      dir)
00095                         );
00096 }

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( char  y,
Rounding_Dir  dir 
)

Direct initialization from a plain char and rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( signed char  y,
Rounding_Dir  dir 
)

Direct initialization from a signed char and rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( signed short  y,
Rounding_Dir  dir 
)

Direct initialization from a signed short and rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( signed int  y,
Rounding_Dir  dir 
)

Direct initialization from a signed int and rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( signed long  y,
Rounding_Dir  dir 
)

Direct initialization from a signed long and rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( signed long long  y,
Rounding_Dir  dir 
)

Direct initialization from a signed long long and rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( unsigned char  y,
Rounding_Dir  dir 
)

Direct initialization from an unsigned char and rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( unsigned short  y,
Rounding_Dir  dir 
)

Direct initialization from an unsigned short and rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( unsigned int  y,
Rounding_Dir  dir 
)

Direct initialization from an unsigned int and rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( unsigned long  y,
Rounding_Dir  dir 
)

Direct initialization from an unsigned long and rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( unsigned long long  y,
Rounding_Dir  dir 
)

Direct initialization from an unsigned long long and rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const mpq_class &  y,
Rounding_Dir  dir 
)

Direct initialization from a rational and rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const mpz_class &  y,
Rounding_Dir  dir 
)

Direct initialization from an unbounded integer and rounding mode.

template<typename T , typename Policy >
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const char *  y,
Rounding_Dir  dir 
) [inline]

Direct initialization from a C string and rounding mode.

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

References Parma_Polyhedra_Library::check_result(), Parma_Polyhedra_Library::rounding_dir(), and Parma_Polyhedra_Library::Checked_Number< T, Policy >::v.

00163                                                                          {
00164   std::istringstream s(x);
00165   Policy::handle_result(check_result(Checked::input<Policy>(v,
00166                                                             s,
00167                                                             rounding_dir(dir)),
00168                                      dir));
00169 }

template<typename T , typename Policy >
template<typename From >
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const From &  ,
Rounding_Dir  dir,
typename Enable_If< Is_Special< From >::value, bool >::type  ignored = false 
) [inline]

Direct initialization from special and rounding mode.

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

References Parma_Polyhedra_Library::check_result(), Parma_Polyhedra_Library::rounding_dir(), and Parma_Polyhedra_Library::Checked_Number< T, Policy >::v.

00185                                                                                                                             {
00186   Policy::handle_result(check_result(Checked::assign_special<Policy>(v,
00187                                                             From::vclass,
00188                                                             rounding_dir(dir)),
00189                                      dir));
00190 }

template<typename T , typename Policy >
template<typename From , typename From_Policy >
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const Checked_Number< From, From_Policy > &  y  )  [inline, explicit]

Direct initialization from a Checked_Number, default rounding mode.

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

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

00102                                                            {
00103   // TODO: avoid default construction of value member.
00104   Rounding_Dir dir = Policy::ROUND_DEFAULT_CONSTRUCTOR;
00105   Policy::handle_result(check_result(Checked::assign_ext<Policy, From_Policy>
00106                                      (v,
00107                                       y.raw_value(),
00108                                       rounding_dir(dir)),
00109                                      dir));
00110 }

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( char  y  ) 

Direct initialization from a plain char, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( signed char  y  ) 

Direct initialization from a signed char, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( signed short  y  ) 

Direct initialization from a signed short, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( signed int  y  ) 

Direct initialization from a signed int, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( signed long  y  ) 

Direct initialization from a signed long, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( signed long long  y  ) 

Direct initialization from a signed long long, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( unsigned char  y  ) 

Direct initialization from an unsigned char, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( unsigned short  y  ) 

Direct initialization from an unsigned short, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( unsigned int  y  ) 

Direct initialization from an unsigned int, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( unsigned long  y  ) 

Direct initialization from an unsigned long, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( unsigned long long  y  ) 

Direct initialization from an unsigned long long, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( float  y  ) 

Direct initialization from a float, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( double  y  ) 

Direct initialization from a double, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( long double  y  ) 

Direct initialization from a long double, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const mpq_class &  y  ) 

Direct initialization from a rational, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const mpz_class &  y  ) 

Direct initialization from an unbounded integer, default rounding mode.

template<typename T , typename Policy >
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const char *  y  )  [inline]

Direct initialization from a C string, default rounding mode.

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

References Parma_Polyhedra_Library::check_result(), Parma_Polyhedra_Library::rounding_dir(), and Parma_Polyhedra_Library::Checked_Number< T, Policy >::v.

00173                                                        {
00174   std::istringstream s(x);
00175   Rounding_Dir dir = Policy::ROUND_DEFAULT_CONSTRUCTOR;
00176   Policy::handle_result(check_result(Checked::input<Policy>(v,
00177                                                             s,
00178                                                             rounding_dir(dir)),
00179                                      dir));
00180 }

template<typename T , typename Policy >
template<typename From >
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const From &  ,
typename Enable_If< Is_Special< From >::value, bool >::type  ignored = false 
) [inline]

Direct initialization from special, default rounding mode.

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

References Parma_Polyhedra_Library::check_result(), Parma_Polyhedra_Library::rounding_dir(), and Parma_Polyhedra_Library::Checked_Number< T, Policy >::v.

00195                                                                                                           {
00196   Rounding_Dir dir = Policy::ROUND_DEFAULT_CONSTRUCTOR;
00197   Policy::handle_result(check_result(Checked::assign_special<Policy>(v,
00198                                                             From::vclass,
00199                                                             rounding_dir(dir)),
00200                                      dir));
00201 }


Member Function Documentation

template<typename T , typename Policy >
Result Parma_Polyhedra_Library::Checked_Number< T, Policy >::classify ( bool  nan = true,
bool  inf = true,
bool  sign = true 
) const [inline]

Classifies *this.

Returns the appropriate Result characterizing:

  • whether *this is NaN, if nan is true;
  • whether *this is a (positive or negative) infinity, if inf is true;
  • the sign of *this, if sign is true.

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

References Parma_Polyhedra_Library::Checked_Number< T, Policy >::v.

00298                                                                        {
00299   return Checked::classify<Policy>(v, nan, inf, sign);
00300 }

template<typename T , typename Policy >
bool Parma_Polyhedra_Library::Checked_Number< T, Policy >::OK (  )  const [inline]

Checks if all the invariants are satisfied.

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

00292                                     {
00293   return true;
00294 }

template<typename T , typename Policy >
Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator T (  )  const [inline]

Conversion operator: returns a copy of the underlying numeric value.

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

References Parma_Polyhedra_Library::Checked_Number< T, Policy >::v.

00259                                             {
00260   if (Policy::convertible)
00261     return v;
00262 }

template<typename T, typename Policy>
template<typename From >
Enable_If<Is_Native_Or_Checked<From>::value, Checked_Number<T, Policy>& >::type Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator%= ( const From &  y  )  [inline]

Compute remainder and assign operator.

template<typename T, typename Policy>
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator%= ( const T &  y  ) 

Compute remainder and assign operator.

template<typename T, typename Policy>
template<typename From_Policy >
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator%= ( const Checked_Number< T, From_Policy > &  y  )  [inline]

Compute remainder and assign operator.

template<typename T, typename Policy>
template<typename From >
Enable_If<Is_Native_Or_Checked<From>::value, Checked_Number<T, Policy>&>::type Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator*= ( const From &  y  )  [inline]

Multiply and assign operator.

template<typename T, typename Policy>
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator*= ( const T &  y  ) 

Multiply and assign operator.

template<typename T, typename Policy>
template<typename From_Policy >
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator*= ( const Checked_Number< T, From_Policy > &  y  )  [inline]

Multiply and assign operator.

template<typename T, typename Policy>
Checked_Number Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator++ ( int   ) 

Post-increment operator.

template<typename T, typename Policy>
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator++ (  ) 

Pre-increment operator.

template<typename T, typename Policy>
template<typename From >
Enable_If<Is_Native_Or_Checked<From>::value, Checked_Number<T, Policy>&>::type Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator+= ( const From &  y  )  [inline]

Add and assign operator.

template<typename T, typename Policy>
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator+= ( const T &  y  ) 

Add and assign operator.

template<typename T, typename Policy>
template<typename From_Policy >
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator+= ( const Checked_Number< T, From_Policy > &  y  )  [inline]

Add and assign operator.

template<typename T, typename Policy>
Checked_Number Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator-- ( int   ) 

Post-decrement operator.

template<typename T, typename Policy>
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator-- (  ) 

Pre-decrement operator.

template<typename T, typename Policy>
template<typename From >
Enable_If<Is_Native_Or_Checked<From>::value, Checked_Number<T, Policy>&>::type Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator-= ( const From &  y  )  [inline]

Subtract and assign operator.

template<typename T, typename Policy>
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator-= ( const T &  y  ) 

Subtract and assign operator.

template<typename T, typename Policy>
template<typename From_Policy >
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator-= ( const Checked_Number< T, From_Policy > &  y  )  [inline]

Subtract and assign operator.

template<typename T, typename Policy>
template<typename From >
Enable_If<Is_Native_Or_Checked<From>::value, Checked_Number<T, Policy>&>::type Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator/= ( const From &  y  )  [inline]

Divide and assign operator.

template<typename T, typename Policy>
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator/= ( const T &  y  ) 

Divide and assign operator.

template<typename T, typename Policy>
template<typename From_Policy >
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator/= ( const Checked_Number< T, From_Policy > &  y  )  [inline]

Divide and assign operator.

template<typename T , typename Policy >
template<typename From >
Checked_Number< T, Policy > & Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator= ( const From &  y  )  [inline]

Assignment operator.

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

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

00497                                                   {
00498   Policy::handle_result(assign_r(*this, y, Policy::ROUND_DEFAULT_OPERATOR));
00499   return *this;
00500 }

template<typename T , typename Policy >
Checked_Number< T, Policy > & Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator= ( const Checked_Number< T, Policy > &  y  )  [inline]

Assignment operator.

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

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

00490                                                                        {
00491   Checked::copy<Policy, Policy>(v, y.raw_value());
00492   return *this;
00493 }

template<typename T , typename Policy >
const T & Parma_Polyhedra_Library::Checked_Number< T, Policy >::raw_value (  )  const [inline]

Returns a const reference to the underlying numeric value.

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

References Parma_Polyhedra_Library::Checked_Number< T, Policy >::v.

00272                                            {
00273   return v;
00274 }

template<typename T , typename Policy >
T & Parma_Polyhedra_Library::Checked_Number< T, Policy >::raw_value (  )  [inline]

Friends And Related Function Documentation

template<typename T , typename Policy >
void abs_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y 
) [related]

Assigns to x the absolute value of y.

template<typename T , typename Policy >
void abs_assign ( Checked_Number< T, Policy > &  x  )  [related]

Assigns to x its absolute value.

template<typename T , typename Policy >
void add_mul_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y,
const Checked_Number< T, Policy > &  z 
) [related]

Assigns to x the value x + y * z.

template<typename To , typename To_Policy >
Enable_If< Is_Native_Or_Checked< To >::value, Result >::type assign_r ( To &  to,
char *  x,
Rounding_Dir  dir 
) [related]
template<typename To >
Enable_If< Is_Native_Or_Checked< To >::value, Result >::type assign_r ( To &  to,
const char *  x,
Rounding_Dir  dir 
) [related]

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

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

00338                                                   {
00339   std::istringstream s(x);
00340   return check_result(Checked::input<typename Native_Checked_To_Wrapper<To>
00341                       ::Policy>(Native_Checked_To_Wrapper<To>::raw_value(to),
00342                                 s,
00343                                 rounding_dir(dir)),
00344                       dir);
00345 }

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 &  x,
Rounding_Dir  dir 
) [related]

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

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

00205                                                 {
00206   return check_result(Checked::assign_special<typename Native_Checked_To_Wrapper<To>
00207                       ::Policy>(Native_Checked_To_Wrapper<To>::raw_value(to),
00208                                 From::vclass,
00209                                 rounding_dir(dir)),
00210                       dir);
00211 }

template<typename T , typename Policy >
void ceil_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y 
) [related]

Assigns to x smallest integral value not less than y.

template<typename T , typename Policy >
void ceil_assign ( Checked_Number< T, Policy > &  x  )  [related]

Assigns to x smallest integral value not less than x.

template<typename From1 , typename From2 >
Enable_If< Is_Native_Or_Checked< From1 >::value &&Is_Native_Or_Checked< From2 >::value, int >::type cmp ( const From1 &  x,
const From2 &  y 
) [related]

Returns a negative, zero or positive value depending on whether x is lower than, equal to or greater than y, respectively.

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

References Parma_Polyhedra_Library::raw_value(), and Parma_Polyhedra_Library::Checked::Result_Relation.

00738                                     {
00739   Result_Relation r
00740     = Checked::cmp_ext<typename Native_Checked_From_Wrapper<From1>::Policy,
00741                        typename Native_Checked_From_Wrapper<From2>::Policy>
00742                  (Native_Checked_From_Wrapper<From1>::raw_value(x),
00743                   Native_Checked_From_Wrapper<From2>::raw_value(y));
00744   switch (r) {
00745   case VR_LT:
00746     return -1;
00747   case VR_EQ:
00748     return 0;
00749   case VR_GT:
00750     return 1;
00751   default:
00752     throw(0);
00753   }
00754 }

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

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

00215                                                  {
00216   return check_result(Checked::construct_special<typename Native_Checked_To_Wrapper<To>
00217                       ::Policy>(Native_Checked_To_Wrapper<To>::raw_value(to),
00218                                 From::vclass,
00219                                 rounding_dir(dir)),
00220                       dir);
00221 }

template<typename T , typename Policy >
void div_2exp_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y,
unsigned int  exp 
) [related]

Assigns to x the value $ y / 2^\mathtt{exp} $.

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 
) [related]

If z divides y, assigns to x the quotient of the integer division of y and z.

The behavior is undefined if z does not divide y.

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

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

template<typename T , typename Policy >
memory_size_type external_memory_in_bytes ( const Checked_Number< T, Policy > &  x  )  [related]

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

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

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

00330                                                              {
00331   return external_memory_in_bytes(x.raw_value());
00332 }

template<typename T , typename Policy >
void floor_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y 
) [related]

Assigns to x largest integral value not greater than y.

template<typename T , typename Policy >
void floor_assign ( Checked_Number< T, Policy > &  x  )  [related]

Assigns to x largest integral value not greater than x.

template<typename T , typename Policy >
void gcd_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y,
const Checked_Number< T, Policy > &  z 
) [related]

Assigns to x the greatest common divisor of y and z.

template<typename T , typename Policy >
void gcdext_assign ( Checked_Number< T, Policy > &  x,
Checked_Number< T, Policy > &  s,
Checked_Number< T, Policy > &  t,
const Checked_Number< T, Policy > &  y,
const Checked_Number< T, Policy > &  z 
) [related]

Assigns to x the greatest common divisor of y and z, setting s and t such that s*y + t*z = x = gcd(y, z).

template<typename T >
Enable_If< Is_Native_Or_Checked< T >::value, Result >::type input ( T &  x,
std::istream &  is,
Rounding_Dir  dir 
) [related]

Input function.

Parameters:
is Input stream to read from;
x Number (possibly extended) to assign to in case of successful reading;
dir Rounding mode to be applied.
Returns:
Result of the input operation. Success, success with imprecision, overflow, parsing error: all possibilities are taken into account, checked for, and properly reported.

This function attempts reading a (possibly extended) number from the given stream is, possibly rounding as specified by dir, assigning the result to x upon success, and returning the appropriate Result.

The input syntax allows the specification of:

  • plain base-10 integer numbers as 34976098, -77 and +13;
  • base-10 integer numbers in scientific notation as 15e2 and 15*^2 (both meaning $15 \cdot 10^2 = 1500$), 9200e-2 and -18*^+11111111111111111;
  • base-10 rational numbers in fraction notation as 15/3 and 15/-3;
  • base-10 rational numbers in fraction/scientific notation as 15/30e-1 (meaning $5$) and 15*^-3/29e2 (meaning $3/580000$);
  • base-10 rational numbers in floating point notation as 71.3 (meaning $713/10$) and -0.123456 (meaning $-1929/15625$);
  • base-10 rational numbers in floating point scientific notation as 2.2e-1 (meaning $11/50$) and -2.20001*^+3 (meaning $-220001/100$);
  • integers and rationals (in fractional, floating point and scientific notations) specified by using Mathematica-style bases, in the range from 2 to 36, as 2^^11 (meaning $3$), 36^^z (meaning $35$), 36^^xyz (meaning $44027$), 2^^11.1 (meaning $7/2$), 10^^2e3 (meaning $2000$), 8^^2e3 (meaning $1024$), 8^^2.1e3 (meaning $1088$), 8^^20402543.120347e7 (meaning $9073863231288$), 8^^2.1 (meaning $17/8$); note that the base and the exponent are always written as plain base-10 integer numbers; also, when an ambiguity may arise, the character e is interpreted as a digit, so that 16^^1e2 (meaning $482$) is different from 16^^1*^2 (meaning $256$);
  • the C-style hexadecimal prefix 0x is interpreted as the Mathematica-style prefix 16^^;
  • the C-style binary exponent indicator p can only be used when base 16 has been specified; if used, the exponent will be applied to base 2 (instead of base 16, as is the case when the indicator e is used);
  • special values like inf and +inf (meaning $+\infty$), -inf (meaning $-\infty$), and nan (meaning "not a number").

The rationale behind the accepted syntax can be summarized as follows:

  • if the syntax is accepted by Mathematica, then this function accepts it with the same semantics;
  • if the syntax is acceptable as standard C++ integer or floating point literal (except for octal notation and type suffixes, which are not supported), then this function accepts it with the same semantics;
  • natural extensions of the above are accepted with the natural extensions of the semantics;
  • special values are accepted.

Valid syntax is more formally and completely specified by the following grammar, with the additional provisos that everything is case insensitive, that the syntactic category BDIGIT is further restricted by the current base and that for all bases above 14, any e is always interpreted as a digit and never as a delimiter for the exponent part (if such a delimiter is desired, it has to be written as *^).

number  : NAN                                   INF     : 'inf'
        | SIGN INF                                      ;
        | INF
        | num                                   NAN     : 'nan'
        | num DIV num                                   ;
        ;
                                                SIGN    : '-'
num     : unum                                          | '+'
        | SIGN unum                                     ;

unum    : unum1                                 EXP     : 'e'
        | HEX unum1                                     | 'p'
        | base BASE unum1                               | '*^'
        ;                                               ;
                                                POINT   : '.'
unum1   : mantissa                                      ;
        | mantissa EXP exponent
        ;                                       DIV     : '/'
                                                        ;
mantissa: bdigits
        | POINT bdigits                         MINUS   : '-'
        | bdigits POINT                                 ;
        | bdigits POINT bdigits
        ;                                       PLUS    : '+'
                                                ;
exponent: SIGN digits
        | digits                                HEX     : '0x'
        ;                                       ;

bdigits : BDIGIT                                BASE    : '^^'
        | bdigits BDIGIT                                ;
        ;
                                                DIGIT   : '0' .. '9'
digits  : DIGIT                                         ;
        | digits DIGIT
        ;                                       BDIGIT  : '0' .. '9'
                                                        | 'a' .. 'z'
                                                        ;

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

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

00780                                               {
00781   return check_result(Checked::input_ext<typename Native_Checked_To_Wrapper<T>::Policy>
00782                       (Native_Checked_To_Wrapper<T>::raw_value(x),
00783                        is,
00784                        rounding_dir(dir)),
00785                       dir);
00786 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename T , typename Policy >
void lcm_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y,
const Checked_Number< T, Policy > &  z 
) [related]

Assigns to x the least common multiple of y and z.

template<typename T , typename Policy >
void mul_2exp_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y,
unsigned int  exp 
) [related]

Assigns to x the value $ y \cdot 2^\mathtt{exp} $.

template<typename T , typename Policy >
void neg_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y 
) [related]

Assigns to x the negation of y.

template<typename T , typename Policy >
void neg_assign ( Checked_Number< T, Policy > &  x  )  [related]

Assigns to x its negation.

template<typename T1 , typename T2 >
Enable_If< Is_Native_Or_Checked< T1 >::value &&Is_Native_Or_Checked< T2 >::value &&(Is_Checked< T1 >::value||Is_Checked< T2 >::value), bool >::type operator!= ( const T1 &  x,
const T2 &  y 
) [related]

Disequality operator.

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

00183                                      {
00184   return !(x == y);
00185 }

template<typename T , typename Policy >
Checked_Number< T, Policy > operator+ ( const Checked_Number< T, Policy > &  x  )  [related]

Unary plus operator.

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

00617                                               {
00618   return x;
00619 }

template<typename T , typename Policy >
Checked_Number< T, Policy > operator- ( const Checked_Number< T, Policy > &  x  )  [related]

Unary minus operator.

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

00624                                               {
00625   Checked_Number<T, Policy> r;
00626   Policy::handle_result(neg_assign_r(r, x, Policy::ROUND_DEFAULT_OPERATOR));
00627   return r;
00628 }

template<typename T1 , typename T2 >
Enable_If< Is_Native_Or_Checked< T1 >::value &&Is_Native_Or_Checked< T2 >::value &&(Is_Checked< T1 >::value||Is_Checked< T2 >::value), bool >::type operator< ( const T1 &  x,
const T2 &  y 
) [related]

Less than operator.

template<typename T , typename Policy >
std::ostream & operator<< ( std::ostream &  os,
const Checked_Number< T, Policy > &  x 
) [related]

Output operator.

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

00772                                                                {
00773   Policy::handle_result(output(os, x, Numeric_Format(), ROUND_IGNORE));
00774   return os;
00775 }

template<typename T1 , typename T2 >
Enable_If< Is_Native_Or_Checked< T1 >::value &&Is_Native_Or_Checked< T2 >::value &&(Is_Checked< T1 >::value||Is_Checked< T2 >::value), bool >::type operator<= ( const T1 &  x,
const T2 &  y 
) [related]

Less than or equal to operator.

template<typename T1 , typename T2 >
Enable_If< Is_Native_Or_Checked< T1 >::value &&Is_Native_Or_Checked< T2 >::value &&(Is_Checked< T1 >::value||Is_Checked< T2 >::value), bool >::type operator== ( const T1 &  x,
const T2 &  y 
) [related]

Equality operator.

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

00164                                      {
00165   PPL_ASSERT(f_OK(x));
00166   PPL_ASSERT(f_OK(y));
00167   if (check_empty_arg(x))
00168     return check_empty_arg(y);
00169   else if (check_empty_arg(y))
00170     return false;
00171   // FIXME: the two restrictions should be evaluated in the context of
00172   // the specific interval
00173   return eq_restriction(f_info(x), f_info(y))
00174     && eq(LOWER, f_lower(x), f_info(x), LOWER, f_lower(y), f_info(y))
00175     && eq(UPPER, f_upper(x), f_info(x), UPPER, f_upper(y), f_info(y));
00176 }

template<typename T1 , typename T2 >
Enable_If< Is_Native_Or_Checked< T1 >::value &&Is_Native_Or_Checked< T2 >::value &&(Is_Checked< T1 >::value||Is_Checked< T2 >::value), bool >::type operator> ( const T1 &  x,
const T2 &  y 
) [related]

Greater than operator.

template<typename T1 , typename T2 >
Enable_If< Is_Native_Or_Checked< T1 >::value &&Is_Native_Or_Checked< T2 >::value &&(Is_Checked< T1 >::value||Is_Checked< T2 >::value), bool >::type operator>= ( const T1 &  x,
const T2 &  y 
) [related]

Greater than or equal to operator.

template<typename T , typename Policy >
std::istream & operator>> ( std::istream &  is,
Checked_Number< T, Policy > &  x 
) [related]

Input operator.

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

References Parma_Polyhedra_Library::Checked::Result.

00791                                                               {
00792   Result r = input(x, is, Policy::ROUND_DEFAULT_INPUT);
00793   if (r == V_CVT_STR_UNK)
00794     is.setstate(std::ios::failbit);
00795   else
00796     Policy::handle_result(r);
00797   return is;
00798 }

template<typename T >
Enable_If< Is_Native_Or_Checked< T >::value, Result >::type output ( std::ostream &  os,
const T &  x,
const Numeric_Format &  fmt,
Rounding_Dir  dir 
) [related]

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

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

00760                                                     {
00761   return check_result(Checked::output_ext<typename Native_Checked_From_Wrapper<T>::Policy>
00762                       (os,
00763                        Native_Checked_From_Wrapper<T>::raw_value(x),
00764                        fmt,
00765                        rounding_dir(dir)),
00766                       dir);
00767 }

template<typename T , typename Policy >
T & raw_value ( Checked_Number< T, Policy > &  x  )  [related]

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

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

00286                                         {
00287   return x.raw_value();
00288 }

template<typename T , typename Policy >
const T & raw_value ( const Checked_Number< T, Policy > &  x  )  [related]

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

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

00279                                               {
00280   return x.raw_value();
00281 }

template<typename From >
Enable_If< Is_Native_Or_Checked< From >::value, int >::type sgn ( const From &  x  )  [related]

Returns $-1$, $0$ or $1$ depending on whether the value of x is negative, zero or positive, respectively.

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

References Parma_Polyhedra_Library::raw_value(), and Parma_Polyhedra_Library::Checked::Result_Relation.

00719                    {
00720   Result_Relation r = Checked::sgn_ext<typename Native_Checked_From_Wrapper<From>::Policy>(Native_Checked_From_Wrapper<From>::raw_value(x));
00721   switch (r) {
00722   case VR_LT:
00723     return -1;
00724   case VR_EQ:
00725     return 0;
00726   case VR_GT:
00727     return 1;
00728   default:
00729     throw(0);
00730   }
00731 }

template<typename T , typename Policy >
void sqrt_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y 
) [related]

Assigns to x the integer square root of y.

template<typename T , typename Policy >
void sub_mul_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y,
const Checked_Number< T, Policy > &  z 
) [related]

Assigns to x the value x - y * z.

template<typename T , typename Policy >
void swap ( Checked_Number< T, Policy > &  x,
Checked_Number< T, Policy > &  y 
) [related]

Swaps x with y.

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

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

00821                                                                  {
00822   using std::swap;
00823   swap(x.raw_value(), y.raw_value());
00824 }

template<typename T , typename Policy >
memory_size_type total_memory_in_bytes ( const Checked_Number< T, Policy > &  x  )  [related]

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

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

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

00323                                                           {
00324   return total_memory_in_bytes(x.raw_value());
00325 }

template<typename T , typename Policy >
void trunc_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y 
) [related]

Assigns to x the value of y rounded to the nearest integer not larger in absolute value.

template<typename T , typename Policy >
void trunc_assign ( Checked_Number< T, Policy > &  x  )  [related]

Round x to the nearest integer not larger in absolute value.


Member Data Documentation

template<typename T, typename Policy>
T Parma_Polyhedra_Library::Checked_Number< T, Policy >::v [private]

The documentation for this class was generated from the following files:
Generated on Sun Feb 27 16:20:20 2011 for PPL by  doxygen 1.6.3