FiniteGroup::count() - Code Metrics - Inspection of "New NGrams iterator." - drupol/phpermutations - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 1e7555...a49478 )

by Pol

created 2018-02-06 14:33 UTC

FiniteGroup::count() A

↳ Parent: FiniteGroup

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	1
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php

namespace drupol\phpermutations\Iterators;

use drupol\phpermutations\Combinatorics;

/**
 * Class FiniteGroup.
 *
 * The finite group is an abelian finite cyclic group.
 */
class FiniteGroup extends Combinatorics implements \Iterator, \Countable
{
    /**
     * The group size.
     *
     * @var int
     */
    protected $size;

    /**
     * The group.
     *
     * @var int[]
     */
    protected $group;

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

    /**
     * Combinatorics constructor.
     */
    public function __construct()
    {
        parent::__construct([], null);
    }

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

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

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

    /**
     * {@inheritdoc}
     */
    public function valid()
    {
        return isset($this->group[$this->key()]);
    }

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

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

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

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

        return $data;
    }

    /**
     * Set the group size.
     *
     * @param int $size
     *                  The size
     */
    public function setSize($size)
    {
        $this->size = $size;
        $this->computeGroup();
    }

    /**
     * Get the group size.
     *
     * @return int
     *             The size
     */
    public function getSize()
    {
        return intval($this->size);
    }

    /**
     * Get the order.
     *
     * @param int $generator
     *                       The generator
     *
     * @return int
     *             The order
     */
    public function order($generator)
    {
        $result = [];

        foreach (range(1, $this->getSize() - 1) as $number) {
            $value = pow($generator, $number) % $this->getSize();
            $result[$value] = $value;
        }

        return count($result);
    }

    /**
     * Clean out the group from unwanted values.
     */
    private function computeGroup()
    {
        $this->group = [];

        foreach (range(1, $this->getSize() - 1) as $number) {
            if (1 === $this->gcd($number, $this->getSize() - 1)) {
                $this->group[] = $number;
            }
        }
    }

    /**
     * Get the greater common divisor between two numbers.
     *
     * @param int $a
     *               The first number
     * @param int $b
     *               The second number
     *
     * @return int
     *             The greater common divisor between $a and $b
     */
    private function gcd($a, $b)

    {
        return $b ? $this->gcd($b, $a % $b) : $a;
    }
}


1		<?php
2
3		namespace drupol\phpermutations\Iterators;
4
5		use drupol\phpermutations\Combinatorics;
6
7		/**
8		* Class FiniteGroup.
9		*
10		* The finite group is an abelian finite cyclic group.
11		*/
12		class FiniteGroup extends Combinatorics implements \Iterator, \Countable
13		{
14		/**
15		* The group size.
16		*
17		* @var int
18		*/
19		protected $size;
20
21		/**
22		* The group.
23		*
24		* @var int[]
25		*/
26		protected $group;
27
28		/**
29		* The key.
30		*
31		* @var int
32		*/
33		protected $key;
34
35		/**
36		* Combinatorics constructor.
37		*/
38	2	public function __construct()
39		{
40	2	parent::__construct([], null);
41	2	}
42
43		/**
44		* {@inheritdoc}
45		*/
46	2	public function current()
47		{
48	2	return current($this->group);
49		}
50
51		/**
52		* {@inheritdoc}
53		*/
54	2	public function next()
55		{
56	2	++$this->key;
57	2	next($this->group);
58	2	}
59
60		/**
61		* {@inheritdoc}
62		*/
63	2	public function key()
64		{
65	2	return $this->key;
66		}
67
68		/**
69		* {@inheritdoc}
70		*/
71	2	public function valid()
72		{
73	2	return isset($this->group[$this->key()]);
74		}
75
76		/**
77		* {@inheritdoc}
78		*/
79	2	public function rewind()
80		{
81	2	$this->key = 0;
82	2	}
83
84		/**
85		* Count elements of an object.
86		*
87		* @return int
88		* The number of element
89		*/
90	2	public function count()
91		{
92	2	return count($this->group);
93		}
94
95		/**
96		* Convert the iterator into an array.
97		*
98		* @return array
99		* The elements
100		*/
101	2	public function toArray()
102		{
103	2	$data = [];
104
105	2	for ($this->rewind(); $this->valid(); $this->next()) {
106	2	$data[] = $this->current();
107		}
108
109	2	return $data;
110		}
111
112		/**
113		* Set the group size.
114		*
115		* @param int $size
116		* The size
117		*/
118	2	public function setSize($size)
119		{
120	2	$this->size = $size;
121	2	$this->computeGroup();
122	2	}
123
124		/**
125		* Get the group size.
126		*
127		* @return int
128		* The size
129		*/
130	2	public function getSize()
131		{
132	2	return intval($this->size);
133		}
134
135		/**
136		* Get the order.
137		*
138		* @param int $generator
139		* The generator
140		*
141		* @return int
142		* The order
143		*/
144		public function order($generator)
145		{
146		$result = [];
147
148		foreach (range(1, $this->getSize() - 1) as $number) {
149		$value = pow($generator, $number) % $this->getSize();
150		$result[$value] = $value;
151		}
152
153		return count($result);
154		}
155
156		/**
157		* Clean out the group from unwanted values.
158		*/
159	2	private function computeGroup()
160		{
161	2	$this->group = [];
162
163	2	foreach (range(1, $this->getSize() - 1) as $number) {
164	2	if (1 === $this->gcd($number, $this->getSize() - 1)) {
165	2	$this->group[] = $number;
166		}
167		}
168	2	}
169
170		/**
171		* Get the greater common divisor between two numbers.
172		*
173		* @param int $a
174		* The first number
175		* @param int $b
176		* The second number
177		*
178		* @return int
179		* The greater common divisor between $a and $b
180		*/
181	2	private function gcd($a, $b)
		0 ignored issues – show Comprehensibility introduced 2017-08-15 18:29 UTC by Report Bug Copy Issue Report Avoid variables with short names like $a. Configured minimum length is 3. Short variable names may make your code harder to understand. Variable names should be self-descriptive. This check looks for variable names who are shorter than a configured minimum. Loading history... Comprehensibility introduced 2017-08-15 18:29 UTC by Report Bug Copy Issue Report Avoid variables with short names like $b. Configured minimum length is 3. Short variable names may make your code harder to understand. Variable names should be self-descriptive. This check looks for variable names who are shorter than a configured minimum. Loading history...
182		{
183	2	return $b ? $this->gcd($b, $a % $b) : $a;
184		}
185		}
186

drupol / phpermutations

Push — master ( 1e7555...a49478 )

FiniteGroup::count() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like