ExperimentManager.java

package cwp;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import cwp.algorithm.Solution;
import cwp.instance.Instance;

public class ExperimentManager {

    private final Map<String, Map<String, Double>> table = new LinkedHashMap<>();
    private final Map<String, Integer> numBest = new LinkedHashMap<>();
    private final Map<String, Double> meanDeviation = new LinkedHashMap<>();

    private boolean calculatedStats = false;

    private final Path experimentDir;
    private final String date;

    public ExperimentManager() throws IOException {
        LocalDateTime now = LocalDateTime.now();
        String timestamp = now.format(DateTimeFormatter.ofPattern("yyyyMMdd-HHmmss"));
        date = now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        experimentDir = Path.of("experiments", timestamp);
        Files.createDirectories(experimentDir);
    }

    public void addSolution(Instance instance, String methodName, Solution solution) throws IOException {
        double weight = solution.getTotalWeight();
        table.computeIfAbsent(instance.getName(), k -> new LinkedHashMap<>()).put(methodName, weight);
        calculatedStats = false;
        saveSolution(instance, methodName, solution);
    }

    public void calculateStats() {
        numBest.clear();
        meanDeviation.clear();

        if (table.isEmpty()) {
            calculatedStats = true;
            return;
        }

        double numInstances = table.size();

        for (Map<String, Double> instanceValues : table.values()) {
            if (instanceValues.isEmpty()) {
                continue;
            }

            // CWP is a minimization problem: the best value is the smallest one
            double bestValue = instanceValues.values().stream()
                    .min(Double::compare)
                    .orElse(0d);

            for (Map.Entry<String, Double> entry : instanceValues.entrySet()) {
                String methodName = entry.getKey();
                double value = entry.getValue();

                if (bestValue != 0d) {
                    meanDeviation.merge(methodName, (value - bestValue) / bestValue, Double::sum);
                }

                if (bestValue == value) {
                    numBest.merge(methodName, 1, Integer::sum);
                }
            }
        }

        for (Map.Entry<String, Double> entry : meanDeviation.entrySet()) {
            meanDeviation.put(entry.getKey(), entry.getValue() / numInstances);
        }

        for (String methodName : numBest.keySet()) {
            meanDeviation.putIfAbsent(methodName, 0d);
        }

        calculatedStats = true;
    }

    public int getNumBest(String methodName) {
        if (!calculatedStats) {
            calculateStats();
        }
        return numBest.getOrDefault(methodName, 0);
    }

    public double getMeanDeviation(String methodName) {
        if (!calculatedStats) {
            calculateStats();
        }
        return meanDeviation.getOrDefault(methodName, 0d);
    }

    public List<String> getMethodNames() {
        return table.values().stream()
                .flatMap(instanceValues -> instanceValues.keySet().stream())
                .distinct()
                .toList();
    }

    public void experimentFinished() throws IOException {
        if (!calculatedStats) {
            calculateStats();
        }

        printConsoleReport();
        writeHtmlReport();

        System.out.println();
        System.out.println("Results saved in: " + experimentDir.toAbsolutePath());
    }

    private void saveSolution(Instance instance, String methodName, Solution solution) throws IOException {
        Path instanceDir = experimentDir.resolve(instance.getName());
        Files.createDirectories(instanceDir);

        StringBuilder content = new StringBuilder();
        content.append("Instance: ").append(instance.getDescription()).append("\n");
        content.append("Algorithm: ").append(methodName).append("\n");
        content.append("Weight: ").append(solution.getTotalWeight()).append("\n");
        content.append("Solution:\n").append(solution).append("\n");

        Files.writeString(instanceDir.resolve(methodName + ".txt"), content.toString());
    }

    private void printConsoleReport() {
        List<String> methodNames = getMethodNames();

        printRow("Instance", methodNames);

        for (Map.Entry<String, Map<String, Double>> instance : table.entrySet()) {
            System.out.print(instance.getKey());
            for (String methodName : methodNames) {
                System.out.print("\t" + instance.getValue().getOrDefault(methodName, 0d));
            }
            System.out.println();
        }

        System.out.println("----------------------------------------------------");

        System.out.print("Mean deviation (%)");
        for (String methodName : methodNames) {
            System.out.print("\t" + formatPercentage(getMeanDeviation(methodName)));
        }
        System.out.println();

        System.out.print("Number of best");
        for (String methodName : methodNames) {
            System.out.print("\t" + getNumBest(methodName));
        }
        System.out.println();
    }

    private void writeHtmlReport() throws IOException {
        List<String> methodNames = getMethodNames();

        StringBuilder html = new StringBuilder();
        html.append("<!DOCTYPE html>\n");
        html.append("<html lang=\"en\">\n<head>\n");
        html.append("<meta charset=\"utf-8\">\n");
        html.append("<title>Experiment report</title>\n");
        html.append("<style>\n");
        html.append("body { font-family: sans-serif; margin: 2rem; color: #222; }\n");
        html.append("h1 { font-size: 1.5rem; }\n");
        html.append("table { border-collapse: collapse; margin-bottom: 2rem; }\n");
        html.append("th, td { border: 1px solid #ccc; padding: 0.4rem 0.8rem; text-align: right; }\n");
        html.append("th:first-child, td:first-child { text-align: left; }\n");
        html.append("thead th { background: #f0f0f0; }\n");
        html.append("</style>\n</head>\n<body>\n");

        html.append("<h1>Experiment report</h1>\n");
        html.append("<p>Date: ").append(escape(date)).append("</p>\n");

        html.append("<h2>Results</h2>\n");
        html.append("<table>\n<thead>\n<tr><th>Instance</th>");
        for (String methodName : methodNames) {
            html.append("<th>").append(escape(methodName)).append("</th>");
        }
        html.append("</tr>\n</thead>\n<tbody>\n");
        for (Map.Entry<String, Map<String, Double>> instance : table.entrySet()) {
            html.append("<tr><td>").append(escape(instance.getKey())).append("</td>");
            for (String methodName : methodNames) {
                html.append("<td>").append(instance.getValue().getOrDefault(methodName, 0d)).append("</td>");
            }
            html.append("</tr>\n");
        }
        html.append("</tbody>\n</table>\n");

        html.append("<h2>Analysis</h2>\n");
        html.append("<table>\n<thead>\n<tr><th></th>");
        for (String methodName : methodNames) {
            html.append("<th>").append(escape(methodName)).append("</th>");
        }
        html.append("</tr>\n</thead>\n<tbody>\n");

        html.append("<tr><td>Mean deviation (%)</td>");
        for (String methodName : methodNames) {
            html.append("<td>").append(formatPercentage(getMeanDeviation(methodName))).append("</td>");
        }
        html.append("</tr>\n");

        html.append("<tr><td>Number of best</td>");
        for (String methodName : methodNames) {
            html.append("<td>").append(getNumBest(methodName)).append("</td>");
        }
        html.append("</tr>\n</tbody>\n</table>\n");

        html.append("</body>\n</html>\n");

        Files.writeString(experimentDir.resolve("report.html"), html.toString());
    }

    private String escape(String text) {
        return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;");
    }

    private String formatPercentage(double ratio) {
        return String.format(Locale.ROOT, "%.2f%%", ratio * 100);
    }

    private void printRow(String firstColumn, List<String> columns) {
        System.out.print(firstColumn);
        for (String column : columns) {
            System.out.print("\t" + column);
        }
        System.out.println();
    }

}