AlgorithmPartialBitPattern.hpp

[詳解]

#ifndef MTTOOLBOX_ALGORITHM_PARTIAL_BITPATTERN_HPP
#define MTTOOLBOX_ALGORITHM_PARTIAL_BITPATTERN_HPP

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <unistd.h>
#include <MTToolBox/AlgorithmTempering.hpp>
#include <MTToolBox/TemperingCalculatable.hpp>
#include <MTToolBox/AlgorithmEquidistribution.hpp>

namespace MTToolBox {
    template<typename U, typename V,
             int bit_len, int param_num, int try_bit_len, int step = 5,
             bool lsb = false>
    class AlgorithmPartialBitPattern : public AlgorithmTempering<U, V> {
    public:
        int operator()(TemperingCalculatable<U, V>& rand,
                       bool verbose = false) {
            using namespace std;
            if (verbose) {
                cout << "searching..." << endl;
            }
            if (lsb) {
                rand.setReverseOutput();
                if (verbose) {
                    cout << "searching from LSB" << endl;
                }
            } else {
                rand.resetReverseOutput();
                if (verbose) {
                    cout << "searching from MSB" << endl;
                }
            }
            int delta = 1000;
            for (int p = 0; p < try_bit_len; p += step) {
                int max_depth = p + step;
                if (max_depth > try_bit_len) {
                    max_depth = try_bit_len;
                }
                for (int i = 0; i < param_num; i++) {
                    delta = search_best_temper(rand, p, i, max_depth, verbose);
                }
            }
            if (verbose) {
                cout << "delta = " << dec << delta << endl;
            }
            rand.resetReverseOutput();
            return 0;
        }

        bool isLSBTempering() const {
            return lsb;
        }
    private:
        void make_temper_bit(TemperingCalculatable<U, V>& rand,
                             U mask,
                             int param_pos,
                             U pattern) {
            rand.setTemperingPattern(mask, pattern, param_pos);
            rand.setUpTempering();
        }

        int search_best_temper(TemperingCalculatable<U, V>& rand, int v_bit,
                               int param_pos, int max_v_bit, bool verbose) {
            using namespace std;
            int bitSize = rand.bitSize();
            int delta;
            int min_delta = bitSize * bit_len;
            U min_pattern = 0;
            int size = max_v_bit - v_bit;
            U pattern;
            U mask = make_mask(v_bit, size);
            int length = bit_size<U>() / 4;
            for (int i = (1 << size) -1; i >= 0; i--) {
                if (lsb) {
                    pattern = static_cast<U>(i) << v_bit;
                } else {
                    pattern = static_cast<U>(i) << (bit_len - v_bit - size);
                }
                make_temper_bit(rand, mask, param_pos, pattern);
                delta = get_equidist(rand, bit_len);
                if (delta < min_delta) {
                    if (verbose) {
                        cout << "pattern change " << hex << min_pattern
                             << ":" << pattern << endl;
                    }
                    min_delta = delta;
                    min_pattern = pattern;
                } else if (delta == min_delta) {
                    if (count_bit(min_pattern) < count_bit(pattern)) {
                        if (verbose) {
                            cout << "pattern change " << hex << min_pattern
                                 << ":" << pattern << endl;
                        }
                        min_pattern = pattern;
                    }
                }
            }
            make_temper_bit(rand, mask, param_pos, min_pattern);
            if (verbose) {
                cout << dec << min_delta << ":"
                     << hex << setw(length) << min_pattern << ":"
                     << hex << setw(length) << mask << endl;
            }
            return min_delta;
        }

        int get_equidist(TemperingCalculatable<U, V>& rand,
                         int bit_length) {
            AlgorithmEquidistribution<U, V> sb(rand, bit_length);
            int veq[bit_length];
            int sum = sb.get_all_equidist(veq);
            return sum;
        }

        U make_mask(int start, int size) {
            U mask = 0;
            mask = ~mask;
            if (start + size > bit_len) {
                size = bit_len - start;
            }
            if (lsb) {
                mask >>= start;
                mask <<= bit_len - size;
                mask >>= bit_len - start - size;
            } else {
                mask <<= start;
                mask >>= bit_len - size;
                mask <<= bit_len - start - size;
            }
            return mask;
        }
    };
}

#endif // MTTOOLBOX_ALGORITHM_PARTIAL_BITPATTERN_HPP