Added more strict typing, refreshing and refactoring source code

Author: EnzoMC

src/FPGrowth.php

@@ -1,46 +1,50 @@
 <?php
 
+declare(strict_types=1);
 
 namespace EnzoMC\PhpFPGrowth;
 
+use Generator;
 
 class FPGrowth
 {
-    protected $support = 3;
-    protected $confidence = 0.7;
+    protected int $support = 3;
+    protected float $confidence = 0.7;
 
     private $patterns;
     private $rules;
 
     /**
-     * @return mixed
+     * @return int
      */
-    public function getSupport()
+    public function getSupport(): int
     {
         return $this->support;
     }
 
     /**
-     * @param mixed $support
+     * @param int $support
+     * @return self
      */
-    public function setSupport($support)
+    public function setSupport(int $support): self
     {
         $this->support = $support;
         return $this;
     }
 
     /**
-     * @return mixed
+     * @return float
      */
-    public function getConfidence()
+    public function getConfidence(): float
     {
         return $this->confidence;
     }
 
     /**
-     * @param mixed $confidence
+     * @param float $confidence
+     * @return self
      */
-    public function setConfidence($confidence)
+    public function setConfidence(float $confidence): self
     {
         $this->confidence = $confidence;
         return $this;
@@ -64,32 +68,40 @@ public function getRules()
 
     /**
      * FPGrowth constructor.
-     * @param $support 1, 2, 3 ...
-     * @param $confidence 0 ... 1
+     * @param int $support 1, 2, 3 ...
+     * @param float $confidence 0 ... 1
      */
-    public function __construct($support, $confidence)
+    public function __construct(int $support, float $confidence)
     {
-        $this->support = $support;
-        $this->confidence = $confidence;
+        $this->setSupport($support);
+        $this->setConfidence($confidence);
     }
 
     /**
      * Do algorithm
-     * @param $transactions
+     * @param array $transactions
      */
-    public function run($transactions)
+    public function run(array $transactions)
     {
-        $this->patterns = $this->findFrequentPatterns($transactions, $this->support);
-        $this->rules = $this->generateAssociationRules($this->patterns, $this->confidence);
+        $this->patterns = $this->findFrequentPatterns($transactions);
+        $this->rules = $this->generateAssociationRules($this->patterns);
     }
 
-    protected function findFrequentPatterns($transactions, $support_threshold)
+    /**
+     * @param array $transactions
+     * @return array<string,int>
+     */
+    protected function findFrequentPatterns(array $transactions): array
     {
-        $tree = new FPTree($transactions, $support_threshold, null, null);
-        return $tree->minePatterns($support_threshold);
+        $tree = new FPTree($transactions, $this->support, null, 0);
+        return $tree->minePatterns($this->support);
     }
 
-    protected function generateAssociationRules($patterns, $confidence_threshold)
+    /**
+     * @param array $patterns
+     * @return array
+     */
+    protected function generateAssociationRules(array $patterns): array
     {
         $rules = [];
         foreach (array_keys($patterns) as $itemsetStr) {
@@ -104,8 +116,8 @@ protected function generateAssociationRules($patterns, $confidence_threshold)
                     $consequentStr = implode(',', $consequent);
                     if (isset($patterns[$antecedentStr])) {
                         $lower_support = $patterns[$antecedentStr];
-                        $confidence = (floatval($upper_support) / $lower_support);
-                        if ($confidence >= $confidence_threshold) {
+                        $confidence = floatval($upper_support) / $lower_support;
+                        if ($confidence >= $this->confidence) {
                             $rules[] = [$antecedentStr, $consequentStr, $confidence];
                         }
                     }
@@ -115,34 +127,15 @@ protected function generateAssociationRules($patterns, $confidence_threshold)
         return $rules;
     }
 
-    public static function iter($var)
-    {
-
-        switch (true) {
-            case $var instanceof \Iterator:
-                return $var;
-
-            case $var instanceof \Traversable:
-                return new \IteratorIterator($var);
-
-            case is_string($var):
-                $var = str_split($var);
-
-            case is_array($var):
-                return new \ArrayIterator($var);
-
-            default:
-                $type = gettype($var);
-                throw new \InvalidArgumentException("'$type' type is not iterable");
-        }
-
-        return;
-    }
-
-    public static function combinations($iterable, $r)
+    /**
+     * @param array $pool
+     * @param int $r
+     * @return Generator
+     * @todo Move to separate class
+     */
+    public static function combinations(array $pool, int $r): Generator
     {
-        $pool = is_array($iterable) ? $iterable : iterator_to_array(self::iter($iterable));
-        $n = sizeof($pool);
+        $n = count($pool);
 
         if ($r > $n) {
             return;

src/FPNode.php

@@ -1,16 +1,25 @@
 <?php
 
+declare(strict_types=1);
 
 namespace EnzoMC\PhpFPGrowth;
 
-use stdClass;
-
-class FPNode extends stdClass
+class FPNode
 {
+    public $value;
+    public int $count;
+    public ?FPNode $parent = null;
+    public ?FPNode $link = null;
+    /** @var FPNode[] */
+    public array $children;
+
     /**
      * Create the node.
+     * @param mixed $value
+     * @param int $count
+     * @param FPNode|null $parent
      */
-    function __construct($value, $count, $parent)
+    public function __construct($value, int $count, ?FPNode $parent)
     {
         $this->value = $value;
         $this->count = $count;
@@ -21,11 +30,13 @@ function __construct($value, $count, $parent)
 
     /**
      * Check if node has a particular child node.
+     * @param mixed $value
+     * @return bool
      */
-    function has_child($value)
+    public function hasChild($value): bool
     {
         foreach ($this->children as $node) {
-            if (($node->value == $value)) {
+            if ($node->value == $value) {
                 return true;
             }
         }
@@ -34,21 +45,25 @@ function has_child($value)
 
     /**
      * Return a child node with a particular value.
+     * @param $value
+     * @return FPNode|null
      */
-    function get_child($value)
+    public function getChild($value): ?FPNode
     {
         foreach ($this->children as $node) {
-            if (($node->value == $value)) {
+            if ($node->value == $value) {
                 return $node;
             }
         }
-        return;
+        return null;
     }
 
     /**
      * Add a node as a child node.
+     * @param $value
+     * @return FPNode
      */
-    function add_child($value)
+    public function addChild($value): FPNode
     {
         $child = new FPNode($value, 1, $this);
         $this->children[] = $child;