vector.hpp

Go to the documentation of this file.

 
 
#pragma once
 
#include <algorithm>
#include <random>
#include <vector>
 
#include "barretenberg/avm_fuzzer/mutations/configuration.hpp"
 
struct RandomInsertion {
    template <typename T, typename GenerateFn>
    static void mutate(std::mt19937_64& rng, std::vector<T>& vec, GenerateFn&& generate_random_element_function)
    {
        T element = generate_random_element_function(rng);
        if (!vec.empty()) {
            std::uniform_int_distribution<size_t> dist(0, vec.size());
            size_t index = dist(rng);
            vec.insert(vec.begin() + static_cast<std::ptrdiff_t>(index), element);
        } else {
            vec.push_back(element);
        }
    }
};
 
struct RandomDeletion {
    template <typename T> static void mutate(std::mt19937_64& rng, std::vector<T>& vec)
    {
        if (vec.size() >= 1) {
            std::uniform_int_distribution<size_t> dist(0, vec.size() - 1);
            size_t index = dist(rng);
            vec.erase(vec.begin() + static_cast<std::ptrdiff_t>(index));
        }
    }
};
 
struct RandomSwap {
    template <typename T> static void mutate(std::mt19937_64& rng, std::vector<T>& vec)
    {
        if (!vec.empty()) {
            std::uniform_int_distribution<size_t> dist(0, vec.size() - 1);
            size_t index1 = dist(rng);
            size_t index2 = dist(rng);
            std::swap(vec[index1], vec[index2]);
        }
    }
};
 
struct RandomElementMutation {
    template <typename T, typename MutateFn>
    static void mutate(std::mt19937_64& rng, std::vector<T>& vec, MutateFn&& mutate_element_function)
    {
        if (!vec.empty()) {
            std::uniform_int_distribution<size_t> dist(0, vec.size() - 1);
            size_t index = dist(rng);
            mutate_element_function(vec[index], rng);
        }
    }
};
 
template <typename T, typename MutateFn, typename GenerateFn>
void mutate_vec(std::vector<T>& vec,
                std::mt19937_64& rng,
                MutateFn&& mutate_element_function,
                GenerateFn&& generate_random_element_function,
                const VecMutationConfig& config)
{
    // If vector is empty, force insertion (other mutations do nothing on empty vectors)
    if (vec.empty()) {
        RandomInsertion::mutate(rng, vec, std::forward<GenerateFn>(generate_random_element_function));
        return;
    }
 
    VecMutationOptions option = config.select(rng);
    switch (option) {
    case VecMutationOptions::Insertion:
        RandomInsertion::mutate(rng, vec, std::forward<GenerateFn>(generate_random_element_function));
        break;
    case VecMutationOptions::Deletion:
        RandomDeletion::mutate(rng, vec);
        break;
    case VecMutationOptions::Swap:
        RandomSwap::mutate(rng, vec);
        break;
    case VecMutationOptions::ElementMutation:
        RandomElementMutation::mutate(rng, vec, std::forward<MutateFn>(mutate_element_function));
        break;
    }
}