Modern C++ how to create constexpr array of power of 10?

#include <iostream>
using namespace std;
class FastFtoa {
public:
static inline constexpr double __inv_pow_10[] = {
1.0,                                      // 0
0.1f,                                      // 1
0.01,                                     // 2
0.001,                                    // 3
0.0001,                                   // 4
0.00001,                                  // 5
0.000001,                                 // 6
0.0000001,                                // 7
0.00000001,                               // 8
0.000000001,                              // 9
0.0000000001,                             // 10
0.00000000001,                            // 11
0.000000000001,                           // 12
0.0000000000001,                          // 13
0.00000000000001,                         // 14
0.000000000000001,                        // 15
0.0000000000000001,                       // 16
0.00000000000000001,                      // 17
0.000000000000000001,                     // 18
0.0000000000000000001,                    // 19
0.00000000000000000001,                   // 20
0.000000000000000000001,                  // 21
0.0000000000000000000001,                 // 22
0.00000000000000000000001,                // 23
0.000000000000000000000001,               // 24
0.0000000000000000000000001,              // 25
0.00000000000000000000000001,             // 26
0.000000000000000000000000001,            // 27
0.0000000000000000000000000001,           // 28
0.00000000000000000000000000001,          // 29
0.000000000000000000000000000001,         // 30
0.0000000000000000000000000000001,        // 31
0.00000000000000000000000000000001,       // 32
0.000000000000000000000000000000001,      // 33
0.0000000000000000000000000000000001,     // 34
0.00000000000000000000000000000000001,    // 35
0.000000000000000000000000000000000001,   // 36
0.00000000000000000000000000000000000001, // 37
0.000000000000000000000000000000000000001 // 38
};
static inline constexpr double __pos_pow_10[] = {
1.0,                                      // 0
10.0,                                     // 1
100.0,                                    // 2
1000.0,                                   // 3
10000.0,                                  // 4
100000.0,                                 // 5
1000000.0,                                // 6
10000000.0,                               // 7
100000000.0,                              // 8
1000000000.0,                             // 9
10000000000.0,                            // 10
100000000000.0,                           // 11
1000000000000.0,                          // 12
10000000000000.0,                         // 13
100000000000000.0,                        // 14
1000000000000000.0,                       // 15
10000000000000000.0,                      // 16
100000000000000000.0,                     // 17
1000000000000000000.0,                    // 18
10000000000000000000.0,                   // 19
100000000000000000000.0,                  // 20
1000000000000000000000.0,                 // 21
10000000000000000000000.0,                // 22
100000000000000000000000.0,               // 23
1000000000000000000000000.0,              // 24
10000000000000000000000000.0,             // 25
100000000000000000000000000.0,            // 26
1000000000000000000000000000.0,           // 27
10000000000000000000000000000.0,          // 28
100000000000000000000000000000.0,         // 29
1000000000000000000000000000000.0,        // 30
10000000000000000000000000000000.0,       // 31
100000000000000000000000000000000.0,      // 32
1000000000000000000000000000000000.0,     // 33
10000000000000000000000000000000000.0,    // 34
100000000000000000000000000000000000.0,   // 35
1000000000000000000000000000000000000.0,  // 36
10000000000000000000000000000000000000.0, // 37
100000000000000000000000000000000000000.0 // 38
};
};
int main()
{
cout << FastFtoa::__inv_pow_10[37] << " " << FastFtoa::__pos_pow_10[37] << "\n";
return 0;
}

I need to create constexpr array of 10^x and 10^-x, for x in range <s>-64..64</s> -38..38. It's for fast float to string conversion. It also needs to be inside a static class (all functions are public static).

It's possible to create them manually like in the code above, but it doesn't look good. Not to mention the full float64 range is 10^308, and that will be a very ugly code if it's done manually.

In C++17/20, what's the proper way to do this?

#include <algorithm>
#include <array>
#include <cmath>
#include <iostream>
#include <utility>
template<typename T, T... ints>
constexpr auto sequence1(std::integer_sequence<T, ints...>)
{
return std::array{std::pow(10L, ints)...};
}
template<typename T, T... ints>
constexpr auto sequence2(std::integer_sequence<T, ints...>)
{
return std::array{(1/std::pow(10L, ints))...};
}
int main()
{
constexpr auto my_arr1 = sequence1(std::make_integer_sequence<size_t, 20>{});
constexpr auto my_arr2 = sequence2(std::make_integer_sequence<size_t, 20>{});
std::cout << my_arr1[5] << std::endl;
std::cout << my_arr2[5] << std::endl;
return 0;
}

You can make use of the fact that std::array is constexpr. And as long as you have calculations that can be done at compile time you can fill that array with calculated values.

In this example : make_pow_10_map makes a map of powers of 10. Simply dividing 1.0f by 10.f in a loop, and multiplying 1.0f by 10.f in another loop. All the values are stored in one array (you can easiliy do the same for 2 arrays).

Then this compile time array is used in a simple lookup function that returns precalculated values.

#include <array>
#include <iostream>
#include <stdexcept>
template<std::size_t N>
static constexpr auto make_pow_10_map()
{
std::array<float, (2 * N)> values{};
float value{ 1.0 };
for (std::size_t n = (N-1); n > 0ul; --n)
{
values[n] = value;
value /= 10.0f;
}
values[0] = value;
value = 1.0;
for (std::size_t n = (N-1); n < 2*N; ++n)
{
values[n] = value;
value *= 10.0f;
}
return values;
}
float pow_10(int n)
{
constexpr std::size_t N{37ul};
static constexpr auto powers_of_10 = make_pow_10_map<N>();
int limit = N;
if ((n < -limit) || (n > limit)) throw std::invalid_argument{"index out of range"};
std::size_t index = (powers_of_10.size() / 2ul) + n - 1ul;
return powers_of_10[index];
}
int main()
{
std::cout << pow_10(-3) << "\n";
std::cout << pow_10(0) << "\n";
std::cout << pow_10(6) << "\n";
std::cout << pow_10(10) << "\n";
std::cout << pow_10(11) << "\n";
return 0;
}

One can use an unnamed lambda to initialize the constexpr std::array to reduce namespace clutter. inline is redundant for static constexprs.

#include <array>
#include <iostream>
class FastFtoa {
public:
static constexpr size_t N{39};
static constexpr std::array<float, N> _pos_pow_10 = []() {
std::array<float, N> x{1};
for (size_t i = 1; i < N; i++)
x[i] = 10*x[i-1];
return x;
}();
static constexpr std::array<float, N> _inv_pow_10 = []() {
std::array<float, N> x{1};
for (size_t i = 1; i < N; i++)
x[i] = .1f * x[i - 1];
return x;
}();
};
int main()
{
std::cout << FastFtoa::_pos_pow_10[0] << '\n';
std::cout << FastFtoa::_pos_pow_10[38] << '\n';
std::cout << FastFtoa::_inv_pow_10[0] << '\n';
std::cout << FastFtoa::_inv_pow_10[38] << '\n';
}

Output:

1
1e+38
1
1e-38