Expand deviation handling in ResultTransformer and services.

Author: andrey-helldar

src/Data/DeviationData.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DragonCode\Benchmark\Data;
+
+readonly class DeviationData
+{
+    public function __construct(
+        public MetricData $avg,
+    ) {}
+}

src/Data/ResultData.php

@@ -11,5 +11,6 @@ public function __construct(
         public MetricData $max,
         public MetricData $avg,
         public MetricData $total,
+        public ?DeviationData $deviation = null,
     ) {}
 }

src/Services/DeviationService.php

@@ -4,6 +4,7 @@
 
 namespace DragonCode\Benchmark\Services;
 
+use DragonCode\Benchmark\Data\DeviationData;
 use DragonCode\Benchmark\Data\MetricData;
 use DragonCode\Benchmark\Data\ResultData;
 
@@ -30,18 +31,37 @@ public function calculate(array $collection): array
 
     protected function map(array $collection): array
     {
-        return array_map(fn (array $item) => $this->make($item), $collection);
+        return array_map(fn (array $item): ResultData => $this->make($item), $collection);
     }
 
     protected function make(array $item): ResultData
     {
-        dd($item);
         return new ResultData(
-            min: $this->metric()
+            min      : $this->metric($item, 'min'),
+            max      : $this->metric($item, 'max'),
+            avg      : $this->metric($item, 'avg'),
+            total    : $this->metric($item, 'total'),
+            deviation: $this->deviationMetric($item),
         );
     }
 
-    protected function metric(float $time, float $memory): MetricData {}
+    protected function metric(array $item, string $key): MetricData
+    {
+        return $this->result->$key(
+            $this->result->values($item[$key], 0, false),
+            $this->result->values($item[$key], 1, false),
+        );
+    }
+
+    protected function deviationMetric(array $item): DeviationData
+    {
+        return new DeviationData(
+            avg: $this->result->avg(
+                $this->result->values($item['deviation'], 0, false),
+                $this->result->values($item['deviation'], 1, false),
+            ),
+        );
+    }
 
     protected function flatten(array $collection): array
     {
@@ -62,8 +82,8 @@ protected function flatten(array $collection): array
                 }
 
                 $result[$key]['deviation'][] = [
-                    $this->deviation($default[$key][0], $item->avg->time),
-                    $this->deviation($default[$key][1], $item->avg->memory),
+                    $this->percentage($default[$key][0], $this->deviation($default[$key][0], $item->avg->time)),
+                    $this->percentage($default[$key][1], $this->deviation($default[$key][1], $item->avg->memory)),
                 ];
             }
         }
@@ -80,4 +100,13 @@ protected function deviation(float $first, float $second): float
 
         return sqrt(($deviation1 + $deviation2) / 2);
     }
+
+    protected function percentage(float $reference, float $value): float
+    {
+        if ($reference === 0.0) {
+            return 0;
+        }
+
+        return ($value - $reference) / $reference * 100;
+    }
 }

src/Services/ResultService.php

@@ -35,9 +35,9 @@ public function force(array $collection): void
     /**
      * @return ResultData[]
      */
-    public function get(array $collections, bool $filterable = true): array
+    public function get(array $collections): array
     {
-        return $this->data ??= $this->map($collections, $filterable);
+        return $this->data ??= $this->map($collections);
     }
 
     public function clear(): void
@@ -48,21 +48,21 @@ public function clear(): void
     /**
      * @return ResultData[]
      */
-    public function map(array $collections, bool $filterable = true): array
+    public function map(array $collections): array
     {
-        return array_map(function (array $data) use ($filterable) {
+        return array_map(function (array $data): ResultData {
             return $this->collect(
-                $this->values($data, 0, $filterable),
-                $this->values($data, 1, $filterable)
+                $this->values($data, 0),
+                $this->values($data, 1)
             );
         }, $collections);
     }
 
-    protected function values(array $data, int $column, bool $filterable): array
+    public function values(array $data, int $column, bool $filter = true): array
     {
         $values = array_column($data, $column);
 
-        return $filterable ? $this->filter($values) : $values;
+        return $filter ? $this->filter($values) : $values;
     }
 
     protected function collect(array $times, array $memory): ResultData
@@ -75,31 +75,31 @@ protected function collect(array $times, array $memory): ResultData
         );
     }
 
-    protected function min(array $times, array $memory): MetricData
+    public function min(array $times, array $memory): MetricData
     {
         return $this->metric(
             time  : min($times),
             memory: min($memory),
         );
     }
 
-    protected function max(array $times, array $memory): MetricData
+    public function max(array $times, array $memory): MetricData
     {
         return $this->metric(
             time  : max($times),
             memory: max($memory),
         );
     }
 
-    protected function avg(array $times, array $memory): MetricData
+    public function avg(array $times, array $memory): MetricData
     {
         return $this->metric(
             time  : array_sum($times) / count($times),
             memory: array_sum($memory) / count($memory),
         );
     }
 
-    protected function total(array $times, array $memory): MetricData
+    public function total(array $times, array $memory): MetricData
     {
         return $this->metric(
             time  : array_sum($times),

src/Transformers/ResultTransformer.php

@@ -53,6 +53,18 @@ protected function map(array $table, array $collection): array
             $table[2][$key] = $this->value($item->avg);
             $table[3][$key] = $this->value($item->total);
             $table[5][$key] = 0;
+
+            if (! $deviation = $item->deviation?->avg) {
+                continue;
+            }
+
+            $table[6] = [null];
+
+            $table[7]['#'] = 'deviation time';
+            $table[8]['#'] = 'deviation memory';
+
+            $table[7][$key] = $this->deviation($deviation->time);
+            $table[8][$key] = $this->deviation($deviation->memory);
         }
 
         return $table;
@@ -88,6 +100,11 @@ protected function value(MetricData $metric): string
             : sprintf('%s ms', $time);
     }
 
+    protected function deviation(float $value): ?string
+    {
+        return ($value > 0 ? '+' : '') . round($value, 2) . '%';
+    }
+
     protected function time(float $value): float
     {
         if ($this->precision === null) {

src/View/TableView.php

@@ -43,7 +43,7 @@ protected function headers(array $data): array
 
     protected function columnWidths(array $headers, array $data): array
     {
-        $widths = array_map(fn ($header) => mb_strlen((string) $header), $headers);
+        $widths = array_map(static fn ($header) => mb_strlen((string) $header), $headers);
 
         foreach ($data as $row) {
             foreach (array_values($row) as $i => $value) {