Подключение сторонних библиотек

///---------------------------------------------------------------------------|
/// Поиск случайного большого числа.
///---------------------------------------------------------------------------:
#include "constructors/constructors.hpp"
#include "functions/conversion.hpp"
#include "functions/math.hpp"
#include "operators/binary_arithmetic.hpp"
#include "operators/io_stream.hpp"
#include "functions/random.hpp"
#include <ctime>
 
typedef BigInt ntype;
 
////////////////////////////////////////////////////////////////////////////////
struct Task_my
{
    ntype result;
    Task_my(ntype from)
    {
        for (ntype i = from; true; i += 2)
        {
            if (is_simple(i))
            {
                result = i;
                break;
            }
        }
    }
 
    bool is_simple(ntype n)
    {
        for (ntype i = 3; i < sqrt(n); i += 2)
        {
            if (n % i == 0) return false;
        }
        return true;
    }
};
 
///////////////////////////////////////////////////////////////////////////////
#define LOG2(X) ((unsigned) (8*sizeof (unsigned long long) -\
    __builtin_clzll((X)) - 1))
 
struct Task_ferma
{
    size_t nn;
    ntype result;
    Task_ferma(ntype from, size_t _nn) : nn(_nn - 1)
    {
        for (ntype i = from; true; i += 2)
        {
            if (ferma(i))
            {
                result = i;
                break;
            }
        }
    }
 
    bool ferma(ntype x)
    {
        //ntype k = LOG2(x) + 2;
        ntype k = sqrt(x);
        for (ntype i = 0; i < 100; i++)
        {
            ntype a = (big_random(nn) % (x - 2)) + 2;
            if (gcd(a, x) != 1)        return false;
            if (pows(a, x - 1, x) != 1)  return false;
        }
        return true;
    }
    ntype gcd(ntype a, ntype b)
    {
        if (b == 0) return a;
        return gcd(b, a % b);
    }
    ntype pows(ntype a, ntype b, ntype m)
    {
        if (b == 0)
            return 1;
        if (b % 2 == 0)
        {
            ntype t = pows(a, b / 2, m);
            return mul(t, t, m) % m;
        }
        return (mul(pows(a, b - 1, m), a, m)) % m;
    }
    ntype mul(ntype a, ntype b, ntype m)
    {
        if (b == 1)
            return a;
        if (b % 2 == 0)
        {
            ntype t = mul(a, b / 2, m);
            return (2 * t) % m;
        }
        return (mul(a, b - 1, m) + a) % m;
    }
};
 
 
int rrand(int range_min, int range_max)
{
    return rand() % (range_max - range_min + 1) + range_min;
}
 
std::string generator(size_t length)
{
    std::string alphabet = "0123456789";
    std::string pass(length, '*');
    pass[0] = alphabet[rrand(1, alphabet.size() - 1)];
 
    for (size_t i = 1; i < length - 1; i++)
    {
        pass[i] = alphabet[rrand(0, alphabet.size() - 1)];
    }
    pass.back() = '3';
 
    return pass;
}
 
#define PERFOMANCE_START {float start  = clock() / (float)60000;
#define PERFOMANCE_END    float finish = clock() / (float)60000;\
            std::cout << "time: " << finish - start << " minute."\
                      << std::endl;}
 
///---------------------------------------------------------------------------|
/// Старт.
///---------------------------------------------------------------------------:
int main(int argc, char** argv)
{
    srand((unsigned)time(NULL));
 
    std::string my = generator(15);
    std::cout << "start number = " << my << "\n";
    BigInt a(my);
 
    PERFOMANCE_START
        std::cout << "ferma        = ... wait ...";
    Task_ferma task(a, my.size());
    std::cout << "\rferma        = " << task.result << "     ";
    PERFOMANCE_END
 
        BigInt a1(my);
        
    PERFOMANCE_START
      std::cout << "my           = ... wait ...";
    Task_my task(a1);
    std::cout << "\rmy           = " << task.result << "     ";
    PERFOMANCE_END
 
        std::cin.get();
    return 0;
}

///---------------------------------------------------------------------------|
/// Поиск случайного большого числа.
///---------------------------------------------------------------------------:
#include "constructors/constructors.hpp"
#include "functions/conversion.hpp"
#include "functions/math.hpp"
#include "operators/binary_arithmetic.hpp"
#include "operators/io_stream.hpp"
#include "functions/random.hpp"
#include <ctime>
 
typedef BigInt ntype;
 
////////////////////////////////////////////////////////////////////////////////
struct Task_my
{   ntype result;
    size_t count;
    Task_my(ntype from) : count(0)
    {   for (ntype i = from; true; i += 2)
        {
            count++;
            if (is_simple(i))
            {   result = i;
                break;
            }
        }
    }
 
    bool is_simple(ntype n)
    {   for (ntype i = 3; i < sqrt(n); i += 2)
        {   if (n % i == 0) return false;
        }
        return true;
    }
};
 
///////////////////////////////////////////////////////////////////////////////
#define LOG2(X) ((unsigned) (8*sizeof (unsigned long long) -\
    __builtin_clzll((X)) - 1))
 
struct Task_ferma
{
    size_t count;
    size_t nn;
    ntype result;
    Task_ferma(ntype from, size_t _nn) : nn(_nn/2), count(0)
    {   for (ntype i = from; true; i += 2)
        {
            count++;
            if (ferma(i))
            {
                result = i;
                break;
            }
        }
    }
 
    bool ferma(ntype x)
    {   //ntype k = LOG2(x) + 2;
        ntype k = sqrt(x);
        for (ntype i = 0; i < 100; i++)
        {   
            ntype a = (big_random(nn) % (x - 2)) + 2;
            if (gcd(a, x) != 1)        return false;
            if (pows(a, x - 1, x) != 1)  return false;
        }
        return true;
    }
 
    ntype gcd(ntype a, ntype b)
    {   if (b == 0) return a;
        return gcd(b, a % b);
    }
 
    ntype pows(ntype a, ntype b, ntype m)
    {   if (b == 0)
            return 1;
        if (b % 2 == 0)
        {   ntype t = pows(a, b / 2, m);
            return mul(t, t, m) % m;
        }
        return (mul(pows(a, b - 1, m), a, m)) % m;
    }
 
    ntype mul(ntype a, ntype b, ntype m)
    {   if (b == 1)
            return a;
        if (b % 2 == 0)
        {   ntype t = mul(a, b / 2, m);
            return (2 * t) % m;
        }
        return (mul(a, b - 1, m) + a) % m;
    }
};
 
 
int rrand(int range_min, int range_max)
{   return rand() % (range_max - range_min + 1) + range_min;
}
 
std::string generator(size_t length)
{
    std::string alphabet = "0123456789";
    std::string pass(length, '*');
    pass[0] = alphabet[rrand(1, alphabet.size() - 1)];
 
    for (size_t i = 1; i < length - 1; i++)
    {   pass[i] = alphabet[rrand(0, alphabet.size() - 1)];
    }
    pass.back() = '3';
 
    return pass;
}
 
#define PERFOMANCE_START {float start  = clock() / (float)60000;
#define PERFOMANCE_END    float finish = clock() / (float)60000;\
            std::cout << "time: " << finish - start << " minute."\
                      << std::endl;}
 
///---------------------------------------------------------------------------|
/// Старт.
///---------------------------------------------------------------------------:
int main(int argc, char** argv)
{
    //srand((unsigned)time(NULL));
 
    std::string my = generator(15);
    std::cout <<   "start number = " << my << "\n";
 
    PERFOMANCE_START
    std::cout <<   "ferma        = ... wait ...";
    Task_ferma task(my, my.size());
    std::cout << "\rferma        = " << task.result << ",  count: " 
                                     << task.count << ",  ";
    PERFOMANCE_END
 
        
    PERFOMANCE_START
    std::cout <<   "my           = ... wait ...";
    Task_my task(my);
    std::cout << "\rmy           = " << task.result << ",  count: "
                                     << task.count << ",  ";
    PERFOMANCE_END
 
        std::cin.get();
    return 0;
}