JMGQ\AStar\Benchmark\Result\ResultAggregator

Complexity

Total Complexity

7

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getNumberOfResultsWithASolution()	0	5	1
A	getDurations()	0	3	1
A	groupBySize()	0	9	2
A	process()	0	26	2
A	averageDuration()	0	3	1

<?php

namespace JMGQ\AStar\Benchmark\Result;

class ResultAggregator
{
    /**
     * @param Result[] $results
     * @return AggregatedResult[]
     */
    public function process(array $results): array
    {
        $aggregatedResults = [];

        $sizeToResultsMap = $this->groupBySize($results);

        foreach ($sizeToResultsMap as $size => $groupedResults) {
            /** @var non-empty-array<int> $durations */
            $durations = $this->getDurations($groupedResults);
            $averageDuration = $this->averageDuration($durations);
            $minimumDuration = min($durations);
            $maximumDuration = max($durations);
            $numberOfSolutions = $this->getNumberOfResultsWithASolution($groupedResults);
            $numberOfTerrains = count($groupedResults);

            $aggregatedResults[] = new AggregatedResult(
                $size,
                $averageDuration,
                $minimumDuration,
                $maximumDuration,
                $numberOfSolutions,
                $numberOfTerrains
            );
        }

        return $aggregatedResults;
    }

    /**
     * @param Result[] $results
     * @return array<int, Result[]>
     */
    private function groupBySize(array $results): array
    {
        $groupedResults = [];

        foreach ($results as $result) {
            $groupedResults[$result->getSize()][] = $result;
        }

        return $groupedResults;
    }

    /**
     * @param Result[] $results
     * @return int[]
     */
    private function getDurations(array $results): array
    {
        return array_map(static fn ($result) => $result->getDuration(), $results);
    }

    /**
     * @param int[] $durations
     * @return int
     */
    private function averageDuration(array $durations): int
    {
        return (int) (array_sum($durations) / count($durations));
    }

    /**
     * @param Result[] $results
     * @return int
     */
    private function getNumberOfResultsWithASolution(array $results): int
    {
        $solvedResults = array_filter($results, static fn ($result) => $result->hasSolution());

        return count($solvedResults);
    }
}