drupol\phpermutations\Iterators\PrimeSieveOfEratosthenes

Complexity

Total Complexity

21

Size/Duplication

Total Lines	185
Duplicated Lines	0 %

Coupling/Cohesion

Dependencies

1

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	generateNextPrime()	0	19	5
A	rewind()	0	3	1
A	current()	0	9	2
A	valid()	0	3	1
A	key()	0	3	1
A	next()	0	3	1
A	count()	0	3	1
A	toArray()	0	9	2
A	setMaxLimit()	0	3	1
A	getMaxLimit()	0	3	1
A	setMinLimit()	0	3	1
A	getMinLimit()	0	3	2
A	pi()	0	3	1

<?php

namespace drupol\phpermutations\Iterators;

use drupol\phpermutations\Combinatorics;

/**
 * Class PrimeSieveOfEratosthenes.
 *
 * @package drupol\phpermutations\Iterators
 */
class PrimeSieveOfEratosthenes extends Combinatorics implements \Iterator, \Countable {

  /**
   * The minimum limit.
   *
   * @var int
   */
  protected $min;

  /**
   * The maximum limit.
   *
   * @var int
   */
  protected $max;

  /**
   * The key.
   *
   * @var int
   */
  protected $key;

  /**
   * The primes array.
   *
   * @var array
   */
  private $primes;

  /**
   * @var int
   */
  private $last;

  /**
   * PrimeSieveOfEratosthenes constructor.
   */
  public function __construct() {
    $this->setMaxLimit(PHP_INT_MAX);
    $this->setMinLimit(0);
    $this->primes = array(2, 3);
  }

  /**
   *
   */
  private function generateNextPrime() {
    $candidate = end($this->primes);

    do {
      $candidate += 2;
      $isPrime = TRUE;

TRUE, FALSE and NULL must be lowercase; expected true, but found TRUE.

      foreach ($this->primes as $prime) {
        if ($candidate % $prime == 0) {
          $isPrime = FALSE;
          break;
        }
        if ($prime * $prime > $candidate) {
          break;
        }
      }
    } while (!$isPrime);

    $this->primes[] = $candidate;
  }

  /**
   * {@inheritdoc}
   */
  public function rewind() {
    $this->key = 0;
  }

  /**
   * {@inheritdoc}
   */
  public function current() {
    if (!isset($this->primes[$this->key()])) {
      $this->generateNextPrime();
    }

    $this->last = $this->primes[$this->key()];

    return $this->last;
  }

  /**
   * {@inheritdoc}
   */
  public function valid() {
    return $this->last < $this->getMaxLimit();
  }

  /**
   * {@inheritdoc}
   */
  public function key() {
    return $this->key;
  }

  /**
   * {@inheritdoc}
   */
  public function next() {
    ++$this->key;
  }

  /**
   * Count elements of an object.
   *
   * @return int
   *   The number of element.
   */
  public function count() {
    return count($this->toArray());
  }

  /**
   * Convert the iterator into an array.
   *
   * @return array
   *   The elements.
   */
  public function toArray() {
    $data = array();

    for ($this->rewind(); $this->valid(); $this->next()) {
      $data[] = $this->current();
    }

    return $data;
  }

  /**
   * Set the maximum limit.
   *
   * @param int $max
   *   The limit.
   */
  public function setMaxLimit($max) {
    $this->max = $max;
  }

  /**
   * Get the maximum limit.
   *
   * @return int
   *   The limit.
   */
  public function getMaxLimit() {
    return intval($this->max);
  }

  /**
   * Set the minimum limit.
   *
   * @param int $min
   *   The limit.
   */
  public function setMinLimit($min) {
    $this->min = $min;
  }

  /**
   * Get the minimum limit.
   *
   * @return int
   *   The limit.
   */
  public function getMinLimit() {
    return $this->min <= 2 ? 2 : intval($this->min);
  }

  /**
   * Get a rough estimation of how many prime numbers there are.
   *
   * @return float
   *   The number of primes.
   */
  public function pi() {

This method's name is shorter than the configured minimum length of 3 characters.

    return $this->getMaxLimit() / log($this->getMaxLimit());
  }

}