ResultAggregator::averageDuration()   A
last analyzed

Complexity

Conditions 1
Paths 1

Size

Total Lines 3
Code Lines 1

Duplication

Lines 0
Ratio 0 %

Code Coverage

Tests 2
CRAP Score 1

Importance

Changes 1
Bugs 0 Features 0
Metric Value
eloc 1
c 1
b 0
f 0
dl 0
loc 3
ccs 2
cts 2
cp 1
rs 10
cc 1
nc 1
nop 1
crap 1
1
<?php
2
3
namespace JMGQ\AStar\Benchmark\Result;
4
5
class ResultAggregator
6
{
7
    /**
8
     * @param Result[] $results
9
     * @return AggregatedResult[]
10
     */
11 5
    public function process(array $results): array
12
    {
13 5
        $aggregatedResults = [];
14
15 5
        $sizeToResultsMap = $this->groupBySize($results);
16
17 5
        foreach ($sizeToResultsMap as $size => $groupedResults) {
18
            /** @var non-empty-array<int> $durations */
19 5
            $durations = $this->getDurations($groupedResults);
20 5
            $averageDuration = $this->averageDuration($durations);
21 5
            $minimumDuration = min($durations);
22 5
            $maximumDuration = max($durations);
23 5
            $numberOfSolutions = $this->getNumberOfResultsWithASolution($groupedResults);
24 5
            $numberOfTerrains = count($groupedResults);
25
26 5
            $aggregatedResults[] = new AggregatedResult(
27 5
                $size,
28
                $averageDuration,
29
                $minimumDuration,
30
                $maximumDuration,
31
                $numberOfSolutions,
32
                $numberOfTerrains
33
            );
34
        }
35
36 5
        return $aggregatedResults;
37
    }
38
39
    /**
40
     * @param Result[] $results
41
     * @return array<int, Result[]>
42
     */
43 5
    private function groupBySize(array $results): array
44
    {
45 5
        $groupedResults = [];
46
47 5
        foreach ($results as $result) {
48 5
            $groupedResults[$result->getSize()][] = $result;
49
        }
50
51 5
        return $groupedResults;
52
    }
53
54
    /**
55
     * @param Result[] $results
56
     * @return int[]
57
     */
58 5
    private function getDurations(array $results): array
59
    {
60 5
        return array_map(static fn ($result) => $result->getDuration(), $results);
61
    }
62
63
    /**
64
     * @param int[] $durations
65
     * @return int
66
     */
67 5
    private function averageDuration(array $durations): int
68
    {
69 5
        return (int) (array_sum($durations) / count($durations));
70
    }
71
72
    /**
73
     * @param Result[] $results
74
     * @return int
75
     */
76 5
    private function getNumberOfResultsWithASolution(array $results): int
77
    {
78 5
        $solvedResults = array_filter($results, static fn ($result) => $result->hasSolution());
79
80 5
        return count($solvedResults);
81
    }
82
}
83