Потестируйте скорость работы класса больших чисел

#pragma once
#ifndef BIGINT_AMP
#define BIGINT_AMP
 
#include "BigInt.h"
#define NOMINMAX
 
#include <amp.h>
#include <iostream>
#include <assert.h>
#include <amp_math.h>
#include <ctime>
 
using namespace std;
using namespace concurrency;
 
#ifndef BASE
#define BASE (long long) 1000000000
#endif
 
// Показываем название ускорителя.
void print_accelerator_description()
{
    accelerator acc;
    accelerator_view av = acc.create_view();
    std::wstring core_device_name = av.accelerator.description;
    std::wcout << L"Accelerator: " << core_device_name << std::endl;
}
 
// Вспомогательная для переноса carry на ЦПУ
bool has_carry(std::vector<INT32>& vec)
{
    for (size_t i = 0; i < vec.size(); i++)
    {
        if (vec[i] != 0)
            return true;
    }
    return false;
}
//*******************************************************
// Складываем на ГПУ числа A и B. Переносы делаем на ЦПУ :(
BigInt gpu_add(const BigInt& numA, const BigInt& numB)
{
    std::vector<INT32> a(numA.a.begin(), numA.a.end());
    std::vector<INT32> b(numB.a.begin(), numB.a.end());
    std::vector<INT32> c, carry;
    size_t max_size = std::max(numA.a.size(), numB.a.size());
 
    // создаём 3 числа на ЦПУ и массив переносов carry.  Результат будет в "c".
    a.resize(max_size);
    b.resize(max_size);
    c.resize(max_size + 1);
    carry.resize(max_size + 1);  // флаги переноса
 
    // создаём их представление на ГПУ. Сами данные на ГПУ не копируем.
    array_view<INT32, 1> avA(a.size(), &a[0]);
    array_view<INT32, 1> avB(b.size(), &b[0]);
    array_view<INT32, 1> avC(c.size(), &c[0]); avC.discard_data();
    array_view<INT32, 1> avCarry(carry.size(), &carry[0]); avCarry.discard_data();
 
    //std::cout << " числа A и B в ГПУ созданы. Складываем." << endl;
    parallel_for_each(avA.extent, [=](index<1> idx) restrict(amp)
    {
        avC[idx] = avA[idx] + avB[idx];
 
        if (avC[idx] >= BASE)
        {
            avCarry[idx + 1] = 1;
            avC[idx] -= BASE;
        }
        else avCarry[idx + 1] = 0;
    });
 
    // синхронизируем массивы. ГПУ->ЦПУ
    avC.synchronize();      // результат без переносов
    avCarry.synchronize();  // массив переносов
 
    // делаем переносы на ЦПУ. 
    while (has_carry(carry))
    {
        for (int i = 1; i < carry.size(); i++)
        {
            if (carry[i] != 0)
            {
                c[i]++;
                carry[i] = 0;
            }
        }
    }
    // переносы сделаны. 
    // удалить нуль впереди, если он есть.
    if (c[c.size() - 1] == 0)
        c.pop_back();
 
    BigInt res;
    res.a = c;
    return res;
}
#endif // BIGINT_AMP

int main(int argc, char *argv[])
{
    setlocale(LC_CTYPE, "russian");
    //runTest(argc, argv);
    print_accelerator_description();
    
    double total_time = (double)clock() / CLOCKS_PER_SEC;
    BigInt a; a.Load("M48.txt");
    
    BigInt b = a; 
    std::cout << " Числа готовы. " << endl;
    std::cout << " time : " << (double)clock() / CLOCKS_PER_SEC - total_time << " sec." << std::endl << std::endl;
 
    BigInt result, result1;
 
    std::cout << "Сложение на ЦПУ." << endl;
    total_time = (double)clock() / CLOCKS_PER_SEC;
    for (int i = 0; i < 100; i++)
    {
        result = a + b;
    }
    std::cout << " time : " << (double)clock() / CLOCKS_PER_SEC - total_time << " sec." << std::endl << std::endl;
 
    std::cout << "Сложение на ГПУ." << endl;
    total_time = (double)clock() / CLOCKS_PER_SEC;
    for (int i = 0; i < 100; i++)
    {
        result1 = gpu_add(a, b);
    }
    std::cout << " time : " << (double)clock() / CLOCKS_PER_SEC - total_time << " sec." << std::endl << std::endl;
    
    result.printInfo();  std::cout << endl;
    result1.printInfo(); std::cout << endl;
 
    if (result == result1)
    {
        std::cout << "Результаты совпадают." << endl;
    }
 
    else
    {
        std::cout << "Результаты не совпадают!" << endl;
    }
}

    const BigInt BigInt::generate_number(const std::string& s)
    {
        BigInt res = 0; // результат
 
        // first try parse Mersenn numbers "M1", "M2" ...
        long long messen_exp = BigInt::mersenExp(s);
        if (messen_exp != 0)
        {
            res = BigInt::mersenNumber(s);
            return res;
        }
 
        std::string str_base;
        std::string str_exp;
        int last_operand_sign = 0; // "+" or "-"
 
        std::string str_last_digit;
 
        // находим экспоненту
        int exp_pos = 0;
        int i;
        for (i = 0; i < s.length(); i++)
        {
            if (s[i] == '^')
                break;
        }
 
        if (i != s.length())
            exp_pos = i;
 
        // находим базу
        for (int i = 0; i < s.length(); i++)
        {
            if (s[i] == '^')
                break;
            str_base += s[i];
        }
        //std::cout << " str_base = " << str_base << std::endl;
 
        unsigned long long base;
        try{ base = std::stoull(str_base); }
        catch (...)
        {
            std::cout << "Cannot convert string '" << str_base << "' to unsigned long long" << std::endl;
            return res;
        }
 
        if (exp_pos == 0) // экспоненты нет. base просто какое-то число.
        {
            res = base;
            return res;
        }
 
        // экспонента есть.
        for (i = exp_pos + 1; i < s.length(); i++)
        {
            if (s[i] == '+')
            {
                last_operand_sign = 1;
                break;
            }
            if (s[i] == '-')
            {
                last_operand_sign = -1;
                break;
            }
 
            str_exp += s[i];
        }
 
        unsigned long long exp;
        try{ exp = std::stoull(str_exp); }
        catch (...)
        {
            std::cout << "Cannot convert exponent '" << str_exp << "' to unsigned long long" << std::endl;
            return res;
        }
 
        // last operand "+" or "-"
        if (last_operand_sign == 0) // "+" or "-" not exists
        {
            res = BigInt::power(base, exp);
            return res;
        }
 
        int last_digit_pos = s.length();
        int last_digit_n_chars = 0;
 
        for (i = s.length() - 1; i >= 0; i--)
        {
 
            if ((s[i] == '+') || (s[i] == '-'))
            {
                break;
            }
            last_digit_pos--;
            last_digit_n_chars++;
        }
 
        for (i = 0; i < last_digit_n_chars; i++)
        {
            str_last_digit += s[last_digit_pos++];
        }
        //std::cout << " str_last_digit " << str_last_digit << std::endl;
 
        unsigned long long last_digit;
        try{ last_digit = std::stoull(str_last_digit); }
        catch (...)
        {
            std::cout << "Cannot convert last digit '" << str_exp << "' to unsigned long long" << std::endl;
            return res;
        }
 
        if (last_operand_sign < 0)
        {
            res = BigInt::power(base, exp) - last_digit;
        }
 
        if (last_operand_sign > 0)
        {
            res = BigInt::power(base, exp) + last_digit;
        }
        //std::cout << " Ok." << std::endl;
        return res;
    }