| Home | Libraries | People | FAQ | More

#### tom_int

`#include <boost/multiprecision/tommath.hpp>`

    namespace boost{ namespace multiprecision{

    class tommath_int;

    typedef number<tommath_int >         tom_int;

    }} // namespaces

The `tommath_int` back-end is used via the typedef `boost::multiprecision::tom_int`. It acts as a thin wrapper around the libtommath `tom_int` to provide an integer type that is a drop-in replacement for the native C++ integer types, but with unlimited precision.

Things you should know when using this type:

- Default constructed objects have the value zero (this is libtommath's default behavior).
- Although `tom_int` is mostly a drop in replacement for the builtin integer types, it should be noted that it is a rather strange beast as it's a signed type that is not a 2's complement type. As a result the bitwise operations `| & ^` will throw a `std::runtime_error` exception if either of the arguments is negative. Similarly the complement operator`~` is deliberately not implemented for this type.
- Formatted IO for this type does not support octal or hexadecimal notation for negative values, as a result performing formatted output on this type when the argument is negative and either of the flags `std::ios_base::oct` or `std::ios_base::hex` are set, will result in a `std::runtime_error` will be thrown.
- Conversion from a string results in a `std::runtime_error` being thrown if the string can not be interpreted as a valid integer.
- Division by zero results in a `std::overflow_error` being thrown.

###### Example:

    #include <boost/multiprecision/tommath.hpp>
    #include <iostream>

    int main()
    {
       boost::multiprecision::tom_int v = 1;

       // Do some arithmetic:
       for(unsigned i = 1; i <= 1000; ++i)
          v *= i;

       std::cout << v << std::endl; // prints 1000!
       std::cout << std::hex << v << std::endl; // prints 1000! in hex format

       try{
          std::cout << std::hex << -v << std::endl; // Ooops! can't print a negative value in hex format!
       }
       catch(const std::runtime_error& e)
       {
          std::cout << e.what() << std::endl;
       }

       try{
          // v is not a 2's complement type, bitwise operations are only supported
          // on positive values:
          v = -v & 2;
       }
       catch(const std::runtime_error& e)
       {
          std::cout << e.what() << std::endl;
       }

       return 0;
    }