PhpScience\PageRank\Service\PageRankAlgorithm

Complexity

Total Complexity

8

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	normalize()	0	13	1
A	run()	0	6	1
A	powerIterate()	0	18	3
A	runBatch()	0	7	1
A	initiateRanking()	0	8	1

<?php


declare(strict_types=1);


namespace PhpScience\PageRank\Service;


use PhpScience\PageRank\Data\NodeCollectionInterface;

use PhpScience\PageRank\Service\PageRankAlgorithm\NormalizerInterface;

use PhpScience\PageRank\Service\PageRankAlgorithm\RankingInterface;

use PhpScience\PageRank\Strategy\NodeDataSourceStrategyInterface;


class PageRankAlgorithm implements PageRankAlgorithmInterface

{

    private NodeDataSourceStrategyInterface $nodeDataStrategy;

    private RankingInterface                $ranking;

    private NormalizerInterface             $normalizer;


    public function __construct(

        RankingInterface $ranking,

        NodeDataSourceStrategyInterface $nodeDataStrategy,

        NormalizerInterface $normalizer

    ) {

        $this->nodeDataStrategy = $nodeDataStrategy;

        $this->ranking = $ranking;

        $this->normalizer = $normalizer;

    }


    public function run(int $maxIterate): NodeCollectionInterface

    {

        $this->initiateRanking();

        $this->runBatch($maxIterate);


        return $this->normalize();

    }


    public function initiateRanking(): NodeCollectionInterface

    {

        $nodeCollection = $this->nodeDataStrategy->getNodeCollection();


        $this->ranking->calculateInitialRank($nodeCollection);

        $this->nodeDataStrategy->updateNodes($nodeCollection);


        return $nodeCollection;

    }


    public function runBatch(int $maxIterate): NodeCollectionInterface

    {

        $nodeCollection = $this->nodeDataStrategy->getNodeCollection();


        $this->powerIterate($nodeCollection, $maxIterate);


        return $nodeCollection;

    }


    public function normalize(): NodeCollectionInterface

    {

        $nodeCollection = $this->nodeDataStrategy->getNodeCollection();

        $min = $this->nodeDataStrategy->getLowestRank();

        $max = $this->nodeDataStrategy->getHighestRank();


        $this->normalizer->normalize(

            $nodeCollection,

            $min,

            $max

        );


        return $nodeCollection;

    }


    private function powerIterate(

        NodeCollectionInterface $nodeCollection,

        int $maxIterate

    ): void {

        $noneRepresentableDiffCount = 0;

        $i = 0;


        while (

            $i < $maxIterate

            && $noneRepresentableDiffCount < $nodeCollection->getAllNodeCount()

        ) {

            $i++;


            $noneRepresentableDiffCount = $this

                ->ranking

                ->calculateRankPerIteration($nodeCollection);


            $this->nodeDataStrategy->updateNodes($nodeCollection);

        }

    }

}