Space::iterate() - Code Metrics - php-ai/php-ml - Measure and Improve Code Quality continuously with Scrutinizer

Space::iterate() B
last analyzed 2020-05-15 05:48 UTC

↳ Parent: Space

Complexity

Conditions	8
Paths	40

Size

Total Lines	42
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	21
dl	0
loc	42
rs	8.4444
c	0
b	0
f	0
cc	8
nc	40
nop	1

<?php

declare(strict_types=1);

namespace Phpml\Clustering\KMeans;

use InvalidArgumentException;
use LogicException;
use Phpml\Clustering\KMeans;
use SplObjectStorage;

class Space extends SplObjectStorage
{
    /**
     * @var int
     */
    protected $dimension;

    public function __construct(int $dimension)
    {
        if ($dimension < 1) {
            throw new LogicException('a space dimension cannot be null or negative');
        }

        $this->dimension = $dimension;
    }

    public function toArray(): array
    {
        $points = [];

        /** @var Point $point */
        foreach ($this as $point) {
            $points[] = $point->toArray();
        }

        return ['points' => $points];
    }

    /**
     * @param mixed $label
     */
    public function newPoint(array $coordinates, $label = null): Point
    {
        if (count($coordinates) !== $this->dimension) {
            throw new LogicException('('.implode(',', $coordinates).') is not a point of this space');
        }

        return new Point($coordinates, $label);
    }

    /**
     * @param mixed $label
     * @param mixed $data
     */
    public function addPoint(array $coordinates, $label = null, $data = null): void
    {
        $this->attach($this->newPoint($coordinates, $label), $data);
    }

    /**
     * @param object $point
     * @param mixed  $data
     */
    public function attach($point, $data = null): void
    {
        if (!$point instanceof Point) {
            throw new InvalidArgumentException('can only attach points to spaces');
        }

        parent::attach($point, $data);
    }

    public function getDimension(): int
    {
        return $this->dimension;
    }

    /**
     * @return array|bool
     */
    public function getBoundaries()
    {
        if (count($this) === 0) {
            return false;
        }

        $min = $this->newPoint(array_fill(0, $this->dimension, null));
        $max = $this->newPoint(array_fill(0, $this->dimension, null));

        /** @var Point $point */
        foreach ($this as $point) {
            for ($n = 0; $n < $this->dimension; ++$n) {
                if ($min[$n] === null || $min[$n] > $point[$n]) {
                    $min[$n] = $point[$n];
                }

                if ($max[$n] === null || $max[$n] < $point[$n]) {
                    $max[$n] = $point[$n];
                }
            }
        }

        return [$min, $max];
    }

    public function getRandomPoint(Point $min, Point $max): Point
    {
        $point = $this->newPoint(array_fill(0, $this->dimension, null));

        for ($n = 0; $n < $this->dimension; ++$n) {
            $point[$n] = random_int($min[$n], $max[$n]);
        }

        return $point;
    }

    /**
     * @return Cluster[]
     */
    public function cluster(int $clustersNumber, int $initMethod = KMeans::INIT_RANDOM): array
    {
        $clusters = $this->initializeClusters($clustersNumber, $initMethod);

        do {
        } while (!$this->iterate($clusters));

        return $clusters;
    }

    /**
     * @return Cluster[]
     */
    protected function initializeClusters(int $clustersNumber, int $initMethod): array
    {
        switch ($initMethod) {
            case KMeans::INIT_RANDOM:
                $clusters = $this->initializeRandomClusters($clustersNumber);

                break;

            case KMeans::INIT_KMEANS_PLUS_PLUS:
                $clusters = $this->initializeKMPPClusters($clustersNumber);

                break;

            default:
                return [];
        }

        $clusters[0]->attachAll($this);

        return $clusters;
    }

    /**
     * @param Cluster[] $clusters
     */
    protected function iterate(array $clusters): bool
    {
        $convergence = true;

        $attach = new SplObjectStorage();
        $detach = new SplObjectStorage();

        foreach ($clusters as $cluster) {
            foreach ($cluster as $point) {
                $closest = $point->getClosest($clusters);

                if ($closest === null) {
                    continue;
                }

                if ($closest !== $cluster) {
                    $attach[$closest] ?? $attach[$closest] = new SplObjectStorage();
                    $detach[$cluster] ?? $detach[$cluster] = new SplObjectStorage();

                    $attach[$closest]->attach($point);
                    $detach[$cluster]->attach($point);

                    $convergence = false;
                }
            }
        }

        /** @var Cluster $cluster */
        foreach ($attach as $cluster) {
            $cluster->attachAll($attach[$cluster]);
        }

        /** @var Cluster $cluster */
        foreach ($detach as $cluster) {
            $cluster->detachAll($detach[$cluster]);
        }

        foreach ($clusters as $cluster) {
            $cluster->updateCentroid();
        }

        return $convergence;
    }

    /**
     * @return Cluster[]
     */
    protected function initializeKMPPClusters(int $clustersNumber): array
    {
        $clusters = [];
        $this->rewind();

        /** @var Point $current */
        $current = $this->current();

        $clusters[] = new Cluster($this, $current->getCoordinates());

        $distances = new SplObjectStorage();

        for ($i = 1; $i < $clustersNumber; ++$i) {
            $sum = 0;
            /** @var Point $point */
            foreach ($this as $point) {
                $closest = $point->getClosest($clusters);
                if ($closest === null) {
                    continue;
                }

                $distance = $point->getDistanceWith($closest);
                $sum += $distances[$point] = $distance;
            }

            $sum = random_int(0, (int) $sum);
            /** @var Point $point */
            foreach ($this as $point) {
                $sum -= $distances[$point];

                if ($sum > 0) {
                    continue;
                }

                $clusters[] = new Cluster($this, $point->getCoordinates());

                break;
            }
        }

        return $clusters;
    }

    /**
     * @return Cluster[]
     */
    private function initializeRandomClusters(int $clustersNumber): array
    {
        $clusters = [];
        [$min, $max] = $this->getBoundaries();

        for ($n = 0; $n < $clustersNumber; ++$n) {
            $clusters[] = new Cluster($this, $this->getRandomPoint($min, $max)->getCoordinates());
        }

        return $clusters;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Phpml\Clustering\KMeans;
6
7			use InvalidArgumentException;
8			use LogicException;
9			use Phpml\Clustering\KMeans;
10			use SplObjectStorage;
11
12			class Space extends SplObjectStorage
13			{
14			/**
15			* @var int
16			*/
17			protected $dimension;
18
19			public function __construct(int $dimension)
20			{
21			if ($dimension < 1) {
22			throw new LogicException('a space dimension cannot be null or negative');
23			}
24
25			$this->dimension = $dimension;
26			}
27
28			public function toArray(): array
29			{
30			$points = [];
31
32			/** @var Point $point */
33			foreach ($this as $point) {
34			$points[] = $point->toArray();
35			}
36
37			return ['points' => $points];
38			}
39
40			/**
41			* @param mixed $label
42			*/
43			public function newPoint(array $coordinates, $label = null): Point
44			{
45			if (count($coordinates) !== $this->dimension) {
46			throw new LogicException('('.implode(',', $coordinates).') is not a point of this space');
47			}
48
49			return new Point($coordinates, $label);
50			}
51
52			/**
53			* @param mixed $label
54			* @param mixed $data
55			*/
56			public function addPoint(array $coordinates, $label = null, $data = null): void
57			{
58			$this->attach($this->newPoint($coordinates, $label), $data);
59			}
60
61			/**
62			* @param object $point
63			* @param mixed $data
64			*/
65			public function attach($point, $data = null): void
66			{
67			if (!$point instanceof Point) {
68			throw new InvalidArgumentException('can only attach points to spaces');
69			}
70
71			parent::attach($point, $data);
72			}
73
74			public function getDimension(): int
75			{
76			return $this->dimension;
77			}
78
79			/**
80			* @return array\|bool
81			*/
82			public function getBoundaries()
83			{
84			if (count($this) === 0) {
85			return false;
86			}
87
88			$min = $this->newPoint(array_fill(0, $this->dimension, null));
89			$max = $this->newPoint(array_fill(0, $this->dimension, null));
90
91			/** @var Point $point */
92			foreach ($this as $point) {
93			for ($n = 0; $n < $this->dimension; ++$n) {
94			if ($min[$n] === null \|\| $min[$n] > $point[$n]) {
95			$min[$n] = $point[$n];
96			}
97
98			if ($max[$n] === null \|\| $max[$n] < $point[$n]) {
99			$max[$n] = $point[$n];
100			}
101			}
102			}
103
104			return [$min, $max];
105			}
106
107			public function getRandomPoint(Point $min, Point $max): Point
108			{
109			$point = $this->newPoint(array_fill(0, $this->dimension, null));
110
111			for ($n = 0; $n < $this->dimension; ++$n) {
112			$point[$n] = random_int($min[$n], $max[$n]);
113			}
114
115			return $point;
116			}
117
118			/**
119			* @return Cluster[]
120			*/
121			public function cluster(int $clustersNumber, int $initMethod = KMeans::INIT_RANDOM): array
122			{
123			$clusters = $this->initializeClusters($clustersNumber, $initMethod);
124
125			do {
126			} while (!$this->iterate($clusters));
127
128			return $clusters;
129			}
130
131			/**
132			* @return Cluster[]
133			*/
134			protected function initializeClusters(int $clustersNumber, int $initMethod): array
135			{
136			switch ($initMethod) {
137			case KMeans::INIT_RANDOM:
138			$clusters = $this->initializeRandomClusters($clustersNumber);
139
140			break;
141
142			case KMeans::INIT_KMEANS_PLUS_PLUS:
143			$clusters = $this->initializeKMPPClusters($clustersNumber);
144
145			break;
146
147			default:
148			return [];
149			}
150
151			$clusters[0]->attachAll($this);
152
153			return $clusters;
154			}
155
156			/**
157			* @param Cluster[] $clusters
158			*/
159			protected function iterate(array $clusters): bool
160			{
161			$convergence = true;
162
163			$attach = new SplObjectStorage();
164			$detach = new SplObjectStorage();
165
166			foreach ($clusters as $cluster) {
167			foreach ($cluster as $point) {
168			$closest = $point->getClosest($clusters);
169
170			if ($closest === null) {
171			continue;
172			}
173
174			if ($closest !== $cluster) {
175			$attach[$closest] ?? $attach[$closest] = new SplObjectStorage();
176			$detach[$cluster] ?? $detach[$cluster] = new SplObjectStorage();
177
178			$attach[$closest]->attach($point);
179			$detach[$cluster]->attach($point);
180
181			$convergence = false;
182			}
183			}
184			}
185
186			/** @var Cluster $cluster */
187			foreach ($attach as $cluster) {
188			$cluster->attachAll($attach[$cluster]);
189			}
190
191			/** @var Cluster $cluster */
192			foreach ($detach as $cluster) {
193			$cluster->detachAll($detach[$cluster]);
194			}
195
196			foreach ($clusters as $cluster) {
197			$cluster->updateCentroid();
198			}
199
200			return $convergence;
201			}
202
203			/**
204			* @return Cluster[]
205			*/
206			protected function initializeKMPPClusters(int $clustersNumber): array
207			{
208			$clusters = [];
209			$this->rewind();
210
211			/** @var Point $current */
212			$current = $this->current();
213
214			$clusters[] = new Cluster($this, $current->getCoordinates());
215
216			$distances = new SplObjectStorage();
217
218			for ($i = 1; $i < $clustersNumber; ++$i) {
219			$sum = 0;
220			/** @var Point $point */
221			foreach ($this as $point) {
222			$closest = $point->getClosest($clusters);
223			if ($closest === null) {
224			continue;
225			}
226
227			$distance = $point->getDistanceWith($closest);
228			$sum += $distances[$point] = $distance;
229			}
230
231			$sum = random_int(0, (int) $sum);
232			/** @var Point $point */
233			foreach ($this as $point) {
234			$sum -= $distances[$point];
235
236			if ($sum > 0) {
237			continue;
238			}
239
240			$clusters[] = new Cluster($this, $point->getCoordinates());
241
242			break;
243			}
244			}
245
246			return $clusters;
247			}
248
249			/**
250			* @return Cluster[]
251			*/
252			private function initializeRandomClusters(int $clustersNumber): array
253			{
254			$clusters = [];
255			[$min, $max] = $this->getBoundaries();
256
257			for ($n = 0; $n < $clustersNumber; ++$n) {
258			$clusters[] = new Cluster($this, $this->getRandomPoint($min, $max)->getCoordinates());
259			}
260
261			return $clusters;
262			}
263			}
264

php-ai / php-ml

Space::iterate() B last analyzed 2020-05-15 05:48 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Space::iterate() B
last analyzed 2020-05-15 05:48 UTC