Алгоритм Диксона - C++

std::vector<std::size_t> &PrimeNumbersProcessor::genPrimesUpToMaxLimit(const std::size_t &limit)
{
    if (limit < 2)
    {
        return m_PrimeNumbers;
    }
    else if (limit == 2)
    {
        m_PrimeNumbers.push_back(2);
        return m_PrimeNumbers;
    }
 
    m_PrimeNumbers.push_back(2);
 
    for (std::size_t i = 3; i <= limit; i++)
    {
        if (isPrime(i))
        {
            m_PrimeNumbers.push_back(i);
        }
    }
    return m_PrimeNumbers;
}

 std::size_t l = static_cast<std::size_t>(std::log(num));
    std::size_t limit = static_cast<std::size_t>(exp(std::sqrt(l * log(l))));
    limit = static_cast<std::size_t>(std::sqrt(limit));
 
    m_Primes.genPrimesUpToMaxLimit(limit);
 
    while (m_Avec.size() != (m_Primes.getGeneratedPrimesList().size() + 1))
    {
        std::size_t tmpB = genRandom();
        std::size_t tmpA = PrimeNumbersProcessor::modPow(tmpB, 2, m_Num);
        if (isSmooth(tmpA))
        {
            std::cout << "This B is ok" << tmpB << std::endl;
            m_Avec.push_back(tmpA);
            m_Bvec.push_back(tmpB);
        }
        else
        {
            std::cout << "This B is BAD" << tmpB << std::endl;
        }
    }

bool DixonFactorization::isSmooth(const std::size_t &num)
{
    CanonicalRepresentation tmp(num);
    for (std::size_t i = 0; i < tmp.getRepresentation().size(); i++)
    {
        if (!isInBasis(tmp.getRepresentation().at(i).num))
        {
            return false;
        }
    }
    return true;
 
}