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>

Inheritance diagram for Parma_Polyhedra_Library::Checked_Number< T, Policy >:

Inheritance graph
[legend]
Collaboration diagram for Parma_Polyhedra_Library::Checked_Number< T, Policy >:

Collaboration graph
[legend]

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 (const signed char y, Rounding_Dir dir)
 Direct initialization from a signed char and rounding mode.
 Checked_Number (const signed short y, Rounding_Dir dir)
 Direct initialization from a signed short and rounding mode.
 Checked_Number (const signed int y, Rounding_Dir dir)
 Direct initialization from a signed int and rounding mode.
 Checked_Number (const signed long y, Rounding_Dir dir)
 Direct initialization from a signed long and rounding mode.
 Checked_Number (const signed long long y, Rounding_Dir dir)
 Direct initialization from a signed long long and rounding mode.
 Checked_Number (const unsigned char y, Rounding_Dir dir)
 Direct initialization from an unsigned char and rounding mode.
 Checked_Number (const unsigned short y, Rounding_Dir dir)
 Direct initialization from an unsigned short and rounding mode.
 Checked_Number (const unsigned int y, Rounding_Dir dir)
 Direct initialization from an unsigned int and rounding mode.
 Checked_Number (const unsigned long y, Rounding_Dir dir)
 Direct initialization from an unsigned long and rounding mode.
 Checked_Number (const 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.
 Checked_Number (const Minus_Infinity &y, Rounding_Dir dir)
 Direct initialization from minus infinity and rounding mode.
 Checked_Number (const Plus_Infinity &y, Rounding_Dir dir)
 Direct initialization from plus infinity and rounding mode.
 Checked_Number (const Not_A_Number &y, Rounding_Dir dir)
 Direct initialization from NAN 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 (const signed char y)
 Direct initialization from a signed char, default rounding mode.
 Checked_Number (const signed short y)
 Direct initialization from a signed short, default rounding mode.
 Checked_Number (const signed int y)
 Direct initialization from a signed int, default rounding mode.
 Checked_Number (const signed long y)
 Direct initialization from a signed long, default rounding mode.
 Checked_Number (const signed long long y)
 Direct initialization from a signed long long, default rounding mode.
 Checked_Number (const unsigned char y)
 Direct initialization from an unsigned char, default rounding mode.
 Checked_Number (const unsigned short y)
 Direct initialization from an unsigned short, default rounding mode.
 Checked_Number (const unsigned int y)
 Direct initialization from an unsigned int, default rounding mode.
 Checked_Number (const unsigned long y)
 Direct initialization from an unsigned long, default rounding mode.
 Checked_Number (const unsigned long long y)
 Direct initialization from an unsigned long long, default rounding mode.
 Checked_Number (const float y)
 Direct initialization from a float, default rounding mode.
 Checked_Number (const double y)
 Direct initialization from a double, default rounding mode.
 Checked_Number (const 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.
 Checked_Number (const Minus_Infinity &y)
 Direct initialization from minus infinity, default rounding mode.
 Checked_Number (const Plus_Infinity &y)
 Direct initialization from plus infinity, default rounding mode.
 Checked_Number (const Not_A_Number &y)
 Direct initialization from NAN, 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, typename From_Policy>
Checked_Numberoperator= (const Checked_Number< From, From_Policy > &y)
 Assignment operator.
template<typename From>
Checked_Numberoperator= (const From &y)
 Assignment operator.
Checked_Numberoperator= (const Not_A_Number &y)
 Assignment operator.
Checked_Numberoperator= (const Minus_Infinity &y)
 Assignment operator.
Checked_Numberoperator= (const Plus_Infinity &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, typename From_Policy>
Checked_Numberoperator+= (const Checked_Number< From, From_Policy > &y)
 Add and assign operator.
template<typename From>
Checked_Numberoperator+= (const From &y)
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, typename From_Policy>
Checked_Numberoperator-= (const Checked_Number< From, From_Policy > &y)
 Subtract and assign operator.
template<typename From>
Checked_Numberoperator-= (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, typename From_Policy>
Checked_Numberoperator*= (const Checked_Number< From, From_Policy > &y)
 Multiply and assign operator.
template<typename From>
Checked_Numberoperator*= (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, typename From_Policy>
Checked_Numberoperator/= (const Checked_Number< From, From_Policy > &y)
 Divide and assign operator.
template<typename From>
Checked_Numberoperator/= (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, typename From_Policy>
Checked_Numberoperator%= (const Checked_Number< From, From_Policy > &y)
 Compute remainder and assign operator.
template<typename From>
Checked_Numberoperator%= (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, typename Policy>
void swap (Checked_Number< T, Policy > &x, Checked_Number< T, Policy > &y)
 Swaps *this with y.
template<typename T, typename Policy>
Result input (Checked_Number< T, Policy > &x, std::istream &is, Rounding_Dir dir)
Accessor Functions
template<typename T, typename Policy>
const T & raw_value (const Checked_Number< T, Policy > &x)
 Returns a const reference to the underlying native integer value.
template<typename T, typename Policy>
T & raw_value (Checked_Number< T, Policy > &x)
 Returns a reference to the underlying native integer value.
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>
size_t 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 neg_assign (Checked_Number< T, Policy > &x)
 Assigns to x its negation.
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, const Checked_Number< T, Policy > &y, const Checked_Number< T, Policy > &z, Checked_Number< T, Policy > &s, Checked_Number< T, Policy > &t)
 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 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 Policy1, typename T2, typename Policy2>
bool operator== (const Checked_Number< T1, Policy1 > &x, const Checked_Number< T2, Policy2 > &y)
 Equality operator.
template<typename T1, typename Policy1, typename T2, typename Policy2>
bool operator!= (const Checked_Number< T1, Policy1 > &x, const Checked_Number< T2, Policy2 > &y)
 Disequality operator.
template<typename T1, typename Policy1, typename T2, typename Policy2>
bool operator>= (const Checked_Number< T1, Policy1 > &x, const Checked_Number< T2, Policy2 > &y)
 Greater than or equal to operator.
template<typename T1, typename Policy1, typename T2, typename Policy2>
bool operator> (const Checked_Number< T1, Policy1 > &x, const Checked_Number< T2, Policy2 > &y)
 Greater than operator.
template<typename T1, typename Policy1, typename T2, typename Policy2>
bool operator<= (const Checked_Number< T1, Policy1 > &x, const Checked_Number< T2, Policy2 > &y)
 Less than or equal to operator.
template<typename T1, typename Policy1, typename T2, typename Policy2>
bool operator< (const Checked_Number< T1, Policy1 > &x, const Checked_Number< T2, Policy2 > &y)
 Less than operator.
template<typename T, typename Policy>
int sgn (const Checked_Number< T, Policy > &x)
 Returns $-1$, $0$ or $1$ depending on whether the value of x is negative, zero or positive, respectively.
template<typename T1, typename Policy1, typename T2, typename Policy2>
int cmp (const Checked_Number< T1, Policy1 > &x, const Checked_Number< T2, Policy2 > &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, typename Policy>
Result output (std::ostream &os, const Checked_Number< T, Policy > &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, typename Policy>
Result input (std::istream &is, Checked_Number< T, Policy > &x, 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 185 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 76 of file Checked_Number.inlines.hh.

00077  : v(0) {
00078 }

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

00082                                                                  {
00083   // TODO: avoid default construction of value member
00084   Checked::copy<Policy>(v, y.raw_value());
00085 }

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 91 of file Checked_Number.inlines.hh.

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

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

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const 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 ( const 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 ( const 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 ( const 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 ( const 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 ( const 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 ( const 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 ( const 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 ( const 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 ( const 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>
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 153 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.

00153                                                                          {
00154   std::istringstream s(x);
00155   Policy::handle_result(check_result(Checked::input<Policy>(v,
00156                                                             s,
00157                                                             rounding_dir(dir)),
00158                                      dir));
00159 }

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

Direct initialization from minus infinity and rounding mode.

Definition at line 196 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.

00197                                                             {
00198   // TODO: avoid default construction of value member
00199   Policy::handle_result(check_result(Checked::assign<Policy>(v,
00200                                                              x,
00201                                                              rounding_dir(dir)),
00202                                      dir));
00203 }

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

Direct initialization from plus infinity and rounding mode.

Definition at line 218 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.

00219                                                             {
00220   // TODO: avoid default construction of value member
00221   Policy::handle_result(check_result(Checked::assign<Policy>(v,
00222                                                              x,
00223                                                              rounding_dir(dir)),
00224                                      dir));
00225 }

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

Direct initialization from NAN and rounding mode.

Definition at line 174 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.

00175                                                             {
00176   // TODO: avoid default construction of value member
00177   Policy::handle_result(check_result(Checked::assign<Policy>(v,
00178                                                              x,
00179                                                              rounding_dir(dir)),
00180                                      dir));
00181 }

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 104 of file Checked_Number.inlines.hh.

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

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

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const 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 ( const 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 ( const 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 ( const 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 ( const 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 ( const 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 ( const 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 ( const 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 ( const 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 ( const 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 ( const float  y  ) 

Direct initialization from a float, default rounding mode.

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

Direct initialization from a double, default rounding mode.

template<typename T, typename Policy>
Parma_Polyhedra_Library::Checked_Number< T, Policy >::Checked_Number ( const 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 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   Rounding_Dir dir = Policy::ROUND_DEFAULT_CONSTRUCTOR;
00166   Policy::handle_result(check_result(Checked::input<Policy>(v,
00167                                                             s,
00168                                                             rounding_dir(dir)),
00169                                      dir));
00170 }

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

Direct initialization from minus infinity, default rounding mode.

Definition at line 207 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.

00207                                                                  {
00208   // TODO: avoid default construction of value member
00209   Rounding_Dir dir = Policy::ROUND_DEFAULT_CONSTRUCTOR_INF;
00210   Policy::handle_result(check_result(Checked::assign<Policy>(v,
00211                                                              x,
00212                                                              rounding_dir(dir)),
00213                                      dir));
00214 }

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

Direct initialization from plus infinity, default rounding mode.

Definition at line 229 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.

00229                                                                 {
00230   // TODO: avoid default construction of value member
00231   Rounding_Dir dir = Policy::ROUND_DEFAULT_CONSTRUCTOR_INF;
00232   Policy::handle_result(check_result(Checked::assign<Policy>(v,
00233                                                              x,
00234                                                              rounding_dir(dir)),
00235                                      dir));
00236 }

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

Direct initialization from NAN, default 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   // TODO: avoid default construction of value member
00187   Rounding_Dir dir = ROUND_IGNORE;
00188   Policy::handle_result(check_result(Checked::assign<Policy>(v,
00189                                                              x,
00190                                                              rounding_dir(dir)),
00191                                      dir));
00192 }


Member Function Documentation

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 264 of file Checked_Number.inlines.hh.

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

00264                                             {
00265   if (Policy::convertible)
00266     return v;
00267 }

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

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 277 of file Checked_Number.inlines.hh.

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

00277                                            {
00278   return v;
00279 }

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 297 of file Checked_Number.inlines.hh.

00297                                     {
00298   return true;
00299 }

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 303 of file Checked_Number.inlines.hh.

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

00303                                                                        {
00304   return Checked::classify<Policy>(v, nan, inf, sign);
00305 }

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

00470                                                                        {
00471   Checked::copy<Policy>(v, y.raw_value());
00472   return *this;
00473 }

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

Assignment operator.

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

References Parma_Polyhedra_Library::assign_r().

00478                                                       {
00479   Policy::handle_result(assign_r(*this, y, Policy::ROUND_DEFAULT_OPERATOR));
00480   return *this;
00481 }

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 485 of file Checked_Number.inlines.hh.

References Parma_Polyhedra_Library::assign_r().

00485                                                   {
00486   Policy::handle_result(assign_r(*this, y, Policy::ROUND_DEFAULT_OPERATOR));
00487   return *this;
00488 }

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

Assignment operator.

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

References Parma_Polyhedra_Library::assign_r().

00491                                                           {
00492   Policy::handle_result(assign_r(*this, y, ROUND_IGNORE));
00493   return *this;
00494 }

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

Assignment operator.

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

References Parma_Polyhedra_Library::assign_r().

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

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

Assignment operator.

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

References Parma_Polyhedra_Library::assign_r().

00503                                                            {
00504   Policy::handle_result(assign_r(*this, y, Policy::ROUND_DEFAULT_ASSIGN_INF));
00505   return *this;
00506 }

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+= ( const T &  y  ) 

Add and assign operator.

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

Add and assign operator.

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

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>
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, typename From_Policy>
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator-= ( const Checked_Number< From, From_Policy > &  y  )  [inline]

Subtract and assign operator.

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

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]

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, typename From_Policy>
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator*= ( const Checked_Number< From, From_Policy > &  y  )  [inline]

Multiply and assign operator.

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

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]

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, typename From_Policy>
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator/= ( const Checked_Number< From, From_Policy > &  y  )  [inline]

Divide and assign operator.

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

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]

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, typename From_Policy>
Checked_Number& Parma_Polyhedra_Library::Checked_Number< T, Policy >::operator%= ( const Checked_Number< From, From_Policy > &  y  )  [inline]

Compute remainder and assign operator.

template<typename T, typename Policy>
template<typename From>
Checked_Number& 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++ (  ) 

Pre-increment 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-decrement operator.

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

Post-decrement operator.


Friends And Related Function Documentation

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

Swaps *this with y.

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

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

00464                                                                  {
00465   std::swap(x.raw_value(), y.raw_value());
00466 }

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

Returns a const reference to the underlying native integer value.

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

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

Referenced by extended_rational_term(), and term_to_unsigned().

00284                                               {
00285   return x.raw_value();
00286 }

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

Returns a reference to the underlying native integer value.

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

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

00291                                         {
00292   return x.raw_value();
00293 }

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 328 of file Checked_Number.inlines.hh.

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

00328                                                           {
00329   return Checked::total_memory_in_bytes(x.raw_value());
00330 }

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 335 of file Checked_Number.inlines.hh.

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

00335                                                              {
00336   return Checked::external_memory_in_bytes(x.raw_value());
00337 }

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

Unary plus operator.

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

00650                                               {
00651   return x;
00652 }

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

Unary minus operator.

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

00657                                               {
00658   Checked_Number<T, Policy> r;
00659   Policy::handle_result(neg_assign_r(r, x, Policy::ROUND_DEFAULT_OPERATOR));
00660   return r;
00661 }

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

Assigns to x its negation.

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

Referenced by Parma_Polyhedra_Library::normalize2().

template<typename T, typename Policy>
void gcdext_assign ( Checked_Number< T, Policy > &  x,
const Checked_Number< T, Policy > &  y,
const Checked_Number< T, Policy > &  z,
Checked_Number< T, Policy > &  s,
Checked_Number< T, Policy > &  t 
) [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, 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 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 716 of file Checked_Number.inlines.hh.

Referenced by Parma_Polyhedra_Library::normalize2().

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

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 T1, typename Policy1, typename T2, typename Policy2>
bool operator== ( const Checked_Number< T1, Policy1 > &  x,
const Checked_Number< T2, Policy2 > &  y 
) [related]

Equality operator.

template<typename T1, typename Policy1, typename T2, typename Policy2>
bool operator!= ( const Checked_Number< T1, Policy1 > &  x,
const Checked_Number< T2, Policy2 > &  y 
) [related]

Disequality operator.

template<typename T1, typename Policy1, typename T2, typename Policy2>
bool operator>= ( const Checked_Number< T1, Policy1 > &  x,
const Checked_Number< T2, Policy2 > &  y 
) [related]

Greater than or equal to operator.

template<typename T1, typename Policy1, typename T2, typename Policy2>
bool operator> ( const Checked_Number< T1, Policy1 > &  x,
const Checked_Number< T2, Policy2 > &  y 
) [related]

Greater than operator.

template<typename T1, typename Policy1, typename T2, typename Policy2>
bool operator<= ( const Checked_Number< T1, Policy1 > &  x,
const Checked_Number< T2, Policy2 > &  y 
) [related]

Less than or equal to operator.

template<typename T1, typename Policy1, typename T2, typename Policy2>
bool operator< ( const Checked_Number< T1, Policy1 > &  x,
const Checked_Number< T2, Policy2 > &  y 
) [related]

Less than operator.

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

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

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

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

00725                                         {
00726   Result r = Checked::sgn_ext<Policy>(x.raw_value());
00727   switch (r) {
00728   case V_LT:
00729     return -1;
00730   case V_EQ:
00731     return 0;
00732   case V_GT:
00733     return 1;
00734   default:
00735     throw(0);
00736   }
00737 }

template<typename T1, typename Policy1, typename T2, typename Policy2>
int cmp ( const Checked_Number< T1, Policy1 > &  x,
const Checked_Number< T2, Policy2 > &  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 743 of file Checked_Number.inlines.hh.

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

00744                                           {
00745   Result r = Checked::cmp_ext<Policy1, Policy2>(x.raw_value(), y.raw_value());
00746   switch (r) {
00747   case V_LT:
00748     return -1;
00749   case V_EQ:
00750     return 0;
00751   case V_GT:
00752     return 1;
00753   default:
00754     throw(0);
00755   }
00756 }

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

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

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

00762                                                     {
00763   return check_result(Checked::output_ext<Policy>(os,
00764                                                   x.raw_value(),
00765                                                   fmt,
00766                                                   rounding_dir(dir)),
00767                       dir);
00768 }

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

Output operator.

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

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

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

template<typename T, typename Policy>
Result input ( std::istream &  is,
Checked_Number< T, Policy > &  x,
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^^;
  • 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                                     | '*^'
        | 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'
                                                        ;

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

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, typename Policy>
Result input ( Checked_Number< T, Policy > &  x,
std::istream &  is,
Rounding_Dir  dir 
) [related]

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

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


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 Wed Jul 16 22:55:44 2008 for PPL by  doxygen 1.5.6