OptiSweep.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "OptiSol.hpp"
#include "janus/core/JanusError.hpp"
#include <optional>
#include <vector>
 
namespace janus {

struct SweepResult {
    std::vector<double> param_values;

    std::vector<std::optional<OptiSol>> solutions;

    std::vector<int> iterations;

    bool all_converged = true;

    std::vector<bool> converged;

    std::vector<std::string> errors;

    size_t size() const { return param_values.size(); }

    double objective(size_t i, const SymbolicScalar &objective_expr) const {
        if (i >= solutions.size()) {
            throw InvalidArgument("SweepResult::objective: index out of range");
        }
        if (!solutions[i].has_value()) {
            throw InvalidArgument("SweepResult::objective: solve did not converge at index " +
                                  std::to_string(i));
        }
        return solutions[i]->value(objective_expr);
    }

    NumericVector values(const SymbolicScalar &var) const {
        // Count converged points
        int n_converged = 0;
        for (const auto &sol : solutions) {
            if (sol.has_value()) {
                ++n_converged;
            }
        }
        NumericVector result(n_converged);
        int j = 0;
        for (const auto &sol : solutions) {
            if (sol.has_value()) {
                result(j++) = sol->value(var);
            }
        }
        return result;
    }

    NumericMatrix values(const SymbolicVector &var) const {
        // Collect converged solutions
        std::vector<size_t> converged_indices;
        for (size_t i = 0; i < solutions.size(); ++i) {
            if (solutions[i].has_value()) {
                converged_indices.push_back(i);
            }
        }
        if (converged_indices.empty()) {
            return NumericMatrix(0, 0);
        }
        auto first = solutions[converged_indices[0]]->value(var);
        NumericMatrix result(first.size(), static_cast<int>(converged_indices.size()));
        result.col(0) = first;
        for (size_t j = 1; j < converged_indices.size(); ++j) {
            result.col(static_cast<int>(j)) = solutions[converged_indices[j]]->value(var);
        }
        return result;
    }
};
 
} // namespace janus