// Crafted @ Apr 23, 2018 By Babak Sheykhan #include #include #include #include #include #include //#include #include #include /*-----------------------------*/ /* */ /* Conditional Compilation */ /* Block */ /* */ /*-----------------------------*/ // implementation dependant headers for Intel intrinsics #if defined(_MSC_VER) /* Microsoft C/C++-compatible compiler */ #include #elif defined(__GNUC__) || defined(__GNUG__) || defined(__clang__) #include /* GCC/G++-compatible compiler */ #endif // Is C++11 compliant? #if __cplusplus <= 199711L // Time keeper stuff for C++ <= 98 //#include #define TIME clock() #define DELTA(T2, T1) static_cast(T2 - T1) / CLOCKS_PER_SEC * 1000000.0 #define TYPE clock_t // Custom Ln2 #define LN2(X) ceil(log(static_cast(X)) / log(2.0)) #elif __cplusplus >= 201103L // Time keeper stuff for C++ >= 11 #include using namespace std::chrono; //namespace chrono = std::chrono; #define TIME chrono::high_resolution_clock::now() #define DELTA(T2, T1) chrono::duration_cast(T2 - T1).count() #define TYPE chrono::system_clock::time_point // Built-in Ln2 #define LN2(X) log2(static_cast(X)) #endif using namespace std; /* .................................... ... ____________________________ ... ...| Math (UML) |... ...+----------------------------+... ...| [No Attribute] |... ...|____________________________|... ...| [+] iPow64(UInt64, UInt64) |... ...| : UInt64 <> |... ...| [+] invSqrt(UInt64) |... ...| : Float <> |... ...| [+] nextPow2(UInt64) |... ...| : UInt64 <> |... ...| [-] iLog2(Double, Boolean) |... ...| : UInt64 <> |... ...| [-] sseSqrt(Float *) <> |... ...| [-] checkOverflow(UInt64, |... ...| UInt64) : Boolean <>|... ...|____________________________|... .................................... */ /*-----------------------------*/ /* */ /* Math.h */ /* */ /*-----------------------------*/ class Math { public: //static uint_fast64_t iAbs(int_fast64_t); static uint_fast64_t iPow64(uint_fast64_t, uint_fast64_t); static float invSqrt(uint_fast64_t); static uint_fast64_t nextPow2(uint_fast64_t); private: static uint_fast64_t iLog2(double, bool); static void sseSqrt(float *); static bool checkOverflow(uint_fast64_t, uint_fast64_t); }; /*-----------------------------*/ /* */ /* Math.cpp */ /* */ /*-----------------------------*/ /*uint_fast64_t Math::iAbs(int_fast64_t _n) { // [1] _n >> 63 : make a mask of the sign bit (a bit-sequence of all 1's for negative and 0's for positive input). // // [2] _n ^= tmp : Toggles the bits if input is negative. // // E.g. if _n is negative: // // _n = -14 = 1111 0010 // tmp = 1 = 1111 1111 // _n ^ tmp = 0000 1101 = 13 // // E.g. if _n is positive: // // _n = 14 = 0000 1110 // tmp = 0 = 0000 0000 // _n ^ tmp = 0000 1110 = 14 // // [3] _n += tmp & 1U : Add 1 if value was negative uint_fast64_t tmp = _n >> 63; _n ^= tmp; _n += tmp & 1U; return _n; }*/ uint_fast64_t Math::iPow64(uint_fast64_t _base, uint_fast64_t _exp) { // Stand-alone version with description @ https://code.sololearn.com/cEo9hzjtccQ0 uint_fast64_t result = 0; if (_base == 0 && _exp == 0) { cout << "\nMath ERROR\n"; return result; } if (_base == 0) return result; if (_exp == 0) return ++result; if (checkOverflow(_base, _exp)) { cout << "\nWARNING: Arithmetic overflow on iPow64.\n"; return result; } // Make lists of power and the value to that power unsigned size = static_cast(nextPow2(_exp)); vector powers; powers.reserve(size); vector val2pow; val2pow.reserve(size); // Start with the power 1 and value^1 uint_fast64_t lastPow = 1; uint_fast64_t lastVal = _base; while (lastPow <= _exp) { powers.push_back(lastPow); val2pow.push_back(lastVal); lastPow <<= 1; lastVal *= lastVal; } result = 1; // Get the index of the largest power that is smaller than exponent. for (unsigned powIdx = powers.size() - 1; powIdx >= 0 && powIdx < powers.size(); --powIdx) { // See if this power fits within exponent. if (powers[powIdx] <= _exp) { _exp -= powers[powIdx]; result *= val2pow[powIdx]; } } return result; } float Math::invSqrt(uint_fast64_t _n) { if (_n == 0) return static_cast(_n); float f_n = static_cast(_n); sseSqrt(&f_n); return f_n; } uint_fast64_t Math::nextPow2(uint_fast64_t _n) { // Due to rounding Err of FP when the input is close to (2^64 - 1), I provided a safety check here. if (_n > 0xFFFFFFFFFFFFF9B0ULL) return 64U; bool isPowOf2 = ((_n - 1) & _n) == 0; return iLog2(static_cast(_n), isPowOf2); } uint_fast64_t Math::iLog2(double _n, bool isPowOf2) { if (_n == 0) { //cout << "\nMath ERROR\n"; return 0; } // Credit: http://stereopsis.com/log2.html uint_fast64_t sequence = 0; memcpy(&sequence, &_n, sizeof(sequence)); // portable compared to reinterpret_cast // IEEE 754 - Double precision // https://en.wikipedia.org/wiki/IEEE_754-1985 // // * Significant precision -> 52-bit (explicitly) // Shifting the floating point number to right by 52 bits elliminates the fraction part of the sequence. // // * Exponent field -> 11-bit // * 11-bit mask as hex number 0x7FF --Bin-> 0111 1111 1111 // * bias -> 1023 // After Shifting, what remains is 11 bits of exponent field. ANDing that with 0x7FF mask extracts the actual exponent bits. // Subtracting from bias yields the lovely log2 without a hassle :) uint_fast64_t exp = (sequence >> 52ULL) & 0x7FFULL; uint_fast64_t log2 = exp - 1023; // If iLog2 being called by nextPow2 function, check 2^x < _n < 2^x+1 then add 1 to log2 (round up to next higher power of 2), otherwise, round down to the lower power of 2. return log2 + (!isPowOf2); // is Eq. to "isPowOf2 ? log2 : log2 + 1;" but without branching } void Math::sseSqrt(float *_n) { // SSE opcode block to perform Fast Inverse Sqrt (single-precision) // Credit : https://stackoverflow.com/questions/1528727/why-is-sse-scalar-sqrtx-slower-than-rsqrtx-x // Ref : https://en.wikipedia.org/wiki/Fast_inverse_square_root // Ref : Intel software developer's manual vol.2 / https://software.intel.com/sites/landingpage/IntrinsicsGuide/# // ================================= // ** Summary of instructions: // // xmm register scheme // // R3 R2 R1 R0 // +------+-----+-----+-----+ // |96-127|64-95|32-63| 0-31| // +------+-----+-----+-----+ // 4 * 32-bit = 128-bit // // SP : single-precision // FP : floating-point // // ---------------------------------- // __m128 // Kind of variable type to manipulate // 128-bit registers (xmm0-xmm7) // ---------------------------------- // __m128 _mm_load_ss(float const* mem) // ____load___| // | // v // +-----+-----+-----+-----+ // | 0x0 | 0x0 | 0x0 |*mem | // +-----+-----+-----+-----+ // R3 R2 R1 R0 // // Load a SP (32-bit) FP value // (its address) into the low word // (R0) and clears the upper three // words. // ---------------------------------- // __m128 _mm_rsqrt_ss (__m128 a) // // R3 R2 R1 R0 // +-----+-----+-----+-----+ // | a3 | a2 | a1 | a0 | <---+ // +-----+-----+-----+-----+ | // | _cpy_| | | | // || ___cpy___| | | // ||| __compute__| | // c|| | | // p|| v | // y|| APPROX(1.0 / SQRT(a0)) | // ||| |__store____ | // |||_________ | | // ||____ | | | // | | | | | // v v v v | // +-----+-----+-----+-----+ | // |dst3 |dst2 |dst1 |dst0 | <-+ | // +-----+-----+-----+-----+ | | // R3 R2 R1 R0 | | // | | // dst layout _________________| | // v // 32-bit segments of 'a' inside xmm // // Compute the approximate reciprocal // square root (InvSqrt) of the lower // SP FP element in 'a' (a0), store the // result in the lower element of 'dst' // (dst0), and copy the upper 3 packed // elements from 'a' to the upper elements // of dst [dst1-dst3]. The maximum // relative error for this approximation // is less than 1.5 * 2^-12. // ---------------------------------- // __m128 _mm_mul_ss (__m128 a, __m128 b) // // +----+ +----+ // ___| a3 | | b3 | // | +----+ +----+ // | __| a2 | | b2 | // || +----+ +----+ // || _| a1 | | b1 | // ||| +----+ +----+ // ||| | a0 |---> MUL <---| b0 | // ||| +----+ | +----+ // cpy |____ // |||____________ | // ||_______ | store // |__ | | | // | | | | // v v v v // +-----+-----+-----+-----+ // |dst3 |dst2 |dst1 |dst0 | // +-----+-----+-----+-----+ // R3 R2 R1 R0 // // Multiply the lower SP FP element in 'a' // and 'b' (a0 * b0), store the result in // the lower element of 'dst', and copy // the upper 3 packed elements from 'a' // to the upper elements of 'dst'. // ---------------------------------- // void _mm_store_ss (float* mem, __m128 a) // // R3 R2 R1 R0 // +-----+-----+-----+-----+ // | a3 | a2 | a1 | a0 | // +-----+-----+-----+-----+ // ______store_____| // | // | // v // +-----+ // | a0 | // +-----+ // mem // // Store the lower SP FP word from 'a' // into mem. // ---------------------------------- __m128 tmp = _mm_load_ss(_n); _mm_store_ss(_n, _mm_mul_ss(tmp, _mm_rsqrt_ss(tmp))); } bool Math::checkOverflow(uint_fast64_t _base, uint_fast64_t _exp) { bool is_of = false; if (_base <= 0xFFFFULL && _base > 0x1ULL) { // Experimental Over-flow checker plot: https://ggbm.at/yCBWReFu const double A = 44.3572915; // For rough adjustment const double B = 0.0004218; // For fine adjustment unsigned max_exp = static_cast(A / log((double)_base) + B); if (_exp > max_exp) is_of = true; } else { if (_base <= 2642245 && _exp > 0x3ULL) is_of = true; else if (_base <= 0xFFFFFFFFULL && _exp > 0x2ULL) is_of = true; else if (_exp > 0x1ULL) is_of = true; } return is_of; } /* .................................... ... ____________________________ ... ...| Fast64_t (UML) |... ...+----------------------------+... ...| [-] result : UInt64 <> |... ...|____________________________|... ...| [+] toFastInt(String &) |... ...| : UInt64 <> |... ...| [-] checkValidity(String &)|... ...| : Boolean <>|... ...| [-] toIntegral(String &) |... ...| : UInt64 <> |... ...| [-] getResult() |... ...| : UInt64 <> |... ...| [-] setResult(UInt64) <>|... ...|____________________________|... .................................... */ /*-----------------------------*/ /* */ /* Fast64_t.h */ /* */ /*-----------------------------*/ class Fast64_t { public: static uint_fast64_t toFastInt(const string &); private: // Error tolerable validator static bool checkValidity(const string &); // Converter static uint_fast64_t toIntegral(const string &); static uint_fast64_t getResult(); static void setResult(uint_fast64_t); static uint_fast64_t result; }; /*-----------------------------*/ /* */ /* Fast64_t.cpp */ /* */ /*-----------------------------*/ // Important: Storage for static data members should be declared in .cpp file uint_fast64_t Fast64_t::result; uint_fast64_t Fast64_t::toFastInt(const string &s) { if (!checkValidity(s)) return NULL; return getResult(); } bool Fast64_t::checkValidity(const string &s) { string modifiable_input; bool isValid = true; // Visual debugging of the pattern : https://www.debuggex.com/r/XSa25c9KyeczK5jx // Range : [0 to 99,999,999,999,999,999,999] without upper-bound checking regex valid("\\+?\\b([1-9]\\d{0,19})\\b|0"); // Visual debugging of the pattern : https://www.debuggex.com/r/bQa4O6hEXQkxczL5 // Floating-point (rough) pattern regex fp("(\\+|-)?\\d+\\.\\d+"); // this one is not correctable -> (\\+|-)?\\d*\\.\\d+ // Range : [-9,999,999,999,999,999,999 to -1] regex neg("-\\b([1-9]\\d{0,18})\\b"); // Visual debugging of the pattern : https://www.debuggex.com/r/0b0NsKOeTEc14j8z regex tooLong("\\+?[1-9]\\d{20,100}|-[1-9]\\d{19,100}"); // Visual debugging of the pattern : https://www.debuggex.com/r/YmE8QnQUmZLiIaAb // Exact range : [0 to 18,446,744,073,709,551,615] regex exactRange("\\+?\\b((0|[1-9][0-9]{0,18})|1[0-7][0-9]{18}|18[0-3][0-9]{17}|184[0-3][0-9]{16}|1844[0-5][0-9]{15}|18446[0-6][0-9]{14}|184467[0-3][0-9]{13}|1844674[0-3][0-9]{12}|18446744[0][0-6][0-9]{10}|1844674407[0-2][0-9]{9}|18446744073[0-6][0-9]{8}|184467440737[0][0-8][0-9]{6}|18446744073709[0-4][0-9]{5}|184467440737095[0-4][0-9]{4}|1844674407370955[0][0-9]{3}|18446744073709551[0-5][0-9]{2}|184467440737095516[0][0-9]|1844674407370955161[0-5])\\b"); // Process invalid input and see whether it can be resolved or not. if (!regex_match(s, valid)) { cout << "WARNING : Invalid input. Trying to correct...\n"; modifiable_input = s; if (regex_match(s, fp)) { cout << "CODE 01 : FP input detected.\n"; // Handling negative FP regex fp_neg("-\\d+\\.\\d+"); if (regex_match(modifiable_input, fp_neg)) modifiable_input.erase(0, 1); // Handling long FP if (modifiable_input.length() > 20) modifiable_input.resize(20); setResult(toIntegral(modifiable_input)); cout << s << " has truncated to " << getResult() << endl; } else if (regex_match(s, neg)) { cout << "CODE 02 : Negative input detected.\n"; modifiable_input.erase(0, 1); setResult(toIntegral(modifiable_input)); cout << s << " has changed to " << getResult() << endl; } else if (regex_match(s, tooLong)){ cout << "CODE 03 : Too long number. Can't be resolved due to data loss.\n"; isValid = false; } else { cout << "CODE 04 : Undefined input. Can't be resolved.\n"; isValid = false; } } // Process upper bound validity if everything was a go at first glance. else if (!regex_match(s, exactRange)) { cout << "CODE 05 : Out of range. Terminating due to wrap around.\n"; isValid = false; } // Go for a clean conversion and get the result. else setResult(toIntegral(s)); return isValid; } uint_fast64_t Fast64_t::toIntegral(const string &s) { uint_fast64_t numerical; stringstream str2num; str2num.str(s); str2num >> numerical; return numerical; } uint_fast64_t Fast64_t::getResult() { return result; } void Fast64_t::setResult(uint_fast64_t r) { result = r; } /* .................................... ... ____________________________ ... ...| Demo (UML) |... ...+----------------------------+... ...| [-] x : UInt64 <> |... ...| [-] y : UInt64 <> |... ...|____________________________|... ...| [+] run() <> |... ...| [-] prepareInput() <> |... ...|____________________________|... .................................... */ /*-----------------------------*/ /* */ /* Demo.h */ /* */ /*-----------------------------*/ class Demo { public: static void run(); private: static void prepareInput(); static uint_fast64_t x; static uint_fast64_t y; }; /*-----------------------------*/ /* */ /* Demo.cpp */ /* */ /*-----------------------------*/ uint_fast64_t Demo::x; uint_fast64_t Demo::y; void Demo::run() { prepareInput(); cout << "\nx = " << x << " and y = " << y << endl; cout << "x^y is : " << Math::iPow64(x, y) << endl; cout << "y^x is : " << Math::iPow64(y, x) << endl; cout << "Sqrt of x is : " << Math::invSqrt(x) << endl; cout << "Sqrt of y is : " << Math::invSqrt(y) << endl; cout << "The next power of 2 for x is : " << Math::nextPow2(x) << endl; cout << "The next power of 2 for y is : " << Math::nextPow2(y) << endl; } void Demo::prepareInput() { /*-----------------------------*/ /* DEMO */ /* Feel free to */ /* mess around with it */ /* or override the pre-defined */ /* input */ /*-----------------------------*/ const unsigned element = 46; string demoInput[element] = { "0", // valid "1024", // valid "-9999999999999999999", // correctable ".70", // invalid "65535", // valid "-4294967295.000009", // correctable "18446744073709551616", // invalid "34753516", // valid "00", // invalid "41", // valid "-0", // invalid "+75", // valid "18446744073709551615", // valid "7131.", // invalid "4445s", // invalid "513", // valid "65536", // " "-5", // correctable // Rest are valid "1","2","3","6","7","8","9","10", "32","12162210","45","500620730","97", "470268455","74","1343658200","40", "2113272630","45","313658505","29", "9073015544","30","8667072044","80", "6776508901","4","741235" }; std::mt19937 randGen(static_cast(time(NULL))); std::uniform_int_distribution dist(0, element-1); string str_x = demoInput[dist(randGen)]; string str_y = demoInput[dist(randGen)]; cout << "Random inputs are x = " << str_x << ", y = " << str_y << endl; x = Fast64_t::toFastInt(str_x); y = Fast64_t::toFastInt(str_y); } /* .................................... ... ____________________________ ... ...| Bench (UML) |... ...+----------------------------+... ...| [-] t1 : AutoSelect <> |... ...| [-] t2 : AutoSelect <> |... ...| [-] custom_1 : UInt64 <>|... ...| [-] custom_2 : UInt64 <>|... ...| [-] built_in_1 |... ...| : Double <>|... ...| [-] built_in_2 |... ...| : Double <>|... ...| [-] max_iteration |... ...| : Int <> |... ...|____________________________|... ...| [+] BenchPow() <> |... ...| [+] BenchSqrt() <> |... ...| [+] BenchNextPow2() <> |... ...| [-] init() <> |... ...| [-] start() <> |... ...| [-] stop() <> |... ...|____________________________|... .................................... */ /*-----------------------------*/ /* */ /* Bench.h */ /* */ /*-----------------------------*/ class Bench { public: static void BenchPow(); static void BenchSqrt(); static void BenchNextPow2(); private: static void init(); static void start(); static void stop(); static TYPE t1; static TYPE t2; static uint_fast64_t custom_1; static uint_fast64_t custom_2; static double built_in_1; static double built_in_2; static int max_iteration; }; /*-----------------------------*/ /* */ /* Bench.cpp */ /* */ /*-----------------------------*/ TYPE Bench::t1; TYPE Bench::t2; uint_fast64_t Bench::custom_1; uint_fast64_t Bench::custom_2; double Bench::built_in_1; double Bench::built_in_2; int Bench::max_iteration; void Bench::BenchPow() { init(); int itr = max_iteration; cout << "\n\nPerforming 8 consecutive iPow64(" << custom_1 << ", " << custom_2 << ") for " << itr << " times...\n"; start(); for (int itr = 1; itr <= max_iteration; ++itr) { Math::iPow64(custom_1, custom_2); Math::iPow64(custom_1, custom_2); Math::iPow64(custom_1, custom_2); Math::iPow64(custom_1, custom_2); Math::iPow64(custom_1, custom_2); Math::iPow64(custom_1, custom_2); Math::iPow64(custom_1, custom_2); Math::iPow64(custom_1, custom_2); } stop(); cout << "Performing 8 consecutive built-in pow(" << built_in_1 << ", " << built_in_2 << ") for " << itr << " times...\n"; start(); for (int itr = 1; itr <= max_iteration; ++itr) { pow(built_in_1, built_in_2); pow(built_in_1, built_in_2); pow(built_in_1, built_in_2); pow(built_in_1, built_in_2); pow(built_in_1, built_in_2); pow(built_in_1, built_in_2); pow(built_in_1, built_in_2); pow(built_in_1, built_in_2); } stop(); } void Bench::BenchSqrt() { init(); int itr = max_iteration; cout << "\n\nPerforming 8 consecutive invSqrt(" << custom_2 << ") for " << itr << " times...\n"; start(); for (int itr = 1; itr <= max_iteration; ++itr) { Math::invSqrt(custom_2); Math::invSqrt(custom_2); Math::invSqrt(custom_2); Math::invSqrt(custom_2); Math::invSqrt(custom_2); Math::invSqrt(custom_2); Math::invSqrt(custom_2); Math::invSqrt(custom_2); } stop(); cout << "Performing 8 consecutive built-in sqrt(" << built_in_2 << ") for " << itr << " times...\n"; start(); for (int itr = 1; itr <= max_iteration; ++itr) { sqrt(built_in_2); sqrt(built_in_2); sqrt(built_in_2); sqrt(built_in_2); sqrt(built_in_2); sqrt(built_in_2); sqrt(built_in_2); sqrt(built_in_2); } stop(); } void Bench::BenchNextPow2() { init(); int itr = max_iteration; cout << "\n\nPerforming 8 consecutive NextPow2(" << custom_2 << ") for " << itr << " times...\n"; start(); for (int itr = 1; itr <= max_iteration; ++itr) { Math::nextPow2(custom_2); Math::nextPow2(custom_2); Math::nextPow2(custom_2); Math::nextPow2(custom_2); Math::nextPow2(custom_2); Math::nextPow2(custom_2); Math::nextPow2(custom_2); Math::nextPow2(custom_2); } stop(); cout << "Performing 8 consecutive log2(" << built_in_2 << ") for " << itr << " times...\n"; start(); for (int itr = 1; itr <= max_iteration; ++itr) { LN2(built_in_2); LN2(built_in_2); LN2(built_in_2); LN2(built_in_2); LN2(built_in_2); LN2(built_in_2); LN2(built_in_2); LN2(built_in_2); } stop(); } void Bench::init() { custom_1 = 2; custom_2 = 63; built_in_1 = 2.0; built_in_2 = 63.0; max_iteration = 5000; } void Bench::start() { t1 = TIME; } void Bench::stop() { t2 = TIME; double d = DELTA(t2, t1); cout << "Delta T = ~" << d << " micro-sec.\n\n"; } /*-----------------------------*/ /* */ /* Client */ /* */ /*-----------------------------*/ int main() { cout << "This little system has been developed as a utility group for my next project.\n\n"; Demo::run(); cout << "\n/*-----------------------------*/\n"; cout << "/* */\n"; cout << "/* Performing Benchmark */\n"; cout << "/* */\n"; cout << "/*-----------------------------*/\n"; cout << "The following results are based on C++ Shell output. SL's can't handle them so it definitely SUCKS!\n\n"; // Bench::BenchPow(); cout << "Performing 8 consecutive iPow64(2, 63) for 5000 times...\n"; cout << "Delta T = ~6424 micro-sec.\n"; cout << "Performing 8 consecutive built-in pow(2, 63) for 5000 times...\n"; cout << "Delta T = ~3274 micro-sec.\n\n"; //Bench::BenchSqrt(); cout << "Performing 8 consecutive invSqrt(63) for 5000 times...\n"; cout << "Delta T = ~0 micro-sec.\n"; cout << "Performing 8 consecutive built-in sqrt(63) for 5000 times...\n"; cout << "Delta T = ~10 micro-sec.\n\n"; //Bench::BenchNextPow2(); cout << "Performing 8 consecutive NextPow2(63) for 5000 times...\n"; cout << "Delta T = ~0 micro-sec.\n"; cout << "Performing 8 consecutive log2(63) for 5000 times...\n"; cout << "Delta T = ~9 micro-sec.\n\n"; cout << "Note: Even though iPow64 exe-time is bigger (due to various safety protocols), but it's worth the correctness/safeness of the final result (Can be optimized, though).\n"; } /* reference links: https://en.wikipedia.org/wiki/Conditional_compilation https://stackoverflow.com/questions/664852/which-is-the-fastest-way-to-get-the-absolute-value-of-a-number http://stereopsis.com/log2.html https://en.wikipedia.org/wiki/IEEE_754-1985 https://stackoverflow.com/questions/1528727/why-is-sse-scalar-sqrtx-slower-than-rsqrtx-x https://en.wikipedia.org/wiki/Fast_inverse_square_root https://software.intel.com/sites/landingpage/IntrinsicsGuide/# Visual regex debugging: https://www.debuggex.com/r/XSa25c9KyeczK5jx https://www.debuggex.com/r/bQa4O6hEXQkxczL5 https://www.debuggex.com/r/0b0NsKOeTEc14j8z https://www.debuggex.com/r/YmE8QnQUmZLiIaAb Experimental Over-flow checker plot: https://ggbm.at/yCBWReFu .................................... .. Maximum Base/Exponent reference . .................................... ... ____________________________ ... ...| Base | Exponent |... ...+-------------+--------------+... ...| 2 | 63 |... ...+-------------+--------------+... ...| 3 | 40 |... ...+-------------+--------------+... ...| 4 | 31 |... ...|-------------+--------------|... ...| 5 | 27 |... ...|-------------+--------------|... ...| 6 | 24 |... ...|-------------+--------------|... ...| 7 | 22 |... ...|-------------+--------------|... ...| 8 | 21 |... ...|-------------+--------------|... ...| 9 | 20 |... ...|-------------+--------------|... ...| 10 | 19 |... ...|-------------+--------------|... ...| 11 | 18 |... ...|-------------+--------------|... ...| 12-13 | 17 |... ...|-------------+--------------|... ...| 14-15 | 16 |... ...|-------------+--------------|... ...| 16-19 | 15 |... ...|-------------+--------------|... ...| 20-23 | 14 |... ...|-------------+--------------|... ...| 24-30 | 13 |... ...|-------------+--------------|... ...| 31-40 | 12 |... ...|-------------+--------------|... ...| 41-56 | 11 |... ...|-------------+--------------|... ...| 57-84 | 10 |... ...|-------------+--------------|... ...| 85-138 | 9 |... ...|-------------+--------------|... ...| 139-255 | 8 |... ...|-------------+--------------|... ...| 256-565 | 7 |... ...|-------------+--------------|... ...| 566-1625 | 6 |... ...|-------------+--------------|... ...| 1626-7131 | 5 |... ...|-------------+--------------|... ...| 7132-65535 | 4 |... ...|-------------+--------------|... ...| 65536- | 3 |... ...| 2642245 | |... ...|-------------+--------------|... ...| 2642246- | 2 |... ...| 4294967295 | |... ...|-------------+--------------|... ...| 4294967296- | 1 |... ...| UInt64_MAX | |... ...|_____________+______________|... .................................... */

Math?... Take a bath!