utils.hpp

#ifndef EVALHYD_UTILS_HPP
#define EVALHYD_UTILS_HPP

#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <stdexcept>
#include <xtensor/xtensor.hpp>
#include <xtensor/xrandom.hpp>

namespace evalhyd
{
    namespace utils
    {
        /// Procedure to determine based on a list of metrics which elements
        /// and which metrics (and their associated elements) require to be
        /// pre-computed for memoisation purposes.
        ///
        /// \param [in] metrics:
        ///     Vector of strings for the metric(s) to be computed.
        /// \param [in] elements:
        ///     Map between metrics and their required computation elements.
        /// \param [in] dependencies:
        ///     Map between metrics and their dependencies.
        /// \param [out] required_elements:
        ///     Set of elements identified as required to be pre-computed.
        /// \param [out] required_dependencies:
        ///     Set of metrics identified as required to be pre-computed.
        inline void find_requirements (
                const std::vector<std::string>& metrics,
                std::unordered_map<std::string, std::vector<std::string>>& elements,
                std::unordered_map<std::string, std::vector<std::string>>& dependencies,
                std::vector<std::string>& required_elements,
                std::vector<std::string>& required_dependencies
        )
        {
            std::unordered_set<std::string> found_elements;
            std::unordered_set<std::string> found_dependencies;

            for (const auto& metric : metrics)
            {
                // add elements to pre-computation set
                for (const auto& element : elements[metric])
                    if (found_elements.find(element) == found_elements.end())
                    {
                        found_elements.insert(element);
                        required_elements.push_back(element);
                    }

                // add metric dependencies to pre-computation set
                if (dependencies.find(metric) != dependencies.end())
                {
                    for (const auto& dependency : dependencies[metric])
                    {
                        if (found_dependencies.find(dependency) == found_dependencies.end())
                        {
                            found_dependencies.insert(dependency);
                            required_dependencies.push_back(dependency);
                        }
                        // add dependency elements to pre-computation set
                        for (const auto& element : elements[dependency])
                            if (found_elements.find(element) == found_elements.end())
                            {
                                found_elements.insert(element);
                                required_elements.push_back(element);
                            }
                    }
                }
            }
        }