boost::multiprecision: What's the cheapest way to multiply or divide by a huge power of 10? Something like bitshift op for powers of 10?

Question

Consider the following MCVE:

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

int main()
{
    boost::multiprecision::cpp_int x = 10;
    x *= 10000000000000000000000000000000000000000000000000000000000000;
    std::cout<<x<<std::endl;
    return 0;
}

It produces a wrong result, due to the obvious overflow from that int. How can I do this correctly, assuming I don't want to involve strings? Is there something like a "digit shift operator" or a power function that can do this cheaply (or cheapest possible)?

Why? Because I have a fixed-precision library that I wrote, and scaling the internal integer requires such operations to be 100% safe.

Find the example here.

Answer 1

You'll want a function to auto-generate the number you need.

boost::multiprecision::cpp_int pow(boost::multiprecision::cpp_int value, boost::multiprecision::cpp_int exponent) {
    if(exponent <= 0)
        return 1;
    else if(exponent == 1)
        return value;
    else {
        if(exponent % 2 == 0) {
            return pow(value * value, exponent / 2);
        } else {
            return value * pow(value, exponent - 1);
        }
    }
}

int main()
{
    boost::multiprecision::cpp_int x = 10;
    x *= pow(10, 61);//I believe this is the correct number of 0's from manually counting
    std::cout<<x<<std::endl;
    return 0;
}

If boost.multiprecision has a baked in pow function (I couldn't find one), use that instead.