Бенчмарк для длинной арифметики

uint64_t rdtsc() {
    return __rdtsc();
}
//  Linux/GCC
#else
 
uint64_t rdtsc() {
    unsigned int lo, hi;
    __asm__ __volatile__("rdtsc" : "=a" (lo), "=d" (hi));
    return ((uint64_t)hi << 32) | lo;
}
 
#endif
 
#include <fstream>
std::ofstream out("out.txt");
//std::ostream& out = std::cout;
std::stringstream tout = std::stringstream();
std::ostringstream garbage;
 
const char garbage_marker[] = "garbage out: ",
begin_marker[] = "BENCH_BEGIN: ",
end_marker[] = "BENCH_END in time: ";
using std::endl;
//using arith = LongArith;
template<typename arith>
void simple_operation_benchmark()
{
    tout << begin_marker << "Simple" << endl;
    const size_t begin = rdtsc();
 
    arith a;
    for (size_t i = 0; i < 1000000; ++i)
        ++a;
    garbage << a;
    arith b = arith::from_string("1654984191651891");
    for (size_t i = 0; i < 1000000; ++i)
        ++b;
    garbage << b;
 
    a = arith(100000);
    for (arith i = 0; i < a; ++i)
        b += arith(15057);
    garbage << b;
 
    tout << "\tPlus: " << rdtsc() - begin << endl;
    const size_t t = rdtsc();
    a /= 10;
    b = 1;
    for (arith i = 0; i < a; ++i)
        b = b * 2;
    garbage << b;
    tout << "\tMult: " << rdtsc() - t << endl;
    const size_t end = rdtsc();
    tout << end_marker << end - begin << endl;
}
 
 
template<typename arith>
void vector_op_benchmark()
{
    tout << begin_marker << "VECT" << endl;
    const size_t begin = rdtsc();
    std::vector<arith> t;
    arith M(1000000);
    for (arith i = 0; i < M; ++i)
    {
        if (rand() % 100 > 95)
        {
            t.push_back(rand() % 1000);
        }
        else
        {
            arith tmp = rand() % 1000;
            for (size_t i = 0; i < 10;++i)
                tmp *= rand() % 1000;
            t.push_back(tmp);
        }
    }
    const size_t end = rdtsc();
    tout << end_marker << end - begin << endl;
    for (auto& tmp : t)
        garbage << tmp;
}
 
template<typename arith>
void factorial_op_benchmark_long()
{
    tout << begin_marker << "Factorial Long" << endl;
    const size_t begin = rdtsc();
    arith M(100 * 1000);
    arith fact = 1;
    for (arith i = 1; i <= M; ++i)
    {
        fact *= i;
    }
    const size_t end = rdtsc();
    tout << end_marker << end - begin << endl;
    garbage << endl << fact << endl;
}
 
template<typename arith>
void factorial_op_benchmark_plain()
{
    tout << begin_marker << "Factorial" << endl;
    const size_t begin = rdtsc();
    long M(100 * 1000);
    arith fact = 1;
    for (long i = 1; i <= M; ++i)
    {
        fact *= i;
    }
    const size_t end = rdtsc();
    tout << end_marker << end - begin << endl;
    garbage << endl << fact << endl;
}
 
void fast_division_benchmark()
{
    tout << begin_marker << "FAST DIV" << endl;
    const size_t begin = rdtsc();
 
    std::vector<LongArith> t;
    constexpr size_t N = 100000;
    LongArith M(N);
    for (LongArith i = 0; i < M; ++i)
    {
        LongArith tmp = rand() % 1000;
        for (size_t i = 0; i < 100;++i)
            tmp *= rand() % 1000;
        t.push_back(tmp);
    }
 
    std::vector<LongArith> dividers = { 1 };
    for (LongArith i = 1; i < M; ++i)
    {
        dividers.emplace_back(dividers.back() * 10);
    }
 
    tout << "Set generated in " << rdtsc() - begin << endl;
 
    std::vector<std::pair<LongArith, LongArith>> result1, result2;
    result1.reserve(M.to_plain_int()); result2.reserve(M.to_plain_int());
 
 
 
    const size_t first_begin = rdtsc();
    for (size_t i = 0; i < N; ++i)
    {
        auto r = LongArith::fraction_and_remainder(t[i], dividers[i]);
        result1.emplace_back(std::move(r));
    }
    const size_t first_end = rdtsc();
 
    const size_t second_begin = rdtsc();
    for (size_t i = 0; i < N; ++i)
    {
        result2.emplace_back(
            t[i].fast_divide_by_10(i),
            t[i].fast_remainder_by_10(i)
        );
    }
    const size_t second_end = rdtsc();
 
    std::ostringstream eout;
 
    bool correct = true;
    for (size_t i = 0; i < result1.size(); ++i)
    {
        if (result1[i] != result2[i])
        {
            correct = false;
 
            eout << i << ":" <<
                "\n\t" << t[i] << " / " << dividers[i] <<
                "\n\t=" << result1[i].first << "\n\t=" << result2[i].first <<
                "\n\t%" << result1[i].second << "\n\t%" << result2[i].second << endl;
        }
    }
 
    if (!correct)
    {
        std::ofstream("division_errors.txt") << eout.str();
    }
 
    tout << "Simple division time: " << first_end - first_begin << endl;
    tout << "Fast division time: " << second_end - second_begin << endl;
    tout << "Is correct: " << correct << endl;
 
    const size_t end = rdtsc();
    tout << end_marker << end - begin << endl;
}
 
 
void compare_long_and_simple_div()
{
    tout << begin_marker << "PLAIN DIV" << endl;
    const size_t begin = rdtsc();
 
    std::vector<LongArith> t;
    constexpr size_t N = 100000;
    LongArith M(N);
    for (LongArith i = 0; i < M; ++i)
    {
        LongArith tmp = rand() % 1000;
        for (size_t i = 0; i < 100;++i)
            tmp *= rand() % 1000;
        t.push_back(tmp);
    }
 
    std::vector<int> dividers;
    for (LongArith i = 0; i < M; ++i)
    {
        int v;
        do {
            v = rand();
        } while (v == 0);
        dividers.emplace_back(v);
    }
 
    tout << "Set generated in " << rdtsc() - begin << endl;
 
    std::vector<std::pair<LongArith, LongArith>> result1;
    std::vector<std::pair<LongArith, long>> result2;
    result1.reserve(N); result2.reserve(N);
 
 
 
    const size_t first_begin = rdtsc();
    for (size_t i = 0; i < N; ++i)
    {
        auto r = LongArith::fraction_and_remainder(t[i], LongArith(dividers[i]));
        result1.emplace_back(std::move(r));
    }
    const size_t first_end = rdtsc();
 
    const size_t second_begin = rdtsc();
    for (size_t i = 0; i < N; ++i)
    {
        auto r = LongArith::fraction_and_remainder(t[i], dividers[i]);
        result2.emplace_back(std::move(r));
    }
    const size_t second_end = rdtsc();
 
    std::ostringstream eout;
 
    bool correct = true;
    for (size_t i = 0; i < result1.size(); ++i)
    {
        if (result1[i].first != result2[i].first || result1[i].second.to_plain_int() != result2[i].second)
        {
            correct = false;
 
            eout << i << ":" <<
                "\n\t" << t[i] << " / " << dividers[i] <<
                "\n\t=" << result1[i].first << "\n\t=" << result2[i].first <<
                "\n\t%" << result1[i].second << "\n\t%" << result2[i].second << endl;
        }
    }
 
    if (!correct)
    {
        std::ofstream("division_errors.txt") << eout.str();
    }
 
    tout << "LongArith division time: " << first_end - first_begin << endl;
    tout << "Plain division time: " << second_end - second_begin << endl;
    tout << "Is correct: " << correct << endl;
 
    const size_t end = rdtsc();
    tout << end_marker << end - begin << endl;
}