-#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
+#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 onwards\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
projects / chaz / yoink / blobdiff