-#ifndef STLPLUS_INF\r
-#define STLPLUS_INF\r
-////////////////////////////////////////////////////////////////////////////////\r
-\r
-// Author: Andy Rushton\r
-// Copyright: (c) Southampton University 1999-2004\r
-// (c) Andy Rushton 2004-2009\r
-// License: BSD License, see ../docs/license.html\r
-\r
-// An infinite-precision integer class. This allows calculations on large\r
-// integers to be performed without overflow.\r
-\r
-// this class can throw the following exceptions:\r
-// std::out_of_range\r
-// std::overflow_error\r
-// std::invalid_argument\r
-// stlplus::divide_by_zero // why doesn't std have this?\r
-// all of these are derivations of the baseclass:\r
-// std::logic_error\r
-// So you can catch all of them by catching the baseclass\r
-\r
-// Warning: inf was never intended to be fast, it is just for programs which\r
-// need a bit of infinite-precision integer arithmetic. For high-performance\r
-// processing, use the Gnu Multi-Precision (GMP) library. The inf type is just\r
-// easier to integrate and is already ported to all platforms and compilers\r
-// that STLplus is ported to.\r
-\r
-////////////////////////////////////////////////////////////////////////////////\r
-#include "portability_fixes.hpp"\r
-#include "portability_exceptions.hpp"\r
-#include <string>\r
-#include <iostream>\r
-\r
-////////////////////////////////////////////////////////////////////////////////\r
-\r
-namespace stlplus\r
-{\r
-\r
-////////////////////////////////////////////////////////////////////////////////\r
-\r
- class inf\r
- {\r
- public:\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // constructors and assignments initialise the inf\r
-\r
- // the void constructor initialises to zero, the others initialise to the\r
- // value of the C integer type or the text value contained in the string\r
-\r
- inf(void);\r
- explicit inf(short);\r
- explicit inf(unsigned short);\r
- explicit inf(int);\r
- explicit inf(unsigned);\r
- explicit inf(long);\r
- explicit inf(unsigned long);\r
- explicit inf(const std::string&) throw(std::invalid_argument);\r
- inf(const inf&);\r
-\r
- ~inf(void);\r
-\r
- // assignments with equivalent behaviour to the constructors\r
-\r
- inf& operator = (short);\r
- inf& operator = (unsigned short);\r
- inf& operator = (int);\r
- inf& operator = (unsigned);\r
- inf& operator = (long);\r
- inf& operator = (unsigned long);\r
- inf& operator = (const std::string&) throw(std::invalid_argument);\r
- inf& operator = (const inf&);\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // conversions back to the C types\r
- // truncate: controls the behaviour when the value is too long for the result\r
- // true: truncate the value\r
- // false: throw an exception\r
-\r
- short to_short(bool truncate = true) const throw(std::overflow_error);\r
- unsigned short to_unsigned_short(bool truncate = true) const throw(std::overflow_error);\r
-\r
- int to_int(bool truncate = true) const throw(std::overflow_error);\r
- unsigned to_unsigned(bool truncate = true) const throw(std::overflow_error);\r
-\r
- long to_long(bool truncate = true) const throw(std::overflow_error);\r
- unsigned long to_unsigned_long(bool truncate = true) const throw(std::overflow_error);\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // bitwise manipulation\r
-\r
- void resize(unsigned bits);\r
- void reduce(void);\r
-\r
- // the number of significant bits in the value\r
- unsigned bits (void) const;\r
- unsigned size (void) const;\r
-\r
- // the number of bits that can be accessed by the bit() method (=bits() rounded up to the next byte)\r
- unsigned indexable_bits(void) const;\r
-\r
- bool bit (unsigned index) const throw(std::out_of_range);\r
- bool operator [] (unsigned index) const throw(std::out_of_range);\r
-\r
- void set (unsigned index) throw(std::out_of_range);\r
- void clear (unsigned index) throw(std::out_of_range);\r
- void preset (unsigned index, bool value) throw(std::out_of_range);\r
-\r
- inf slice(unsigned low, unsigned high) const throw(std::out_of_range);\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // tests for common values or ranges\r
-\r
- bool negative (void) const;\r
- bool natural (void) const;\r
- bool positive (void) const;\r
- bool zero (void) const;\r
- bool non_zero (void) const;\r
-\r
- // tests used in if(i) and if(!i)\r
-// operator bool (void) const;\r
- bool operator ! (void) const;\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // comparisons\r
-\r
- bool operator == (const inf&) const;\r
- bool operator != (const inf&) const;\r
- bool operator < (const inf&) const;\r
- bool operator <= (const inf&) const;\r
- bool operator > (const inf&) const;\r
- bool operator >= (const inf&) const;\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // bitwise logic operations\r
-\r
- inf& invert (void);\r
- inf operator ~ (void) const;\r
-\r
- inf& operator &= (const inf&);\r
- inf operator & (const inf&) const;\r
-\r
- inf& operator |= (const inf&);\r
- inf operator | (const inf&) const;\r
-\r
- inf& operator ^= (const inf&);\r
- inf operator ^ (const inf&) const;\r
-\r
- inf& operator <<= (unsigned shift);\r
- inf operator << (unsigned shift) const;\r
-\r
- inf& operator >>= (unsigned shift);\r
- inf operator >> (unsigned shift) const;\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // arithmetic operations\r
-\r
- inf& negate (void);\r
- inf operator - (void) const;\r
-\r
- inf& abs(void);\r
- friend inf abs(const inf&);\r
-\r
- inf& operator += (const inf&);\r
- inf operator + (const inf&) const;\r
-\r
- inf& operator -= (const inf&);\r
- inf operator - (const inf&) const;\r
-\r
- inf& operator *= (const inf&);\r
- inf operator * (const inf&) const;\r
-\r
- inf& operator /= (const inf&) throw(divide_by_zero);\r
- inf operator / (const inf&) const throw(divide_by_zero);\r
-\r
- inf& operator %= (const inf&) throw(divide_by_zero);\r
- inf operator % (const inf&) const throw(divide_by_zero);\r
-\r
- // combined division operator - returns the result pair(quotient,remainder) in one go\r
- std::pair<inf,inf> divide(const inf&) const throw(divide_by_zero);\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // pre- and post- increment and decrement\r
-\r
- inf& operator ++ (void);\r
- inf operator ++ (int);\r
- inf& operator -- (void);\r
- inf operator -- (int);\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- // string representation and I/O\r
-\r
- std::string image_debug(void) const;\r
-\r
- // conversion to a string representation\r
- // radix must be 10, 2, 8 or 16\r
- std::string to_string(unsigned radix = 10) const\r
- throw(std::invalid_argument);\r
-\r
- // conversion from a string\r
- // radix == 0 - radix is deduced from the input - assumed 10 unless number is prefixed by 0b, 0 or 0x\r
- // however, you can specify the radix to be 10, 2, 8 or 16 to force that interpretation\r
- inf& from_string(const std::string&, unsigned radix = 0)\r
- throw(std::invalid_argument);\r
-\r
- //////////////////////////////////////////////////////////////////////////////\r
- private:\r
- std::string m_data;\r
- public:\r
- const std::string& get_bytes(void) const;\r
- void set_bytes(const std::string&);\r
- };\r
-\r
- ////////////////////////////////////////////////////////////////////////////////\r
- // redefine friends for gcc v4.1\r
-\r
- inf abs(const inf&);\r
-\r
- ////////////////////////////////////////////////////////////////////////////////\r
-\r
- std::ostream& operator << (std::ostream&, const inf&);\r
- std::istream& operator >> (std::istream&, inf&);\r
-\r
- ////////////////////////////////////////////////////////////////////////////////\r
-\r
-} // end namespace stlplus\r
-\r
-#endif\r
+#ifndef STLPLUS_INF
+#define STLPLUS_INF
+////////////////////////////////////////////////////////////////////////////////
+
+// Author: Andy Rushton
+// Copyright: (c) Southampton University 1999-2004
+// (c) Andy Rushton 2004-2009
+// License: BSD License, see ../docs/license.html
+
+// An infinite-precision integer class. This allows calculations on large
+// integers to be performed without overflow.
+
+// this class can throw the following exceptions:
+// std::out_of_range
+// std::overflow_error
+// std::invalid_argument
+// stlplus::divide_by_zero // why doesn't std have this?
+// all of these are derivations of the baseclass:
+// std::logic_error
+// So you can catch all of them by catching the baseclass
+
+// Warning: inf was never intended to be fast, it is just for programs which
+// need a bit of infinite-precision integer arithmetic. For high-performance
+// processing, use the Gnu Multi-Precision (GMP) library. The inf type is just
+// easier to integrate and is already ported to all platforms and compilers
+// that STLplus is ported to.
+
+////////////////////////////////////////////////////////////////////////////////
+#include "portability_fixes.hpp"
+#include "portability_exceptions.hpp"
+#include <string>
+#include <iostream>
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace stlplus
+{
+
+////////////////////////////////////////////////////////////////////////////////
+
+ class inf
+ {
+ public:
+
+ //////////////////////////////////////////////////////////////////////////////
+ // constructors and assignments initialise the inf
+
+ // the void constructor initialises to zero, the others initialise to the
+ // value of the C integer type or the text value contained in the string
+
+ inf(void);
+ explicit inf(short);
+ explicit inf(unsigned short);
+ explicit inf(int);
+ explicit inf(unsigned);
+ explicit inf(long);
+ explicit inf(unsigned long);
+ explicit inf(const std::string&) throw(std::invalid_argument);
+ inf(const inf&);
+
+ ~inf(void);
+
+ // assignments with equivalent behaviour to the constructors
+
+ inf& operator = (short);
+ inf& operator = (unsigned short);
+ inf& operator = (int);
+ inf& operator = (unsigned);
+ inf& operator = (long);
+ inf& operator = (unsigned long);
+ inf& operator = (const std::string&) throw(std::invalid_argument);
+ inf& operator = (const inf&);
+
+ //////////////////////////////////////////////////////////////////////////////
+ // conversions back to the C types
+ // truncate: controls the behaviour when the value is too long for the result
+ // true: truncate the value
+ // false: throw an exception
+
+ short to_short(bool truncate = true) const throw(std::overflow_error);
+ unsigned short to_unsigned_short(bool truncate = true) const throw(std::overflow_error);
+
+ int to_int(bool truncate = true) const throw(std::overflow_error);
+ unsigned to_unsigned(bool truncate = true) const throw(std::overflow_error);
+
+ long to_long(bool truncate = true) const throw(std::overflow_error);
+ unsigned long to_unsigned_long(bool truncate = true) const throw(std::overflow_error);
+
+ //////////////////////////////////////////////////////////////////////////////
+ // bitwise manipulation
+
+ void resize(unsigned bits);
+ void reduce(void);
+
+ // the number of significant bits in the value
+ unsigned bits (void) const;
+ unsigned size (void) const;
+
+ // the number of bits that can be accessed by the bit() method (=bits() rounded up to the next byte)
+ unsigned indexable_bits(void) const;
+
+ bool bit (unsigned index) const throw(std::out_of_range);
+ bool operator [] (unsigned index) const throw(std::out_of_range);
+
+ void set (unsigned index) throw(std::out_of_range);
+ void clear (unsigned index) throw(std::out_of_range);
+ void preset (unsigned index, bool value) throw(std::out_of_range);
+
+ inf slice(unsigned low, unsigned high) const throw(std::out_of_range);
+
+ //////////////////////////////////////////////////////////////////////////////
+ // tests for common values or ranges
+
+ bool negative (void) const;
+ bool natural (void) const;
+ bool positive (void) const;
+ bool zero (void) const;
+ bool non_zero (void) const;
+
+ // tests used in if(i) and if(!i)
+// operator bool (void) const;
+ bool operator ! (void) const;
+
+ //////////////////////////////////////////////////////////////////////////////
+ // comparisons
+
+ bool operator == (const inf&) const;
+ bool operator != (const inf&) const;
+ bool operator < (const inf&) const;
+ bool operator <= (const inf&) const;
+ bool operator > (const inf&) const;
+ bool operator >= (const inf&) const;
+
+ //////////////////////////////////////////////////////////////////////////////
+ // bitwise logic operations
+
+ inf& invert (void);
+ inf operator ~ (void) const;
+
+ inf& operator &= (const inf&);
+ inf operator & (const inf&) const;
+
+ inf& operator |= (const inf&);
+ inf operator | (const inf&) const;
+
+ inf& operator ^= (const inf&);
+ inf operator ^ (const inf&) const;
+
+ inf& operator <<= (unsigned shift);
+ inf operator << (unsigned shift) const;
+
+ inf& operator >>= (unsigned shift);
+ inf operator >> (unsigned shift) const;
+
+ //////////////////////////////////////////////////////////////////////////////
+ // arithmetic operations
+
+ inf& negate (void);
+ inf operator - (void) const;
+
+ inf& abs(void);
+ friend inf abs(const inf&);
+
+ inf& operator += (const inf&);
+ inf operator + (const inf&) const;
+
+ inf& operator -= (const inf&);
+ inf operator - (const inf&) const;
+
+ inf& operator *= (const inf&);
+ inf operator * (const inf&) const;
+
+ inf& operator /= (const inf&) throw(divide_by_zero);
+ inf operator / (const inf&) const throw(divide_by_zero);
+
+ inf& operator %= (const inf&) throw(divide_by_zero);
+ inf operator % (const inf&) const throw(divide_by_zero);
+
+ // combined division operator - returns the result pair(quotient,remainder) in one go
+ std::pair<inf,inf> divide(const inf&) const throw(divide_by_zero);
+
+ //////////////////////////////////////////////////////////////////////////////
+ // pre- and post- increment and decrement
+
+ inf& operator ++ (void);
+ inf operator ++ (int);
+ inf& operator -- (void);
+ inf operator -- (int);
+
+ //////////////////////////////////////////////////////////////////////////////
+ // string representation and I/O
+
+ std::string image_debug(void) const;
+
+ // conversion to a string representation
+ // radix must be 10, 2, 8 or 16
+ std::string to_string(unsigned radix = 10) const
+ throw(std::invalid_argument);
+
+ // conversion from a string
+ // radix == 0 - radix is deduced from the input - assumed 10 unless number is prefixed by 0b, 0 or 0x
+ // however, you can specify the radix to be 10, 2, 8 or 16 to force that interpretation
+ inf& from_string(const std::string&, unsigned radix = 0)
+ throw(std::invalid_argument);
+
+ //////////////////////////////////////////////////////////////////////////////
+ private:
+ std::string m_data;
+ public:
+ const std::string& get_bytes(void) const;
+ void set_bytes(const std::string&);
+ };
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // redefine friends for gcc v4.1
+
+ inf abs(const inf&);
+
+ ////////////////////////////////////////////////////////////////////////////////
+
+ std::ostream& operator << (std::ostream&, const inf&);
+ std::istream& operator >> (std::istream&, inf&);
+
+ ////////////////////////////////////////////////////////////////////////////////
+
+} // end namespace stlplus
+
+#endif
projects / chaz / yoink / blobdiff