WorseThanBestSolutionSkipper::nextCandidate() - Code Metrics - Stratadox/PuzzleSolver - Measure and Improve Code Quality continuously with Scrutinizer

WorseThanBestSolutionSkipper::nextCandidate() A
last analyzed 2021-02-03 19:18 UTC

↳ Parent: WorseThanBestSolutionSkipper

Complexity

Conditions	3
Paths	2

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	6
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	10
rs	10

<?php declare(strict_types=1);

namespace Stratadox\PuzzleSolver\SearchStrategy;

use Stratadox\PuzzleSolver\Puzzle;
use const INF;

/**
 * Worse-Than-Best Solution Skipper
 *
 * The Worse-Than-Best Solution Skipper keeps track of the lowest cost of the
 * solutions that have been found during the search. Each time a node is
 * encountered of which the path cost is more than the cost of the cheapest
 * solution that has already been found, the node is skipped.
 *
 * @author Stratadox
 */
final class WorseThanBestSolutionSkipper implements SearchStrategy
{
    /** @var float */
    private $lowestSolutionCost = INF;
    /** @var SearchStrategy */
    private $search;

    private function __construct(SearchStrategy $search)
    {
        $this->search = $search;
    }

    public static function forThe(SearchStrategy $search): self
    {
        return new self($search);
    }

    public function isOngoing(): bool
    {
        return $this->search->isOngoing();
    }

    public function consider(Puzzle $puzzle): bool
    {
        if ($puzzle->movesSoFar()->cost() > $this->lowestSolutionCost) {
            return false;
        }
        return $this->search->consider($puzzle);
    }

    public function nextCandidate(): Puzzle
    {
        $puzzle = $this->search->nextCandidate();
        if (
            $puzzle->isSolved() &&
            ($cost = $puzzle->movesSoFar()->cost()) < $this->lowestSolutionCost
        ) {
            $this->lowestSolutionCost = $cost;
        }
        return $puzzle;
    }
}


1			<?php declare(strict_types=1);
2
3			namespace Stratadox\PuzzleSolver\SearchStrategy;
4
5			use Stratadox\PuzzleSolver\Puzzle;
6			use const INF;
7
8			/**
9			* Worse-Than-Best Solution Skipper
10			*
11			* The Worse-Than-Best Solution Skipper keeps track of the lowest cost of the
12			* solutions that have been found during the search. Each time a node is
13			* encountered of which the path cost is more than the cost of the cheapest
14			* solution that has already been found, the node is skipped.
15			*
16			* @author Stratadox
17			*/
18			final class WorseThanBestSolutionSkipper implements SearchStrategy
19			{
20			/** @var float */
21			private $lowestSolutionCost = INF;
22			/** @var SearchStrategy */
23			private $search;
24
25			private function __construct(SearchStrategy $search)
26			{
27			$this->search = $search;
28			}
29
30			public static function forThe(SearchStrategy $search): self
31			{
32			return new self($search);
33			}
34
35			public function isOngoing(): bool
36			{
37			return $this->search->isOngoing();
38			}
39
40			public function consider(Puzzle $puzzle): bool
41			{
42			if ($puzzle->movesSoFar()->cost() > $this->lowestSolutionCost) {
43			return false;
44			}
45			return $this->search->consider($puzzle);
46			}
47
48			public function nextCandidate(): Puzzle
49			{
50			$puzzle = $this->search->nextCandidate();
51			if (
52			$puzzle->isSolved() &&
53			($cost = $puzzle->movesSoFar()->cost()) < $this->lowestSolutionCost
54			) {
55			$this->lowestSolutionCost = $cost;
56			}
57			return $puzzle;
58			}
59			}
60

Stratadox / PuzzleSolver

WorseThanBestSolutionSkipper::nextCandidate() A last analyzed 2021-02-03 19:18 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

WorseThanBestSolutionSkipper::nextCandidate() A
last analyzed 2021-02-03 19:18 UTC