Phpml\Clustering\KMeans\Point

Complexity

Total Complexity

15

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	toArray()	0	4	1
A	getDistanceWith()	0	10	3
A	getClosest()	0	22	4
A	getCoordinates()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	count()	0	4	1

<?php

declare(strict_types=1);

namespace Phpml\Clustering\KMeans;

use ArrayAccess;

class Point implements ArrayAccess, \Countable
{
    /**
     * @var int
     */
    protected $dimension;

    /**
     * @var array
     */
    protected $coordinates = [];

    /**
     * @var mixed
     */
    protected $label;

    /**
     * @param mixed $label
     */
    public function __construct(array $coordinates, $label = null)
    {
        $this->dimension = count($coordinates);
        $this->coordinates = $coordinates;
        $this->label = $label;
    }

    public function toArray(): array
    {
        return $this->coordinates;
    }

    /**
     * @return float|int
     */
    public function getDistanceWith(self $point, bool $precise = true)
    {
        $distance = 0;
        for ($n = 0; $n < $this->dimension; ++$n) {
            $difference = $this->coordinates[$n] - $point->coordinates[$n];
            $distance += $difference * $difference;
        }

        return $precise ? sqrt((float) $distance) : $distance;
    }

    /**
     * @param Point[] $points
     */
    public function getClosest(array $points): ?self
    {
        $minPoint = null;

        foreach ($points as $point) {
            $distance = $this->getDistanceWith($point, false);

$point is of type object<Phpml\Clustering\KMeans\Point>, but the function expects a object<self>.

            if (!isset($minDistance)) {
                $minDistance = $distance;
                $minPoint = $point;

                continue;
            }

            if ($distance < $minDistance) {
                $minDistance = $distance;
                $minPoint = $point;
            }
        }

        return $minPoint;
    }

    public function getCoordinates(): array
    {
        return $this->coordinates;
    }

    /**
     * @param mixed $offset
     */
    public function offsetExists($offset): bool
    {
        return isset($this->coordinates[$offset]);
    }

    /**
     * @param mixed $offset
     *
     * @return mixed
     */
    public function offsetGet($offset)
    {
        return $this->coordinates[$offset];
    }

    /**
     * @param mixed $offset
     * @param mixed $value
     */
    public function offsetSet($offset, $value): void
    {
        $this->coordinates[$offset] = $value;
    }

    /**
     * @param mixed $offset
     */
    public function offsetUnset($offset): void
    {
        unset($this->coordinates[$offset]);
    }

    public function count(): int
    {
        return count($this->coordinates);
    }
}