Hotrush\Polarcy\Polarcy

Complexity

Total Complexity

16

Size/Duplication

Total Lines	130
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	accuracy()	0	7	2
A	calculateAccuracy()	0	21	6
A	minPerPoint()	0	3	1
A	calculate()	0	4	1
A	calculateAveragePoint()	0	12	1
A	__construct()	0	9	3
A	averagePoint()	0	7	2

<?php

namespace Hotrush\Polarcy;

class Polarcy
{
    /**
     * @var PointsCollection
     */
    private $pointsCollection;

    /**
     * @var Point
     */
    private $averagePoint;

    /**
     * @var float
     */
    private $accuracy;

    /**
     * @var float|int
     */
    private $maxDistance;

    /**
     * @var float|int
     */
    private $minPerPoint;

    /**
     * Polarcy constructor.
     *
     * @param PointsCollection $pointsCollection
     * @param null $maxDistance

Are you sure the doc-type for parameter $maxDistance is correct as it would always require null to be passed?

     * @param null $minPerPoint

Are you sure the doc-type for parameter $minPerPoint is correct as it would always require null to be passed?

     */
    public function __construct(PointsCollection $pointsCollection, $maxDistance = null, $minPerPoint = null)
    {
        if ($pointsCollection->total() < 2) {
            throw new \InvalidArgumentException('PointsCollection must have at least two points');
        }

        $this->pointsCollection = $pointsCollection;
        $this->maxDistance = $maxDistance;
        $this->minPerPoint = $minPerPoint ?: $this->minPerPoint();

$minPerPoint is of type null, thus it always evaluated to false.

    }

    /**
     * @return Point
     */
    public function averagePoint()
    {
        if (!$this->averagePoint) {
            $this->calculate();
        }

        return $this->averagePoint;
    }

    /**
     * @return float
     */
    public function accuracy()
    {
        if (!$this->accuracy) {
            $this->calculate();
        }

        return $this->accuracy;
    }

    /**
     * Run the calculations
     *
     * @return void
     */
    public function calculate()
    {
        $this->calculateAveragePoint();
        $this->calculateAccuracy();
    }

    /**
     * @return float|int
     */
    private function minPerPoint()
    {
        return 100 / pow($this->pointsCollection->total(), 2);
    }

    /**
     * @return void
     */
    private function calculateAveragePoint()
    {
        $xSum = array_sum(array_map(function (Point $point) {
            return $point->x();
        }, $this->pointsCollection->all()));
        $ySum = array_sum(array_map(function (Point $point) {
            return $point->y();
        }, $this->pointsCollection->all()));

        $this->averagePoint = new Point(
            $xSum / $this->pointsCollection->total(),
            $ySum / $this->pointsCollection->total()
        );
    }

    /**
     * @return void
     */
    private function calculateAccuracy()
    {
        $maxPerPoint = 100 / $this->pointsCollection->total();
        $distances = [];

        foreach ($this->pointsCollection->all() as $point) {
            $distances[] = Helpers::distanceBetweenPoints($point, $this->averagePoint);
        }

        if (!$this->maxDistance) {
            rsort($distances, SORT_NUMERIC);
            $this->maxDistance = $distances[0];
        }

        if ($this->maxDistance > 0) {
            foreach ($distances as $distance) {
                $remoteness = ($this->maxDistance - $distance) / $this->maxDistance;
                $this->accuracy += $remoteness > 0 ? $remoteness * $maxPerPoint : $this->minPerPoint;
            }
        } else {
            $this->accuracy = 100;
        }
    }
}