diff options
Diffstat (limited to 'src/tool/moneycount/inf.hpp')
| -rw-r--r-- | src/tool/moneycount/inf.hpp | 228 |
1 files changed, 228 insertions, 0 deletions
diff --git a/src/tool/moneycount/inf.hpp b/src/tool/moneycount/inf.hpp new file mode 100644 index 0000000..f28541a --- /dev/null +++ b/src/tool/moneycount/inf.hpp @@ -0,0 +1,228 @@ +#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
|