AlgorithmRecursionSearch.hpp

Go to the documentation of this file.

#ifndef MTTOOLBOX_ALGORITHM_RECURSION_SEARCH_HPP
#define MTTOOLBOX_ALGORITHM_RECURSION_SEARCH_HPP

#if defined(DEBUG)
#include <iostream>
#endif
#include <NTL/GF2X.h>
#include <NTL/GF2XFactoring.h>
#include <MTToolBox/RecursionSearchable.hpp>
#include <MTToolBox/AlgorithmPrimitivity.hpp>
#include <MTToolBox/period.hpp>
#include <MTToolBox/util.hpp>

namespace MTToolBox {
    using namespace std;
    template<typename U, typename V = U>
    class AlgorithmRecursionSearch {
    public:
        AlgorithmRecursionSearch(RecursionSearchable<U, V>& generator,
                                 AbstractGenerator<V>& bg) {
            rand = &generator;
            baseGenerator = &bg;
            count = 0;
            isPrime = &MersennePrimitivity;
        }

        AlgorithmRecursionSearch(RecursionSearchable<U, V>& generator,
                                 AbstractGenerator<V>& bg,
                                 const AlgorithmPrimitivity& primitivity) {
            rand = &generator;
            baseGenerator = &bg;
            count = 0;
            isPrime = &primitivity;
        }

        bool start(int try_count) {
            long size = rand->bitSize();
            long degree;
            for (int i = 0; i < try_count; i++) {
                rand->setUpParam(*baseGenerator);
                rand->seed(getOne<U>());
                minpoly(poly, *rand);
                count++;
                degree = deg(poly);
                if (degree != size) {
#if defined(DEBUG)
                    cout << "degree:" << degree << endl;
#endif
                    continue;
                }
                if ((*isPrime)(size, poly)) {
                    return true;
                }
            }
            return false;
        }

        const std::string getParamString() {
            return rand->getParamString();
        }

        const NTL::GF2X& getMinPoly() const {
            return poly;
        }

        long getCount() const {
            return count;
        }

    private:
        RecursionSearchable<U, V> *rand;
        AbstractGenerator<V> *baseGenerator;
        const AlgorithmPrimitivity *isPrime;
        NTL::GF2X poly;
        long count;
    };
}
#endif // MTTOOLBOX_ALGORITHM_RECURSION_SEARCH_HPP