Warning removal

Requirement update
Few more comments
2025-07-11 14:31:04 +02:00 · 2025-07-08 09:41:38 +00:00 · 2025-06-24 12:55:00 +00:00 · 2025-06-18 11:49:40 +00:00 · 2025-06-06 14:24:46 +00:00 · 2025-06-02 08:49:46 +00:00
92 changed files with 61943 additions and 2877 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,6 +1,5 @@
-.*/
-vendor
+vendor/
 .*.cache/
-*.phar
 .phpdoc/
-output/
+output/
+tools/
--- a/.phive/phars.xml
+++ b/.phive/phars.xml
@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phive xmlns="https://phar.io/phive">
+  <phar name="phpmd" version="^2.15.0" installed="2.15.0" location="./tools/phpmd" copy="false"/>
+  <phar name="phpstan" version="^2.1.12" installed="2.1.17" location="./tools/phpstan" copy="false"/>
+  <phar name="psalm" version="^7.0.0-beta6" installed="7.0.0-beta10" location="./tools/psalm" copy="false"/>
+  <phar name="phpcs" version="^3.12.2" installed="3.13.2" location="./tools/phpcs" copy="false"/>
+  <phar name="phpcbf" version="^3.12.2" installed="3.13.2" location="./tools/phpcbf" copy="false"/>
+  <phar name="phpdocumentor" version="^3.7.1" installed="3.8.0" location="./tools/phpdocumentor" copy="false"/>
+  <phar name="phpbench" version="^1.4.1" installed="1.4.1" location="./tools/phpbench" copy="false"/>
+  <phar name="infection" version="^0.29.14" installed="0.29.14" location="./tools/infection" copy="false"/>
+  <phar name="phpunit" version="^12.1.3" installed="12.2.6" location="./tools/phpunit" copy="false"/>
+</phive>
--- a/.phpcs.xml
+++ b/.phpcs.xml
@ -6,6 +6,11 @@
    <file>tests/</file>
    <file>benchmark/</file>

+    <arg name="basepath" value="."/>
+    <arg name="colors"/>
+    <arg name="parallel" value="8"/>
+    <arg name="report" value="emacs"/>
+    <arg value="p"/>

    <rule ref="PSR1">
        <exclude name="Generic.Files.LineLength"/>
@ -18,23 +23,19 @@
        <exclude name="Generic.Files.LowercasedFilename.NotFound"/>
        <exclude name="Generic.PHP.ClosingPHPTag.NotFound"/>
        <exclude name="Generic.Files.EndFileNoNewline.Found"/>
-        <exclude name="Generic.Files.EndFileNoNewline.Found"/>
        <exclude name="Generic.Arrays.DisallowShortArraySyntax.Found"/>
        <exclude name="Generic.Functions.OpeningFunctionBraceKernighanRitchie.BraceOnNewLine"/>
        <exclude name="Generic.Classes.OpeningBraceSameLine.BraceOnNewLine"/>
        <exclude name="Generic.PHP.LowerCaseConstant.Found"/>
-        <exclude name="Generic.Formatting.SpaceAfterCast"/>
        <exclude name="Generic.Formatting.MultipleStatementAlignment.NotSameWarning"/>
        <exclude name="Generic.Commenting.DocComment.MissingShort"/>
        <exclude name="Generic.NamingConventions.AbstractClassNamePrefix.Missing"/>
        <exclude name="Generic.CodeAnalysis.ForLoopWithTestFunctionCall.NotAllowed"/>
        <exclude name="Generic.NamingConventions.InterfaceNameSuffix.Missing"/>
-        <exclude name="Generic.Commenting.Todo.TaskFound"/>
        <exclude name="Generic.CodeAnalysis.UnusedFunctionParameter.FoundInImplementedInterfaceAfterLastUse"/>
        <exclude name="Generic.CodeAnalysis.UnusedFunctionParameter.FoundInExtendedClassAfterLastUsed"/>
        <exclude name="Generic.CodeAnalysis.UnusedFunctionParameter.FoundInImplementedInterfaceAfterLastUsed"/>
-        <exclude name="Generic.Formatting.SpaceBeforeCast.NoSpace"/>
-        <exclude name="Generic.CodeAnalysis.UselessOverridingMethod.Found"/>
+        
        <exclude name="Squiz.Functions.MultiLineFunctionDeclaration.NewlineBeforeOpenBrace"/>
    </rule>

@ -50,4 +51,25 @@
            </property>
        </properties>
    </rule>
+
+    <rule ref="Generic.Formatting.SpaceAfterCast">
+        <properties>
+            <property name="spacing" value="0"/>
+        </properties>
+    </rule>
+
+    <!-- Do not allow unreachable code. -->
+    <rule ref="Squiz.PHP.NonExecutableCode"/>
+
+    <!-- Do not allow ambiguous conditions. -->
+    <rule ref="Generic.CodeAnalysis.RequireExplicitBooleanOperatorPrecedence"/>
+
+    <!-- The testing bootstrap file uses string concats to stop IDEs seeing the class aliases -->
+    <rule ref="Generic.Strings.UnnecessaryStringConcat" />
+
+    <!-- This test file specifically *needs* Windows line endings for testing purposes. -->
+    <rule ref="Generic.Files.LineEndings.InvalidEOLChar" />
+
+    <!-- Avoid false positive with this sniff detecting itself -->
+    <rule ref="Generic.Commenting.Todo"/>
 </ruleset>
--- a/.phplint.yml
+++ b/.phplint.yml
@ -1,12 +0,0 @@
-path:
-  - src/
-  - tests/
-  - benchmark/
-jobs: 10
-extensions:
-  - php
-exclude:
-  - vendor
-warning: true
-memory-limit: -1
-log-junit: "output/lint.xml"
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@ -0,0 +1,3 @@
+{
+    "php.version": "8.4"
+}
--- a/.woodpecker/test.yml
+++ b/.woodpecker/test.yml
@ -1,3 +1,5 @@
+when:
+  - event: [push, tag]
 steps:
  - name: requirements
    image: composer
@ -8,7 +10,7 @@ steps:
    commands:
      - php examples/3teams.php
      - php examples/basic.php
-  - name: dependencies
+  - name: test
    image: composer
    commands:
    - composer install
--- a/CodeStandard.md
+++ b/CodeStandard.md
--- a/benchmark/BasicBench.php
+++ b/benchmark/BasicBench.php
@ -10,9 +10,11 @@ use DNW\Skills\TrueSkill\FactorGraphTrueSkillCalculator;
 use DNW\Skills\GameInfo;
 use DNW\Skills\Player;
 use DNW\Skills\Team;
-use DNW\Skills\Teams;

-class BasicBench
+/**
+ * Basic Benchmarks.
+ */
+final class BasicBench
 {
    /**
     * To benchmark performance when using TwoPlayerTrueSkillCalculator
@ -39,9 +41,11 @@ class BasicBench

            $team1 = new Team($p1, $newRatings->getRating($p1));
            $team2 = new Team($p2, $newRatings->getRating($p2));
-
-            $newRatings->getRating($p1)->getConservativeRating();
-            $newRatings->getRating($p2)->getConservativeRating();
+            
+            ob_start();
+            echo $newRatings->getRating($p1)->getConservativeRating();
+            echo $newRatings->getRating($p2)->getConservativeRating();
+            ob_clean();
        }
    }

@ -71,8 +75,10 @@ class BasicBench
            $team1 = new Team($p1, $newRatings->getRating($p1));
            $team2 = new Team($p2, $newRatings->getRating($p2));

-            $newRatings->getRating($p1)->getConservativeRating();
-            $newRatings->getRating($p2)->getConservativeRating();
+            ob_start();
+            echo $newRatings->getRating($p1)->getConservativeRating();
+            echo $newRatings->getRating($p2)->getConservativeRating();
+            ob_clean();
        }
    }

@ -102,8 +108,10 @@ class BasicBench
            $team1 = new Team($p1, $newRatings->getRating($p1));
            $team2 = new Team($p2, $newRatings->getRating($p2));

-            $newRatings->getRating($p1)->getConservativeRating();
-            $newRatings->getRating($p2)->getConservativeRating();
+            ob_start();
+            echo $newRatings->getRating($p1)->getConservativeRating();
+            echo $newRatings->getRating($p2)->getConservativeRating();
+            ob_clean();
        }
    }

@ -136,9 +144,11 @@ class BasicBench
            $team2 = new Team($p2, $newRatings->getRating($p2));
            $team3 = new Team($p3, $newRatings->getRating($p3));

-            $newRatings->getRating($p1)->getConservativeRating();
-            $newRatings->getRating($p2)->getConservativeRating();
-            $newRatings->getRating($p3)->getConservativeRating();
+            ob_start();
+            echo $newRatings->getRating($p1)->getConservativeRating();
+            echo $newRatings->getRating($p2)->getConservativeRating();
+            echo $newRatings->getRating($p3)->getConservativeRating();
+            ob_clean();
        }
    }
 }
--- a/composer.json
+++ b/composer.json
@ -1,16 +1,19 @@
 {
  "name": "dnw/php-trueskill",
-  "description": "Trueskill implementation by Moserware updated for PHP 8.2",
-  "keywords": ["trueskill", "matchmaking", "ranking", "skill", "elo"],
+  "description": "Trueskill implementation by Moserware updated for PHP 8.4",
+  "keywords": [
+    "trueskill",
+    "matchmaking",
+    "ranking",
+    "skill",
+    "elo"
+  ],
  "require": {
-    "php": "^8.2"
+    "php": "^8.4"
  },
  "require-dev": {
-    "phpstan/phpstan": "^1.0",
-    "vimeo/psalm": "^5.21.1",
    "phpmetrics/phpmetrics": "^3.0-dev",
-    "phpunit/phpunit": "^10.5",
-    "psalm/plugin-phpunit": "^0.18.4",
+    "phpunit/phpunit": "^11.2",
    "rector/rector": "^1.0",
    "league/csv": "^9.0"
  },
@ -25,33 +28,35 @@
    }
  },
  "scripts": {
-    "test":          "phpunit",
-    "document":      "phpDocumentor", 
-    "benchmark":     "phpbench run --report=default --output=build-artifact",
-    "metrics":       "vendor/bin/phpmetrics --config=phpmetrics.json",
+    "test": "tools/phpunit",
+    "document": "tools/phpdocumentor",
+    "benchmark": "tools/phpbench run --report=default --output=build-artifact",
+    "metrics": "phpmetrics --config=phpmetrics.yml",
    "lint": [
-        "phplint",
-        "phpcs"
+      "tools/phpcbf",
+      "tools/phpcs",
+      "tools/phpmd src/,tests/,benchmark/,examples/ text phpmd.ruleset.xml"
    ],
    "analyze": [
-        "@analyze-phpstan",
-        "@analyze-psalm",
-        "@analyze-rector"
+      "@analyze-phpstan",
+      "@analyze-psalm",
+      "@analyze-rector"
    ],
-    "analyze-phpstan":"vendor/bin/phpstan analyze --error-format=raw",
-    "analyze-psalm":  "vendor/bin/psalm --no-cache --show-info=true",
-    "analyze-rector": "vendor/bin/rector --dry-run",
+    "analyze-phpstan": "tools/phpstan analyze --error-format=raw",
+    "analyze-psalm": "tools/psalm --show-info=true",
+    "analyze-rector": "rector --dry-run",
    "html": [
      "pandoc -s README.md -o output/README.html",
-      "pandoc -s docs/index.rst -o output/index.html"
+      "pandoc -s docs/index.rst -o output/index.html",
+      "tools/phpcs --generator=MarkDown | pandoc  -o output/CodeStandard.html --metadata title=\"Code Standard\""
    ],
    "all": [
      "@test",
-      "@document",
-      "@benchmark",
      "@lint",
      "@analyze",
+      "@document",
+      "@metrics",
      "@html"
    ]
  }
-}
+}
--- a/composer.lock
+++ b/composer.lock
--- a/docs/index.rst
+++ b/docs/index.rst
@ -30,14 +30,19 @@ Links
 * `Project README <README.html>`_
 * `API Documentations <docs/>`_
 * `CodeCoverage <coverage/>`_
-* `Metrics <metrics/>`_
 * `Test report <test/index.html>`_
-* `Mutation testing <mutation/>`_
+* `Mutation testing <mutation/infection.html>`_
+* `Code metrics <metrics/index.html>`_
+* `Code Standard <CodeStandard.html>`_
+* `Benchmark <benchmark.html>`_


 Standard Tools
 --------------
-* PHP8.3
+* PHP8.4
+
+Development Tools
+-------------------
 * PlantUML
 * GraphViz
 * Pandoc
@ -47,7 +52,5 @@ PHP Tools
 ---------
 For development Composer and the following packages are used (Recommended as Phars installed via Phive)

-* sudo phive install -g composer phpdocumentor infection phpcs phpcbf phploc phpbench 
-* sudo phive install -g overtrue/phplint --force-accept-unsigned
 * composer install
 * composer all
--- a/examples/3teams.php
+++ b/examples/3teams.php
@ -20,7 +20,7 @@ $team2 = new Team($p2, $gameInfo->getDefaultRating());
 $team3 = new Team($p3, $gameInfo->getDefaultRating());


-for($i = 0; $i < 5; ++$i) {
+for ($i = 0; $i < 5; ++$i) {
    echo "Iteration: " . $i . PHP_EOL;
    $teams = [$team1, $team2, $team3];

@ -32,10 +32,7 @@ for($i = 0; $i < 5; ++$i) {
    $team2 = new Team($p2, $newRatings->getRating($p2));
    $team3 = new Team($p3, $newRatings->getRating($p3));

-    echo "P1: ". $newRatings->getRating($p1)->getConservativeRating() . PHP_EOL;
-    echo "P2: ". $newRatings->getRating($p2)->getConservativeRating() . PHP_EOL;
-    echo "P3: ". $newRatings->getRating($p3)->getConservativeRating() . PHP_EOL;
+    echo "P1: " . $newRatings->getRating($p1)->getConservativeRating() . PHP_EOL;
+    echo "P2: " . $newRatings->getRating($p2)->getConservativeRating() . PHP_EOL;
+    echo "P3: " . $newRatings->getRating($p3)->getConservativeRating() . PHP_EOL;
 }
-
-
-
--- a/examples/basic.php
+++ b/examples/basic.php
@ -19,7 +19,7 @@ $team1 = new Team($p1, $gameInfo->getDefaultRating());
 $team2 = new Team($p2, $gameInfo->getDefaultRating());


-for($i = 0; $i < 5; ++$i) {
+for ($i = 0; $i < 5; ++$i) {
    echo "Iteration: " . $i . PHP_EOL;
    $teams = [$team1, $team2];

@ -30,9 +30,6 @@ for($i = 0; $i < 5; ++$i) {
    $team1 = new Team($p1, $newRatings->getRating($p1));
    $team2 = new Team($p2, $newRatings->getRating($p2));

-    echo "P1: ". $newRatings->getRating($p1)->getConservativeRating() . PHP_EOL;
-    echo "P2: ". $newRatings->getRating($p2)->getConservativeRating() . PHP_EOL;
+    echo "P1: " . $newRatings->getRating($p1)->getConservativeRating() . PHP_EOL;
+    echo "P2: " . $newRatings->getRating($p2)->getConservativeRating() . PHP_EOL;
 }
-
-
-
--- a/examples/motogp/goat.php
+++ b/examples/motogp/goat.php
@ -0,0 +1,90 @@
+<?php
+
+require __DIR__ . "/../../vendor/autoload.php";
+
+use League\Csv\Reader;
+use League\Csv\Statement;
+use DNW\Skills\TrueSkill\FactorGraphTrueSkillCalculator;
+use DNW\Skills\GameInfo;
+use DNW\Skills\Player;
+use DNW\Skills\Team;
+use DNW\Skills\Teams;
+
+//load the CSV document from a stream
+$stream = fopen('motogp.csv', 'r');
+$csv = Reader::createFromStream($stream);
+$csv->setDelimiter(',');
+$csv->setHeaderOffset(0);
+
+//build a statement
+$stmt = new Statement()->where(static fn (array $record): bool => $record['category'] == "MotoGP" ||  $record['category'] == "500cc");
+
+/**
+ * @var $riders Player[]
+ */
+$riders = [];
+//query your records from the document
+$records = $stmt->process($csv);
+
+$gameInfo = new GameInfo();
+$calculator = new FactorGraphTrueSkillCalculator();
+$first_record = $records->first();
+$year_race = $first_record['year'] . '_' . $first_record['sequence'] . '_' . $first_record['category'];
+
+$race_rate = [];
+foreach ($records as $record) {
+    if ($year_race !== $record['year'] . '_' . $record['sequence'] . '_' . $record['category']) {
+        //Calculate the old race
+        $newRatings = $calculator->calculateNewRatings($gameInfo, $teams, $pos);
+
+        //update ratings
+        $highest_rate = 0;
+        $highest_rider = "";
+        foreach ($riders as $rider) {
+            //echo $rider['P']->getId().": ". $newRatings->getRating($rider['P'])->getConservativeRating() . PHP_EOL;
+            $rider['T']->setRating($rider['P'], $newRatings->getRating($rider['P']));
+            if ($newRatings->getRating($rider['P'])->getConservativeRating() > $highest_rate) {
+                $highest_rate = $newRatings->getRating($rider['P'])->getConservativeRating();
+                $highest_rider = $rider['P']->getId();
+            }
+        }
+
+        echo sprintf('Highest rider: %s => %s', $highest_rider, $highest_rate) . PHP_EOL;
+
+        foreach ($global_riders as $r) {
+            $rate = $r['T']->getRating($r['P'])->getConservativeRating();
+
+            $race_rate[$year_race][$r['P']->getId()] = $rate;
+            if (! isset($top_rating[$r['P']->getId()]) || $top_rating[$r['P']->getId()] < $rate) {
+                $top_rating[$r['P']->getId()] = $rate;
+            }
+        }
+
+        //prepare for next race
+        $year_race = $record['year'] . '_' . $record['sequence'] . '_' . $record['category'];
+        $races[] = ['year' => $record['year'], 'race' => $record['sequence'], 'circuit' => $record['circuit_name']];
+        echo "New Race: " . $year_race . ' => ' . $record['circuit_name'] . PHP_EOL;
+        $riders = [];
+        $teams = [];
+        $pos = [];
+    }
+
+    //Is it a new rider?
+    if (! isset($global_riders[$record['rider']])) {
+        $global_riders[$record['rider']]['P'] = new Player($record['rider_name']);
+        $global_riders[$record['rider']]['T'] = new Team($global_riders[$record['rider']]['P'], $gameInfo->getDefaultRating());
+        //echo "New Rider: ". $record['rider'] . " => ".$global_riders[$record['rider']]['P']->getId().PHP_EOL;
+    }
+
+    $riders[] = $global_riders[$record['rider']];
+    $teams[] = $global_riders[$record['rider']]['T'];
+    
+    //Position or DNF?
+    $pos[] = $record['position'] >= 1 ? $record['position'] : end($pos);
+}
+
+echo "All time top score" . PHP_EOL;
+asort($top_rating);
+foreach ($top_rating as $n => $r) {
+    echo sprintf('%s => %s', $n, $r) . PHP_EOL;
+}
--- a/examples/motogp/motogp.csv
+++ b/examples/motogp/motogp.csv
--- a/infection.json5
+++ b/infection.json5
@ -1,8 +1,8 @@
 {
-    "$schema": "https://raw.githubusercontent.com/infection/infection/0.27.9/resources/schema.json",
+    "$schema": "https://raw.githubusercontent.com/infection/infection/0.29.6/resources/schema.json",
    "source": {
        "directories": [
-            "src"
+            "src/"
        ]
    },
    "logs": {
--- a/phpbench.json
+++ b/phpbench.json
@ -10,6 +10,5 @@
            "path": "output/benchmark.html",
            "title": "Benchmarking"
        }
-   }
-   
+   }   
 }
--- a/phpdoc.xml
+++ b/phpdoc.xml
@ -16,5 +16,5 @@
            </source>
        </api>
    </version>
-    <!--setting name="graphs.enabled" value="true"/-->
+    <setting name="graphs.enabled" value="true"/>
 </phpdocumentor>
--- a/phpmd.baseline.xml
+++ b/phpmd.baseline.xml
@ -0,0 +1,9 @@
+<?xml version="1.0"?>
+<phpmd-baseline>
+  <violation rule="PHPMD\Rule\Design\TooManyPublicMethods" file="src/Numerics/GaussianDistribution.php"/>
+  <violation rule="PHPMD\Rule\UnusedPrivateMethod" file="src/Numerics/GaussianDistribution.php" method="errorFunctionCumulativeTo"/>
+  <violation rule="PHPMD\Rule\UnusedPrivateMethod" file="src/Numerics/GaussianDistribution.php" method="inverseErrorFunctionCumulativeTo"/>
+  <violation rule="PHPMD\Rule\Design\WeightedMethodCount" file="src/Numerics/Matrix.php"/>
+  <violation rule="PHPMD\Rule\Design\CouplingBetweenObjects" file="src/TrueSkill/FactorGraphTrueSkillCalculator.php"/>
+  <violation rule="PHPMD\Rule\Design\CouplingBetweenObjects" file="src/TrueSkill/TrueSkillFactorGraph.php"/>
+</phpmd-baseline>
--- a/phpmd.ruleset.xml
+++ b/phpmd.ruleset.xml
@ -0,0 +1,49 @@
+<?xml version="1.0"?>
+<ruleset name="TrueSkill custom PHPMD rules"
+         xmlns="http://pmd.sf.net/ruleset/1.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://pmd.sf.net/ruleset/1.0.0
+                     http://pmd.sf.net/ruleset_xml_schema.xsd"
+         xsi:noNamespaceSchemaLocation="
+                     http://pmd.sf.net/ruleset_xml_schema.xsd">
+    <description>
+        TrueSkill custom PHPMD rules
+    </description>
+
+    <!-- Import the entire unused code rule set -->
+    <rule ref="rulesets/cleancode.xml">
+        <exclude name="StaticAccess" />
+        <exclude name="ElseExpression" />
+    </rule>
+    <rule ref="rulesets/codesize.xml" >
+        <exclude name="TooManyMethods" />
+        <exclude name="TooManyPublicMethods" />
+    </rule>
+    <rule ref="rulesets/codesize.xml/TooManyMethods">
+        <priority>1</priority>
+        <properties>
+            <property name="ignorepattern" value="#^(set|get|test)|test$#i" />
+        </properties>
+    </rule>
+    <rule ref="rulesets/codesize.xml/TooManyPublicMethods">
+        <priority>1</priority>
+        <properties>
+            <property name="ignorepattern" value="#^(set|get|test)|test$#i" />
+        </properties>
+    </rule>
+
+
+    <!--rule ref="rulesets/controversial.xml" /-->
+    <rule ref="rulesets/design.xml" />
+    <rule ref="rulesets/naming.xml" >
+        <exclude name="LongClassName" />
+        <exclude name="ShortClassName" />
+        <exclude name="ShortVariable" />
+        <exclude name="LongVariable" />
+        <exclude name="ShortMethodName" />
+    </rule>
+    <rule ref="rulesets/unusedcode.xml" />
+
+    <!-- Import entire naming rule set and exclude rules -->
+
+</ruleset>
--- a/phpmetrics.json
+++ b/phpmetrics.json
@ -1,21 +0,0 @@
-{
-    "composer": true,
-    "includes": [
-      "src"
-    ],
-    "excludes": [
-      "tests"
-    ],
-    "report": {
-      "html": "output/metrics/",
-      "json": "output/metrics/report.json"
-    },
-    "plugins": {
-      "git": {
-        "binary": "git"
-      },
-      "junit": {
-        "file": "output/test.xml"
-      }
-    }
-}
--- a/phpmetrics.yml
+++ b/phpmetrics.yml
@ -0,0 +1,18 @@
+---
+composer: true
+includes:
+    - src
+excludes:
+    - benchmark
+    - tests
+extensions:
+    - php
+report:
+  html: "output/metrics/"
+  json: "output/metrics/report.json"
+  violations: "/tmp/violations.xml"
+plugins:
+  git:
+    binary: git
+  junit:
+    file: "output/test.xml"
--- a/psalm.xml
+++ b/psalm.xml
@ -12,11 +12,5 @@
        <directory name="src"/>
        <directory name="tests"/>
        <directory name="benchmark"/>
-        <ignoreFiles>
-            <directory name="vendor"/>
-        </ignoreFiles>
    </projectFiles>
-    <plugins>
-        <pluginClass class="Psalm\PhpUnitPlugin\Plugin"/>
-    </plugins>
 </psalm>
--- a/src/FactorGraphs/Factor.php
+++ b/src/FactorGraphs/Factor.php
@ -15,7 +15,7 @@ abstract class Factor
     */
    private array $messages = [];

-    private readonly HashMap $messageToVariableBinding;
+    private readonly HashMap $msgToVariableBinding;

    /**
     * @var Variable[] $variables
@ -24,7 +24,7 @@ abstract class Factor

    protected function __construct()
    {
-        $this->messageToVariableBinding = new HashMap();
+        $this->msgToVariableBinding = new HashMap();
    }

    /**
@ -70,7 +70,7 @@ abstract class Factor
    {
        Guard::argumentIsValidIndex($messageIndex, count($this->messages), 'messageIndex');
        $message = $this->messages[$messageIndex];
-        $variable = $this->messageToVariableBinding->getValue($message);
+        $variable = $this->msgToVariableBinding->getValue($message);

        return $this->updateMessageVariable($message, $variable);
    }
@ -85,7 +85,7 @@ abstract class Factor
     */
    public function resetMarginals(): void
    {
-        $allValues = $this->messageToVariableBinding->getAllValues();
+        $allValues = $this->msgToVariableBinding->getAllValues();
        foreach ($allValues as $currentVariable) {
            $currentVariable->resetToPrior();
        }
@ -101,7 +101,7 @@ abstract class Factor
        Guard::argumentIsValidIndex($messageIndex, count($this->messages), 'messageIndex');

        $message = $this->messages[$messageIndex];
-        $variable = $this->messageToVariableBinding->getValue($message);
+        $variable = $this->msgToVariableBinding->getValue($message);

        return $this->sendMessageVariable($message, $variable);
    }
@ -112,7 +112,7 @@ abstract class Factor

    protected function createVariableToMessageBindingWithMessage(Variable $variable, Message $message): Message
    {
-        $this->messageToVariableBinding->setValue($message, $variable);
+        $this->msgToVariableBinding->setValue($message, $variable);
        $this->messages[] = $message;
        $this->variables[] = $variable;

--- a/src/FactorGraphs/FactorGraphLayer.php
+++ b/src/FactorGraphs/FactorGraphLayer.php
@ -17,14 +17,14 @@ abstract class FactorGraphLayer
    /**
     * @var array<int,array<int,Variable>>
     */
-    private array $outputVariablesGroups = [];
+    private array $outputVarGroups = [];

    /**
     * @var array<int,array<int,Variable>>
     */
    private array $inputVariablesGroups = [];

-    protected function __construct(private readonly TrueSkillFactorGraph $parentFactorGraph)
+    public function __construct(private readonly TrueSkillFactorGraph $parentFactorGraph)
    {
    }

@ -48,7 +48,7 @@ abstract class FactorGraphLayer
     */
    public function &getOutputVariablesGroups(): array
    {
-        return $this->outputVariablesGroups;
+        return $this->outputVarGroups;
    }

    /**
--- a/src/FactorGraphs/FactorList.php
+++ b/src/FactorGraphs/FactorList.php
@ -7,7 +7,7 @@ namespace DNW\Skills\FactorGraphs;
 /**
 * Helper class for computing the factor graph's normalization constant.
 */
-class FactorList
+final class FactorList
 {
    /**
     * @var Factor[] $list
@ -26,16 +26,16 @@ class FactorList
        $listCount = count($this->list);

        for ($i = 0; $i < $listCount; ++$i) {
-            $f = $this->list[$i];
+            $factor = $this->list[$i];

-            $numberOfMessages = $f->getNumberOfMessages();
+            $numberOfMessages = $factor->getNumberOfMessages();

            for ($j = 0; $j < $numberOfMessages; ++$j) {
-                $sumLogZ += $f->sendMessageIndex($j);
+                $sumLogZ += (float)$factor->sendMessageIndex($j);
            }
        }

-        $sumLogS = 0;
+        $sumLogS = 0.0;

        foreach ($list as &$currentFactor) {
            $sumLogS += $currentFactor->getLogNormalization();
--- a/src/FactorGraphs/KeyedVariable.php
+++ b/src/FactorGraphs/KeyedVariable.php
@ -4,7 +4,7 @@ declare(strict_types=1);

 namespace DNW\Skills\FactorGraphs;

-class KeyedVariable extends Variable
+final class KeyedVariable extends Variable
 {
    public function __construct(private readonly mixed $key, mixed $prior)
    {
--- a/src/FactorGraphs/Message.php
+++ b/src/FactorGraphs/Message.php
@ -6,7 +6,7 @@ namespace DNW\Skills\FactorGraphs;

 use DNW\Skills\Numerics\GaussianDistribution;

-class Message
+final class Message
 {
    public function __construct(private GaussianDistribution $value)
    {
--- a/src/FactorGraphs/ScheduleLoop.php
+++ b/src/FactorGraphs/ScheduleLoop.php
@ -4,12 +4,13 @@ declare(strict_types=1);

 namespace DNW\Skills\FactorGraphs;

-class ScheduleLoop extends Schedule
+final class ScheduleLoop extends Schedule
 {
    public function __construct(private readonly Schedule $scheduleToLoop, private readonly float $maxDelta)
    {
    }

+    #[\Override]
    public function visit(int $depth = -1, int $maxDepth = 0): float
    {
        $delta = $this->scheduleToLoop->visit($depth + 1, $maxDepth);
--- a/src/FactorGraphs/ScheduleSequence.php
+++ b/src/FactorGraphs/ScheduleSequence.php
@ -4,7 +4,7 @@ declare(strict_types=1);

 namespace DNW\Skills\FactorGraphs;

-class ScheduleSequence extends Schedule
+final class ScheduleSequence extends Schedule
 {
    /**
     * @param Schedule[] $schedules
@ -13,6 +13,7 @@ class ScheduleSequence extends Schedule
    {
    }

+    #[\Override]
    public function visit(int $depth = -1, int $maxDepth = 0): float
    {
        $maxDelta = 0;
--- a/src/FactorGraphs/ScheduleStep.php
+++ b/src/FactorGraphs/ScheduleStep.php
@ -4,12 +4,13 @@ declare(strict_types=1);

 namespace DNW\Skills\FactorGraphs;

-class ScheduleStep extends Schedule
+final class ScheduleStep extends Schedule
 {
    public function __construct(private readonly Factor $factor, private readonly int $index)
    {
    }

+    #[\Override]
    public function visit(int $depth = -1, int $maxDepth = 0): float
    {
        return $this->factor->updateMessageIndex($this->index);
--- a/src/FactorGraphs/Variable.php
+++ b/src/FactorGraphs/Variable.php
@ -10,7 +10,7 @@ class Variable
 {
    private mixed $value;

-    public function __construct(private GaussianDistribution $prior)
+    public function __construct(private readonly GaussianDistribution $prior)
    {
        $this->resetToPrior();
    }
--- a/src/FactorGraphs/VariableFactory.php
+++ b/src/FactorGraphs/VariableFactory.php
@ -4,22 +4,22 @@ declare(strict_types=1);

 namespace DNW\Skills\FactorGraphs;

-class VariableFactory
+final readonly class VariableFactory
 {
-    public function __construct(private \Closure $variablePriorInitializer)
+    public function __construct(private \Closure $varPriorInitializer)
    {
    }

    public function createBasicVariable(): Variable
    {
-        $initializer = $this->variablePriorInitializer;
+        $initializer = $this->varPriorInitializer;

        return new Variable($initializer());
    }

    public function createKeyedVariable(mixed $key): KeyedVariable
    {
-        $initializer = $this->variablePriorInitializer;
+        $initializer = $this->varPriorInitializer;

        return new KeyedVariable($key, $initializer());
    }
--- a/src/GameInfo.php
+++ b/src/GameInfo.php
@ -7,30 +7,30 @@ namespace DNW\Skills;
 /**
 * Parameters about the game for calculating the TrueSkill.
 */
-class GameInfo
+final readonly class GameInfo
 {
    /**
     * Default initial mean / 6
     */
-    private const DEFAULT_BETA = 4.1666666666666666666666666666667;
+    private const float DEFAULT_BETA = 4.1666666666666666666666666666667;

-    private const DEFAULT_DRAW_PROBABILITY = 0.10;
+    private const float DEFAULT_DRAW_PROBABILITY = 0.10;

    /**
     * Default initial mean / 300
     */
-    private const DEFAULT_DYNAMICS_FACTOR = 0.083333333333333333333333333333333;
+    private const float DEFAULT_DYNAMICS_FACTOR = 0.083333333333333333333333333333333;

-    private const DEFAULT_INITIAL_MEAN = 25.0;
+    private const float DEFAULT_INITIAL_MEAN = 25.0;

-    private const DEFAULT_INITIAL_STANDARD_DEVIATION = 8.3333333333333333333333333333333;
+    private const float DEFAULT_INITIAL_STANDARD_DEVIATION = 8.3333333333333333333333333333333;

    public function __construct(
-        private readonly float $initialMean = self::DEFAULT_INITIAL_MEAN,
-        private readonly float $initialStandardDeviation = self::DEFAULT_INITIAL_STANDARD_DEVIATION,
-        private readonly float $beta = self::DEFAULT_BETA,
-        private readonly float $dynamicsFactor = self::DEFAULT_DYNAMICS_FACTOR,
-        private readonly float $drawProbability = self::DEFAULT_DRAW_PROBABILITY
+        private float $initialMean = self::DEFAULT_INITIAL_MEAN,
+        private float $initialStdDev = self::DEFAULT_INITIAL_STANDARD_DEVIATION,
+        private float $beta = self::DEFAULT_BETA,
+        private float $dynamicsFactor = self::DEFAULT_DYNAMICS_FACTOR,
+        private float $drawProbability = self::DEFAULT_DRAW_PROBABILITY
    )
    {
    }
@ -42,7 +42,7 @@ class GameInfo

    public function getInitialStandardDeviation(): float
    {
-        return $this->initialStandardDeviation;
+        return $this->initialStdDev;
    }

    public function getBeta(): float
@ -62,6 +62,6 @@ class GameInfo

    public function getDefaultRating(): Rating
    {
-        return new Rating($this->initialMean, $this->initialStandardDeviation);
+        return new Rating($this->initialMean, $this->initialStdDev);
    }
 }
--- a/src/Guard.php
+++ b/src/Guard.php
@ -11,7 +11,7 @@ use Exception;
 *
 * @see http://www.moserware.com/2008/01/borrowing-ideas-from-3-interesting.html
 */
-class Guard
+final class Guard
 {
    public static function argumentIsValidIndex(int $index, int $count, string $parameterName): void
    {
@ -23,7 +23,7 @@ class Guard
    public static function argumentInRangeInclusive(float $value, float $min, float $max, string $parameterName): void
    {
        if (($value < $min) || ($value > $max)) {
-            throw new Exception($parameterName . ' is not in the valid range [' . $min . ', ' . $max . ']');
+            throw new Exception($parameterName . ' is not in the valid range [' . (int)$min . ', ' . (int)$max . ']');
        }
    }
 }
--- a/src/HashMap.php
+++ b/src/HashMap.php
@ -7,15 +7,15 @@ namespace DNW\Skills;
 /**
 * Basic hashmap that supports object keys.
 */
-class HashMap
+final class HashMap
 {
    /**
-     * @var mixed[] $hashToValue
+     * @var mixed[] $hashToValue Store the hash to value mapping.
     */
    private array $hashToValue = [];

    /**
-     * @var mixed[] $hashToKey
+     * @var mixed[] $hashToKey Store the hash to original key mapping.
     */
    private array $hashToKey = [];

--- a/src/Numerics/BasicMath.php
+++ b/src/Numerics/BasicMath.php
@ -10,24 +10,24 @@ namespace DNW\Skills\Numerics;
 * @author    Jeff Moser <jeff@moserware.com>
 * @copyright 2010 Jeff Moser
 */
-class BasicMath
+final class BasicMath
 {
    /**
-     * Squares the input (x^2 = x * x)
+     * Squares the input (input^2 = input * input)
     *
-     * @param $x Value to square (x)
+     * @param $input Value to square (input)
     *
-     * @return float The squared value (x^2)
+     * @return float The squared value (input^2)
     */
-    public static function square(float $x): float
+    public static function square(float $input): float
    {
-        return $x * $x;
+        return $input * $input;
    }

    /**
     * Sums the items in $itemsToSum
     *
-     * @param mixed[]    $itemsToSum The items to sum,
+     * @param mixed[]    $itemsToSum The items to sum.
     * @param \Closure $callback   The function to apply to each array element before summing.
     *
     * @return float The sum.
--- a/src/Numerics/GaussianDistribution.php
+++ b/src/Numerics/GaussianDistribution.php
@ -10,11 +10,11 @@ namespace DNW\Skills\Numerics;
 * @author    Jeff Moser <jeff@moserware.com>
 * @copyright 2010 Jeff Moser
 */
-class GaussianDistribution
+final class GaussianDistribution
 {
-    private const DEFAULT_STANDARD_DEVIATION = 1.0;
+    private const float DEFAULT_STANDARD_DEVIATION = 1.0;

-    private const DEFAULT_MEAN = 0.0;
+    private const float DEFAULT_MEAN = 0.0;

    /**
     * Square Root 2π.
@ -23,7 +23,7 @@ class GaussianDistribution
     *
     * @link https://www.wolframalpha.com/input?i=sqrt%282*pi%29 Source of value
     */
-    private const M_SQRT_2_PI = 2.5066282746310005024157652848110452530069867406099383166299235763;
+    private const float M_SQRT_2_PI = 2.5066282746310005024157652848110452530069867406099383166299235763;

    /**
     * Log of Square Root 2π.
@ -32,10 +32,11 @@ class GaussianDistribution
     *
     * @link https://www.wolframalpha.com/input?i=log%28sqrt%282*pi%29%29 Source of value
     */
-    private const M_LOG_SQRT_2_PI = 0.9189385332046727417803297364056176398613974736377834128171515404;
+    private const float M_LOG_SQRT_2_PI = 0.9189385332046727417803297364056176398613974736377834128171515404;

-    // precision and precisionMean are used because they make multiplying and dividing simpler
-    // (see the accompanying math paper for more details)
+    /**
+     * Precision and precisionMean are used because they make multiplying and dividing simpler.
+     */
    private float $precision = 1.0;

    private float $precisionMean = 0.0;
@ -55,7 +56,6 @@ class GaussianDistribution
            $this->precisionMean = $this->precision * $this->mean;
        } else {
            $this->precision = \INF;
-
            $this->precisionMean = $this->mean == 0 ? 0 : \INF;
        }
    }
@ -172,10 +172,10 @@ class GaussianDistribution
        $meanDifference = $numerator->mean - $denominator->mean;

        return log($denominator->variance) + self::M_LOG_SQRT_2_PI - log($varianceDifference) / 2.0 +
-        BasicMath::square($meanDifference) / (2 * $varianceDifference);
+        BasicMath::square($meanDifference) / (2.0 * $varianceDifference);
    }

-    public static function at(float $x, float $mean = 0.0, float $standardDeviation = 1.0): float
+    public static function at(float $var, float $mean = 0.0, float $standardDeviation = 1.0): float
    {
        // See http://mathworld.wolfram.com/NormalDistribution.html
        //                1              -(x-mean)^2 / (2*stdDev^2)
@ -183,25 +183,25 @@ class GaussianDistribution
        //        stdDev * sqrt(2*pi)

        $multiplier = 1.0 / ($standardDeviation * self::M_SQRT_2_PI);
-        $expPart = exp((-1.0 * BasicMath::square($x - $mean)) / (2 * BasicMath::square($standardDeviation)));
+        $expPart = exp((-1.0 * BasicMath::square($var - $mean)) / (2.0 * BasicMath::square($standardDeviation)));

        return $multiplier * $expPart;
    }

-    public static function cumulativeTo(float $x): float
+    public static function cumulativeTo(float $var): float
    {
-        $result = GaussianDistribution::errorFunctionCumulativeTo(-M_SQRT1_2 * $x);
+        $result = GaussianDistribution::errorFunctionCumulativeTo(-M_SQRT1_2 * $var);

        return 0.5 * $result;
    }

-    private static function errorFunctionCumulativeTo(float $x): float
+    private static function errorFunctionCumulativeTo(float $var): float
    {
        // Derived from page 265 of Numerical Recipes 3rd Edition
-        $z = abs($x);
+        $z = abs($var);

        $t = 2.0 / (2.0 + $z);
-        $ty = 4 * $t - 2;
+        $ty = 4.0 * $t - 2.0;

        $coefficients = [
            -1.3026537197817094,
@ -246,7 +246,7 @@ class GaussianDistribution

        $ans = $t * exp(-$z * $z + 0.5 * ($coefficients[0] + $ty * $d) - $dd);

-        return ($x >= 0.0) ? $ans : (2.0 - $ans);
+        return ($var >= 0.0) ? $ans : (2.0 - $ans);
    }

    private static function inverseErrorFunctionCumulativeTo(float $p): float
@ -260,8 +260,8 @@ class GaussianDistribution
            return 100;
        }

-        $pp = ($p < 1.0) ? $p : 2 - $p;
-        $t = sqrt(-2 * log($pp / 2.0)); // Initial guess
+        $pp = ($p < 1.0) ? $p : 2.0 - $p;
+        $t = sqrt(-2.0 * log($pp / 2.0)); // Initial guess
        $x = -M_SQRT1_2 * ((2.30753 + $t * 0.27061) / (1.0 + $t * (0.99229 + $t * 0.04481)) - $t);

        for ($j = 0; $j < 2; ++$j) {
@ -272,9 +272,9 @@ class GaussianDistribution
        return ($p < 1.0) ? $x : -$x;
    }

-    public static function inverseCumulativeTo(float $x, float $mean = 0.0, float $standardDeviation = 1.0): float
+    public static function inverseCumulativeTo(float $var, float $mean = 0.0, float $standardDeviation = 1.0): float
    {
        // From numerical recipes, page 320
-        return $mean - M_SQRT2 * $standardDeviation * GaussianDistribution::inverseErrorFunctionCumulativeTo(2 * $x);
+        return $mean - M_SQRT2 * $standardDeviation * GaussianDistribution::inverseErrorFunctionCumulativeTo(2.0 * $var);
    }
 }
--- a/src/Numerics/IdentityMatrix.php
+++ b/src/Numerics/IdentityMatrix.php
@ -4,7 +4,7 @@ declare(strict_types=1);

 namespace DNW\Skills\Numerics;

-class IdentityMatrix extends DiagonalMatrix
+final class IdentityMatrix extends DiagonalMatrix
 {
    public function __construct(int $rows)
    {
--- a/src/Numerics/Matrix.php
+++ b/src/Numerics/Matrix.php
@ -8,7 +8,7 @@ use Exception;

 class Matrix
 {
-    public const ERROR_TOLERANCE = 0.0000000001;
+    public const float ERROR_TOLERANCE = 0.0000000001;

    /**
     * @param array<int,array<int,float>> $matrixRowData
@ -60,13 +60,34 @@ class Matrix
        return $this->columnCount;
    }

-    public function getValue(int $row, int $col): float|int
+    private function checkRowCol(int $row, int $col): void
    {
+        if ($row < 0) {
+            throw new Exception("Row negative");
+        }
+
+        if ($row >= $this->getRowCount()) {
+            throw new Exception("Row beyond range");
+        }
+
+        if ($col < 0) {
+            throw new Exception("Column negative");
+        }
+
+        if ($col >= $this->getColumnCount()) {
+            throw new Exception("Column beyond range");
+        }
+    }
+
+    public function getValue(int $row, int $col): float
+    {
+        $this->checkRowCol($row, $col);
        return $this->matrixRowData[$row][$col];
    }

    public function setValue(int $row, int $col, float|int $value): void
    {
+        $this->checkRowCol($row, $col);
        $this->matrixRowData[$row][$col] = $value;
    }

@ -76,10 +97,10 @@ class Matrix
        $transposeMatrix = [];

        $rowMatrixData = $this->matrixRowData;
-        for ($currentRowTransposeMatrix = 0; $currentRowTransposeMatrix < $this->columnCount; ++$currentRowTransposeMatrix) {
-            for ($currentColumnTransposeMatrix = 0; $currentColumnTransposeMatrix < $this->rowCount; ++$currentColumnTransposeMatrix) {
-                $transposeMatrix[$currentRowTransposeMatrix][$currentColumnTransposeMatrix] =
-                    $rowMatrixData[$currentColumnTransposeMatrix][$currentRowTransposeMatrix];
+        for ($curRowTransposeMx = 0; $curRowTransposeMx < $this->columnCount; ++$curRowTransposeMx) {
+            for ($curColTransposeMx = 0; $curColTransposeMx < $this->rowCount; ++$curColTransposeMx) {
+                $transposeMatrix[$curRowTransposeMx][$curColTransposeMx] =
+                    $rowMatrixData[$curColTransposeMx][$curRowTransposeMx];
            }
        }

@ -100,7 +121,7 @@ class Matrix

        if ($this->rowCount == 1) {
            // Really happy path :)
-            return $this->matrixRowData[0][0];
+            return $this->getValue(0, 0);
        }

        if ($this->rowCount == 2) {
@ -109,10 +130,10 @@ class Matrix
            // | a b |
            // | c d |
            // The determinant is ad - bc
-            $a = $this->matrixRowData[0][0];
-            $b = $this->matrixRowData[0][1];
-            $c = $this->matrixRowData[1][0];
-            $d = $this->matrixRowData[1][1];
+            $a = $this->getValue(0, 0);
+            $b = $this->getValue(0, 1);
+            $c = $this->getValue(1, 0);
+            $d = $this->getValue(1, 1);

            return $a * $d - $b * $c;
        }
@ -127,7 +148,7 @@ class Matrix

        // I expand along the first row
        for ($currentColumn = 0; $currentColumn < $this->columnCount; ++$currentColumn) {
-            $firstRowColValue = $this->matrixRowData[0][$currentColumn];
+            $firstRowColValue = $this->getValue(0, $currentColumn);
            $cofactor = $this->getCofactor(0, $currentColumn);
            $itemToAdd = $firstRowColValue * $cofactor;
            $result += $itemToAdd;
@ -152,10 +173,10 @@ class Matrix
            // | d -b |
            // | -c a |

-            $a = $this->matrixRowData[0][0];
-            $b = $this->matrixRowData[0][1];
-            $c = $this->matrixRowData[1][0];
-            $d = $this->matrixRowData[1][1];
+            $a = $this->getValue(0, 0);
+            $b = $this->getValue(0, 1);
+            $c = $this->getValue(1, 0);
+            $d = $this->getValue(1, 1);

            return new SquareMatrix(
                $d,
@ -180,7 +201,7 @@ class Matrix
    public function getInverse(): Matrix|SquareMatrix
    {
        if (($this->rowCount == 1) && ($this->columnCount == 1)) {
-            return new SquareMatrix(1.0 / $this->matrixRowData[0][0]);
+            return new SquareMatrix(1.0 / $this->getValue(0, 0));
        }

        // Take the simple approach:
@ -191,7 +212,7 @@ class Matrix
        return self::scalarMultiply($determinantInverse, $adjugate);
    }

-    public static function scalarMultiply(float|int $scalarValue, Matrix $matrix): Matrix
+    public static function scalarMultiply(float $scalarValue, Matrix $matrix): Matrix
    {
        $rows = $matrix->getRowCount();
        $columns = $matrix->getColumnCount();
@ -244,7 +265,7 @@ class Matrix

        for ($currentRow = 0; $currentRow < $resultRows; ++$currentRow) {
            for ($currentColumn = 0; $currentColumn < $resultColumns; ++$currentColumn) {
-                $productValue = 0;
+                $productValue = 0.0;

                for ($vectorIndex = 0; $vectorIndex < $left->getColumnCount(); ++$vectorIndex) {
                    $leftValue = $left->getValue($currentRow, $vectorIndex);
@ -262,6 +283,7 @@ class Matrix

    private function getMinorMatrix(int $rowToRemove, int $columnToRemove): Matrix
    {
+        $this->checkRowCol($rowToRemove, $columnToRemove);
        // See http://en.wikipedia.org/wiki/Minor_(linear_algebra)

        // I'm going to use a horribly naïve algorithm... because I can :)
@ -281,7 +303,7 @@ class Matrix
                    continue;
                }

-                $result[$actualRow][$actualCol] = $this->matrixRowData[$currentRow][$currentColumn];
+                $result[$actualRow][$actualCol] = $this->getValue($currentRow, $currentColumn);

                ++$actualCol;
            }
@ -294,6 +316,7 @@ class Matrix

    public function getCofactor(int $rowToRemove, int $columnToRemove): float
    {
+        $this->checkRowCol($rowToRemove, $columnToRemove);
        // See http://en.wikipedia.org/wiki/Cofactor_(linear_algebra) for details
        // REVIEW: should things be reversed since I'm 0 indexed?
        $sum = $rowToRemove + $columnToRemove;
@ -316,7 +339,7 @@ class Matrix
            for ($currentColumn = 0; $currentColumn < $this->columnCount; ++$currentColumn) {
                $delta =
                    abs(
-                        $this->matrixRowData[$currentRow][$currentColumn] -
+                        $this->getValue($currentRow, $currentColumn) -
                        $otherMatrix->getValue($currentRow, $currentColumn)
                    );

--- a/src/Numerics/SquareMatrix.php
+++ b/src/Numerics/SquareMatrix.php
@ -4,7 +4,7 @@ declare(strict_types=1);

 namespace DNW\Skills\Numerics;

-class SquareMatrix extends Matrix
+final class SquareMatrix extends Matrix
 {
    public function __construct(float|int ...$allValues)
    {
--- a/src/Numerics/Vector.php
+++ b/src/Numerics/Vector.php
@ -4,7 +4,7 @@ declare(strict_types=1);

 namespace DNW\Skills\Numerics;

-class Vector extends Matrix
+final class Vector extends Matrix
 {
    /**
     * @param float[] $vectorValues
--- a/src/PartialPlay.php
+++ b/src/PartialPlay.php
@ -4,18 +4,18 @@ declare(strict_types=1);

 namespace DNW\Skills;

-class PartialPlay
+final class PartialPlay
 {
    public static function getPartialPlayPercentage(Player $player): float
    {
-        $partialPlayPercentage = $player->getPartialPlayPercentage();
+        $partialPlayPct = $player->getPartialPlayPercentage();

        // HACK to get around bug near 0
-        $smallestPercentage = 0.0001;
-        if ($partialPlayPercentage < $smallestPercentage) {
-            return $smallestPercentage;
+        $smallestPct = 0.0001;
+        if ($partialPlayPct < $smallestPct) {
+            return $smallestPct;
        }

-        return $partialPlayPercentage;
+        return $partialPlayPct;
    }
 }
--- a/src/Player.php
+++ b/src/Player.php
@ -7,33 +7,39 @@ namespace DNW\Skills;
 /**
 * Represents a player who has a Rating.
 */
-class Player implements ISupportPartialPlay, ISupportPartialUpdate
+final readonly class Player implements ISupportPartialPlay, ISupportPartialUpdate
 {
-    private const DEFAULT_PARTIAL_PLAY_PERCENTAGE = 1.0; // = 100% play time
+    private const float DEFAULT_PARTIAL_PLAY_PERCENTAGE = 1.0; // = 100% play time

-    private const DEFAULT_PARTIAL_UPDATE_PERCENTAGE = 1.0;
+    private const float DEFAULT_PARTIAL_UPDATE_PERCENTAGE = 1.0;

-    private readonly float $PartialPlayPercentage;
+    /**
+     * @var float The weight percentage to give this player when calculating a new rank.
+     */
+    private float $PartialPlayPct;

-    private readonly float $PartialUpdatePercentage;
+    /**
+     * @var float Indicated how much of a skill update a player should receive where 0 represents no update and 1.0 represents 100% of the update.
+     */
+    private float $PartialUpdatePct;

    /**
     * Constructs a player.
     *
-     * @param string|int $Id                      The identifier for the player, such as a name.
-     * @param float $partialPlayPercentage   The weight percentage to give this player when calculating a new rank.
-     * @param float $partialUpdatePercentage Indicated how much of a skill update a player should receive where 0 represents no update and 1.0 represents 100% of the update.
+     * @param string|int $Id          The identifier for the player, such as a name.
+     * @param float $partialPlayPct   The weight percentage to give this player when calculating a new rank.
+     * @param float $partialUpdatePct Indicated how much of a skill update a player should receive where 0 represents no update and 1.0 represents 100% of the update.
     */
    public function __construct(
-        private readonly mixed $Id,
-        float $partialPlayPercentage = self::DEFAULT_PARTIAL_PLAY_PERCENTAGE,
-        float $partialUpdatePercentage = self::DEFAULT_PARTIAL_UPDATE_PERCENTAGE
+        private mixed $Id,
+        float $partialPlayPct = self::DEFAULT_PARTIAL_PLAY_PERCENTAGE,
+        float $partialUpdatePct = self::DEFAULT_PARTIAL_UPDATE_PERCENTAGE
    )
    {
-        Guard::argumentInRangeInclusive($partialPlayPercentage, 0.0, 1.0, 'partialPlayPercentage');
-        Guard::argumentInRangeInclusive($partialUpdatePercentage, 0, 1.0, 'partialUpdatePercentage');
-        $this->PartialPlayPercentage = $partialPlayPercentage;
-        $this->PartialUpdatePercentage = $partialUpdatePercentage;
+        Guard::argumentInRangeInclusive($partialPlayPct, 0.0, 1.0, 'partialPlayPercentage');
+        Guard::argumentInRangeInclusive($partialUpdatePct, 0, 1.0, 'partialUpdatePercentage');
+        $this->PartialPlayPct = $partialPlayPct;
+        $this->PartialUpdatePct = $partialUpdatePct;
    }

    /**
@ -47,16 +53,18 @@ class Player implements ISupportPartialPlay, ISupportPartialUpdate
    /**
     * Indicates the percent of the time the player should be weighted where 0.0 indicates the player didn't play and 1.0 indicates the player played 100% of the time.
     */
+    #[\Override]
    public function getPartialPlayPercentage(): float
    {
-        return $this->PartialPlayPercentage;
+        return $this->PartialPlayPct;
    }

    /**
     * Indicated how much of a skill update a player should receive where 0.0 represents no update and 1.0 represents 100% of the update.
     */
+    #[\Override]
    public function getPartialUpdatePercentage(): float
    {
-        return $this->PartialUpdatePercentage;
+        return $this->PartialUpdatePct;
    }
 }
--- a/src/PlayersRange.php
+++ b/src/PlayersRange.php
@ -6,6 +6,6 @@ namespace DNW\Skills;

 use DNW\Skills\Numerics\Range;

-class PlayersRange extends Range
+final class PlayersRange extends Range
 {
 }
--- a/src/RankSorter.php
+++ b/src/RankSorter.php
@ -7,7 +7,7 @@ namespace DNW\Skills;
 /**
 * Helper class to sort ranks in non-decreasing order.
 */
-class RankSorter
+final class RankSorter
 {
    /**
     * Performs an in-place sort of the items in according to the ranks in non-decreasing order.
--- a/src/Rating.php
+++ b/src/Rating.php
@ -9,18 +9,18 @@ use DNW\Skills\Numerics\GaussianDistribution;
 /**
 * Container for a player's rating.
 */
-class Rating
+final readonly class Rating
 {
-    private const CONSERVATIVE_STANDARD_DEVIATION_MULTIPLIER = 3;
+    private const float CONSERVATIVE_STANDARD_DEVIATION_MULTIPLIER = 3;

    /**
     * Constructs a rating.
     *
     * @param float     $mean                                    The statistical mean value of the rating (also known as mu).
     * @param float     $standardDeviation                       The standard deviation of the rating (also known as s).
-     * @param float|int $conservativeStandardDeviationMultiplier optional The number of standardDeviations to subtract from the mean to achieve a conservative rating.
+     * @param float     $conservativeStandardDeviationMultiplier optional The number of standardDeviations to subtract from the mean to achieve a conservative rating.
     */
-    public function __construct(private readonly float $mean, private readonly float $standardDeviation, private readonly float|int $conservativeStandardDeviationMultiplier = self::CONSERVATIVE_STANDARD_DEVIATION_MULTIPLIER)
+    public function __construct(private float $mean, private float $standardDeviation, private float $conservativeStandardDeviationMultiplier = self::CONSERVATIVE_STANDARD_DEVIATION_MULTIPLIER)
    {
    }

--- a/src/RatingContainer.php
+++ b/src/RatingContainer.php
@ -6,6 +6,9 @@ namespace DNW\Skills;

 class RatingContainer
 {
+    /**
+     * Link Player to a Rating using a hash map.
+     */
    private readonly HashMap $playerToRating;

    public function __construct()
--- a/src/SkillCalculator.php
+++ b/src/SkillCalculator.php
@ -11,6 +11,12 @@ use Exception;
 */
 abstract class SkillCalculator
 {
+    public const int NONE = 0x00;
+
+    public const int PARTIAL_PLAY = 0x01;
+
+    public const int PARTIAL_UPDATE = 0x02;
+
    protected function __construct(
        private readonly int $supportedOptions,
        private readonly TeamsRange $totalTeamsAllowed,
@ -46,7 +52,7 @@ abstract class SkillCalculator

    public function isSupported(int $option): bool
    {
-        return (bool)($this->supportedOptions & $option) == $option;
+        return ($this->supportedOptions & $option) === $option;
    }

    /**
@ -58,7 +64,7 @@ abstract class SkillCalculator
    }

    /**
-     * @param array<\DNW\Skills\Team> $teams
+     * @param Team[] $teams
     *
     * @throws \Exception
     */
--- a/src/SkillCalculatorSupportedOptions.php
+++ b/src/SkillCalculatorSupportedOptions.php
@ -1,14 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace DNW\Skills;
-
-class SkillCalculatorSupportedOptions
-{
-    public const NONE = 0x00;
-
-    public const PARTIAL_PLAY = 0x01;
-
-    public const PARTIAL_UPDATE = 0x02;
-}
--- a/src/Team.php
+++ b/src/Team.php
@ -4,9 +4,9 @@ declare(strict_types=1);

 namespace DNW\Skills;

-class Team extends RatingContainer
+final class Team extends RatingContainer
 {
-    public function __construct(Player $player = NULL, Rating $rating = NULL)
+    public function __construct(?Player $player = NULL, ?Rating $rating = NULL)
    {
        parent::__construct();
        if (! $player instanceof Player) {
--- a/src/TeamsRange.php
+++ b/src/TeamsRange.php
@ -6,6 +6,6 @@ namespace DNW\Skills;

 use DNW\Skills\Numerics\Range;

-class TeamsRange extends Range
+final class TeamsRange extends Range
 {
 }
--- a/src/TrueSkill/DrawMargin.php
+++ b/src/TrueSkill/DrawMargin.php
@ -18,6 +18,6 @@ final class DrawMargin
        //
        // margin = inversecdf((draw probability + 1)/2) * sqrt(n1+n2) * beta
        // n1 and n2 are the number of players on each team
-        return GaussianDistribution::inverseCumulativeTo(.5 * ($drawProbability + 1), 0, 1) * M_SQRT2 * $beta;
+        return GaussianDistribution::inverseCumulativeTo(0.5 * ($drawProbability + 1.0), 0.0, 1.0) * M_SQRT2 * $beta;
    }
 }
--- a/src/TrueSkill/FactorGraphTrueSkillCalculator.php
+++ b/src/TrueSkill/FactorGraphTrueSkillCalculator.php
@ -14,7 +14,6 @@ use DNW\Skills\PartialPlay;
 use DNW\Skills\PlayersRange;
 use DNW\Skills\RankSorter;
 use DNW\Skills\SkillCalculator;
-use DNW\Skills\SkillCalculatorSupportedOptions;
 use DNW\Skills\Team;
 use DNW\Skills\TeamsRange;
 use DNW\Skills\RatingContainer;
@ -23,16 +22,17 @@ use DNW\Skills\Rating;
 /**
 * Calculates TrueSkill using a full factor graph.
 */
-class FactorGraphTrueSkillCalculator extends SkillCalculator
+final class FactorGraphTrueSkillCalculator extends SkillCalculator
 {
    public function __construct()
    {
-        parent::__construct(SkillCalculatorSupportedOptions::PARTIAL_PLAY | SkillCalculatorSupportedOptions::PARTIAL_UPDATE, TeamsRange::atLeast(2), PlayersRange::atLeast(1));
+        parent::__construct(SkillCalculator::PARTIAL_PLAY | SkillCalculator::PARTIAL_UPDATE, TeamsRange::atLeast(2), PlayersRange::atLeast(1));
    }

    /**
     * {@inheritdoc}
     */
+    #[\Override]
    public function calculateNewRatings(
        GameInfo $gameInfo,
        array $teams,
@ -55,6 +55,7 @@ class FactorGraphTrueSkillCalculator extends SkillCalculator
    /**
     * {@inheritdoc}
     */
+    #[\Override]
    public function calculateMatchQuality(GameInfo $gameInfo, array $teams): float
    {
        // We need to create the A matrix which is the player team assigments.
@ -172,7 +173,8 @@ class FactorGraphTrueSkillCalculator extends SkillCalculator

        $currentColumn = 0;

-        for ($i = 0; $i < count($teamAssignmentsList) - 1; ++$i) {
+        $teamCnt = count($teamAssignmentsList);
+        for ($i = 0; $i < $teamCnt - 1; ++$i) {
            $currentTeam = $teamAssignmentsList[$i];

            // Need to add in 0's for all the previous players, since they're not
@ -190,7 +192,7 @@ class FactorGraphTrueSkillCalculator extends SkillCalculator
            $nextTeam = $teamAssignmentsList[$i + 1];
            foreach ($nextTeam->getAllPlayers() as $nextTeamPlayer) {
                // Add a -1 * playing time to represent the difference
-                $playerAssignments[$currentColumn][] = -1 * PartialPlay::getPartialPlayPercentage($nextTeamPlayer);
+                $playerAssignments[$currentColumn][] = -1.0 * PartialPlay::getPartialPlayPercentage($nextTeamPlayer);
                --$rowsRemaining;
            }

--- a/src/TrueSkill/Factors/GaussianFactor.php
+++ b/src/TrueSkill/Factors/GaussianFactor.php
@ -14,6 +14,7 @@ abstract class GaussianFactor extends Factor
    /**
     * Sends the factor-graph message with and returns the log-normalization constant.
     */
+    #[\Override]
    protected function sendMessageVariable(Message $message, Variable $variable): float|int
    {
        $marginal = $variable->getValue();
@ -24,6 +25,7 @@ abstract class GaussianFactor extends Factor
        return $logZ;
    }

+    #[\Override]
    public function createVariableToMessageBinding(Variable $variable): Message
    {
        $newDistribution = GaussianDistribution::fromPrecisionMean(0, 0);
--- a/src/TrueSkill/Factors/GaussianGreaterThanFactor.php
+++ b/src/TrueSkill/Factors/GaussianGreaterThanFactor.php
@ -14,7 +14,7 @@ use DNW\Skills\TrueSkill\TruncatedGaussianCorrectionFunctions;
 *
 * See the accompanying math paper for more details.
 */
-class GaussianGreaterThanFactor extends GaussianFactor
+final class GaussianGreaterThanFactor extends GaussianFactor
 {
    public function __construct(private readonly float $epsilon, Variable $variable)
    {
@ -22,6 +22,7 @@ class GaussianGreaterThanFactor extends GaussianFactor
        $this->createVariableToMessageBinding($variable);
    }

+    #[\Override]
    public function getLogNormalization(): float
    {
        $vars = $this->getVariables();
@ -42,6 +43,7 @@ class GaussianGreaterThanFactor extends GaussianFactor
        );
    }

+    #[\Override]
    protected function updateMessageVariable(Message $message, Variable $variable): float
    {
        $oldMarginal = clone $variable->getValue();
--- a/src/TrueSkill/Factors/GaussianLikelihoodFactor.php
+++ b/src/TrueSkill/Factors/GaussianLikelihoodFactor.php
@ -15,7 +15,7 @@ use Exception;
 *
 * See the accompanying math paper for more details.
 */
-class GaussianLikelihoodFactor extends GaussianFactor
+final class GaussianLikelihoodFactor extends GaussianFactor
 {
    private readonly float $precision;

@ -28,10 +28,11 @@ class GaussianLikelihoodFactor extends GaussianFactor
        $this->createVariableToMessageBinding($variable2);
    }

+    #[\Override]
    public function getLogNormalization(): float
    {
        /**
- * @var KeyedVariable[]|mixed $vars
+ * @var KeyedVariable[] $vars
 */
        $vars = $this->getVariables();
        /**
@ -60,9 +61,9 @@ class GaussianLikelihoodFactor extends GaussianFactor
            $a * ($marginal2->getPrecision() - $message2Value->getPrecision())
        );

-        $oldMarginalWithoutMessage = GaussianDistribution::divide($marginal1, $message1Value);
+        $oldMarginalWithoutMsg = GaussianDistribution::divide($marginal1, $message1Value);

-        $newMarginal = GaussianDistribution::multiply($oldMarginalWithoutMessage, $newMessage);
+        $newMarginal = GaussianDistribution::multiply($oldMarginalWithoutMsg, $newMessage);

        // Update the message and marginal

@ -73,6 +74,7 @@ class GaussianLikelihoodFactor extends GaussianFactor
        return GaussianDistribution::subtract($newMarginal, $marginal1);
    }

+    #[\Override]
    public function updateMessageIndex(int $messageIndex): float
    {
        $messages = $this->getMessages();
--- a/src/TrueSkill/Factors/GaussianPriorFactor.php
+++ b/src/TrueSkill/Factors/GaussianPriorFactor.php
@ -13,7 +13,7 @@ use DNW\Skills\Numerics\GaussianDistribution;
 *
 * See the accompanying math paper for more details.
 */
-class GaussianPriorFactor extends GaussianFactor
+final class GaussianPriorFactor extends GaussianFactor
 {
    private readonly GaussianDistribution $newMessage;

@ -29,6 +29,7 @@ class GaussianPriorFactor extends GaussianFactor
        $this->createVariableToMessageBindingWithMessage($variable, $newMessage);
    }

+    #[\Override]
    protected function updateMessageVariable(Message $message, Variable $variable): float
    {
        $oldMarginal = clone $variable->getValue();
--- a/src/TrueSkill/Factors/GaussianWeightedSumFactor.php
+++ b/src/TrueSkill/Factors/GaussianWeightedSumFactor.php
@ -16,12 +16,12 @@ use DNW\Skills\Numerics\GaussianDistribution;
 *
 * See the accompanying math paper for more details.
 */
-class GaussianWeightedSumFactor extends GaussianFactor
+final class GaussianWeightedSumFactor extends GaussianFactor
 {
    /**
-     * @var array<int[]> $variableIndexOrdersForWeights
+     * @var array<int[]> $varIndexOrdersForWeights
     */
-    private array $variableIndexOrdersForWeights = [];
+    private array $varIndexOrdersForWeights = [];

    /**
     * This following is used for convenience, for example, the first entry is [0, 1, 2]
@ -58,9 +58,9 @@ class GaussianWeightedSumFactor extends GaussianFactor
        $variablesToSumLength = count($variablesToSum);

        // 0..n-1
-        $this->variableIndexOrdersForWeights[0] = [];
+        $this->varIndexOrdersForWeights[0] = [];
        for ($i = 0; $i < ($variablesToSumLength + 1); ++$i) {
-            $this->variableIndexOrdersForWeights[0][] = $i;
+            $this->varIndexOrdersForWeights[0][] = $i;
        }

        $variableWeightsLength = count($variableWeights);
@ -72,12 +72,12 @@ class GaussianWeightedSumFactor extends GaussianFactor

        $weightsLength = $variableWeightsLength + 1;
        for ($weightsIndex = 1; $weightsIndex < $weightsLength; ++$weightsIndex) {
-            $currentWeights = \array_fill(0, $variableWeightsLength, 0);
+            $currentWeights = \array_fill(0, $variableWeightsLength, 0.0);

-            $variableIndices = \array_fill(0, $variableWeightsLength + 1, 0);
+            $variableIndices = \array_fill(0, $variableWeightsLength + 1, 0.0);
            $variableIndices[0] = $weightsIndex;

-            $currentWeightsSquared = \array_fill(0, $variableWeightsLength, 0);
+            $currentWeightsSquared = \array_fill(0, $variableWeightsLength, 0.0);

            // keep a single variable to keep track of where we are in the array.
            // This is helpful since we skip over one of the spots
@ -90,9 +90,9 @@ class GaussianWeightedSumFactor extends GaussianFactor

                $currentWeight = (-$variableWeights[$currentWeightSourceIndex] / $variableWeights[$weightsIndex - 1]);

-                if ($variableWeights[$weightsIndex - 1] == 0) {
+                if ($variableWeights[$weightsIndex - 1] == 0.0) {
                    // HACK: Getting around division by zero
-                    $currentWeight = 0;
+                    $currentWeight = 0.0;
                }

                $currentWeights[$currentDestinationWeightIndex] = $currentWeight;
@ -112,8 +112,8 @@ class GaussianWeightedSumFactor extends GaussianFactor

            $currentWeights[$currentDestinationWeightIndex] = $finalWeight;
            $currentWeightsSquared[$currentDestinationWeightIndex] = BasicMath::square($finalWeight);
-            $variableIndices[count($variableWeights)] = 0;
-            $this->variableIndexOrdersForWeights[] = $variableIndices;
+            $variableIndices[count($variableWeights)] = 0.0;
+            $this->varIndexOrdersForWeights[] = $variableIndices;

            $this->weights[$weightsIndex] = $currentWeights;
            $this->weightsSquared[$weightsIndex] = $currentWeightsSquared;
@ -127,6 +127,7 @@ class GaussianWeightedSumFactor extends GaussianFactor
        }
    }

+    #[\Override]
    public function getLogNormalization(): float
    {
        $vars = $this->getVariables();
@ -160,9 +161,7 @@ class GaussianWeightedSumFactor extends GaussianFactor

        // The math works out so that 1/newPrecision = sum of a_i^2 /marginalsWithoutMessages[i]
        $inverseOfNewPrecisionSum = 0.0;
-        $anotherInverseOfNewPrecisionSum = 0.0;
        $weightedMeanSum = 0.0;
-        $anotherWeightedMeanSum = 0.0;

        $weightsSquaredLength = count($weightsSquared);

@ -172,16 +171,11 @@ class GaussianWeightedSumFactor extends GaussianFactor
            $inverseOfNewPrecisionSum += $weightsSquared[$i] /
                ($variables[$i + 1]->getValue()->getPrecision() - $messages[$i + 1]->getValue()->getPrecision());

-            $diff = GaussianDistribution::divide($variables[$i + 1]->getValue(), $messages[$i + 1]->getValue());
-            $anotherInverseOfNewPrecisionSum += $weightsSquared[$i] / $diff->getPrecision();
-
            $weightedMeanSum += $weights[$i]
                *
                ($variables[$i + 1]->getValue()->getPrecisionMean() - $messages[$i + 1]->getValue()->getPrecisionMean())
                /
                ($variables[$i + 1]->getValue()->getPrecision() - $messages[$i + 1]->getValue()->getPrecision());
-
-            $anotherWeightedMeanSum += $weights[$i] * $diff->getPrecisionMean() / $diff->getPrecision();
        }

        $newPrecision = 1.0 / $inverseOfNewPrecisionSum;
@ -204,6 +198,7 @@ class GaussianWeightedSumFactor extends GaussianFactor
        return $finalDiff;
    }

+    #[\Override]
    public function updateMessageIndex(int $messageIndex): float
    {
        $allMessages = $this->getMessages();
@ -214,7 +209,7 @@ class GaussianWeightedSumFactor extends GaussianFactor
        $updatedMessages = [];
        $updatedVariables = [];

-        $indicesToUse = $this->variableIndexOrdersForWeights[$messageIndex];
+        $indicesToUse = $this->varIndexOrdersForWeights[$messageIndex];
        // The tricky part here is that we have to put the messages and variables in the same
        // order as the weights. Thankfully, the weights and messages share the same index numbers,
        // so we just need to make sure they're consistent
--- a/src/TrueSkill/Factors/GaussianWithinFactor.php
+++ b/src/TrueSkill/Factors/GaussianWithinFactor.php
@ -14,7 +14,7 @@ use DNW\Skills\TrueSkill\TruncatedGaussianCorrectionFunctions;
 *
 * See the accompanying math paper for more details.
 */
-class GaussianWithinFactor extends GaussianFactor
+final class GaussianWithinFactor extends GaussianFactor
 {
    public function __construct(private readonly float $epsilon, Variable $variable)
    {
@ -23,6 +23,7 @@ class GaussianWithinFactor extends GaussianFactor
        $this->createVariableToMessageBinding($variable);
    }

+    #[\Override]
    public function getLogNormalization(): float
    {
        /**
@ -46,6 +47,7 @@ class GaussianWithinFactor extends GaussianFactor
        return -GaussianDistribution::logProductNormalization($messageFromVariable, $message) + log($z);
    }

+    #[\Override]
    protected function updateMessageVariable(Message $message, Variable $variable): float
    {
        $oldMarginal = clone $variable->getValue();
--- a/src/TrueSkill/Layers/IteratedTeamDifferencesInnerLayer.php
+++ b/src/TrueSkill/Layers/IteratedTeamDifferencesInnerLayer.php
@ -11,37 +11,40 @@ use DNW\Skills\TrueSkill\TrueSkillFactorGraph;
 use Exception;

 // The whole purpose of this is to do a loop on the bottom
-class IteratedTeamDifferencesInnerLayer extends TrueSkillFactorGraphLayer
+final class IteratedTeamDifferencesInnerLayer extends TrueSkillFactorGraphLayer
 {
    public function __construct(
        TrueSkillFactorGraph $parentGraph,
-        private readonly TeamPerformancesToTeamPerformanceDifferencesLayer $TeamPerformancesToTeamPerformanceDifferencesLayer,
-        private readonly TeamDifferencesComparisonLayer $TeamDifferencesComparisonLayer
+        private readonly TeamPerformancesToTeamPerformanceDifferencesLayer $teamPerformancesToTeamPerformanceDifferencesLayer,
+        private readonly TeamDifferencesComparisonLayer $teamDifferencesComparisonLayer
    )
    {
        parent::__construct($parentGraph);
    }

+    #[\Override]
    public function getLocalFactors(): array
    {
        return array_merge(
-            $this->TeamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors(),
-            $this->TeamDifferencesComparisonLayer->getLocalFactors()
+            $this->teamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors(),
+            $this->teamDifferencesComparisonLayer->getLocalFactors()
        );
    }

+    #[\Override]
    public function buildLayer(): void
    {
        $inputVariablesGroups = $this->getInputVariablesGroups();
-        $this->TeamPerformancesToTeamPerformanceDifferencesLayer->setInputVariablesGroups($inputVariablesGroups);
-        $this->TeamPerformancesToTeamPerformanceDifferencesLayer->buildLayer();
+        $this->teamPerformancesToTeamPerformanceDifferencesLayer->setInputVariablesGroups($inputVariablesGroups);
+        $this->teamPerformancesToTeamPerformanceDifferencesLayer->buildLayer();

-        $teamDifferencesOutputVariablesGroups = $this->TeamPerformancesToTeamPerformanceDifferencesLayer->getOutputVariablesGroups();
-        $this->TeamDifferencesComparisonLayer->setInputVariablesGroups($teamDifferencesOutputVariablesGroups);
-        $this->TeamDifferencesComparisonLayer->buildLayer();
+        $teamDifferencesOutputVariablesGroups = $this->teamPerformancesToTeamPerformanceDifferencesLayer->getOutputVariablesGroups();
+        $this->teamDifferencesComparisonLayer->setInputVariablesGroups($teamDifferencesOutputVariablesGroups);
+        $this->teamDifferencesComparisonLayer->buildLayer();
    }

-    public function createPriorSchedule(): ?ScheduleSequence
+    #[\Override]
+    public function createPriorSchedule(): ScheduleSequence
    {
        switch (count($this->getInputVariablesGroups())) {
            case 0:
@ -56,9 +59,9 @@ class IteratedTeamDifferencesInnerLayer extends TrueSkillFactorGraphLayer
        }

        // When dealing with differences, there are always (n-1) differences, so add in the 1
-        $totalTeamDifferences = count($this->TeamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors());
+        $totalTeamDifferences = count($this->teamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors());

-        $localFactors = $this->TeamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors();
+        $localFactors = $this->teamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors();

        $firstDifferencesFactor = $localFactors[0];
        $lastDifferencesFactor = $localFactors[$totalTeamDifferences - 1];
@ -83,8 +86,8 @@ class IteratedTeamDifferencesInnerLayer extends TrueSkillFactorGraphLayer

    private function createTwoTeamInnerPriorLoopSchedule(): ScheduleSequence
    {
-        $teamPerformancesToTeamPerformanceDifferencesLayerLocalFactors = $this->TeamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors();
-        $teamDifferencesComparisonLayerLocalFactors = $this->TeamDifferencesComparisonLayer->getLocalFactors();
+        $teamPerformancesToTeamPerformanceDifferencesLayerLocalFactors = $this->teamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors();
+        $teamDifferencesComparisonLayerLocalFactors = $this->teamDifferencesComparisonLayer->getLocalFactors();

        $firstPerfToTeamDiff = $teamPerformancesToTeamPerformanceDifferencesLayerLocalFactors[0];
        $firstTeamDiffComparison = $teamDifferencesComparisonLayerLocalFactors[0];
@ -109,13 +112,13 @@ class IteratedTeamDifferencesInnerLayer extends TrueSkillFactorGraphLayer

    private function createMultipleTeamInnerPriorLoopSchedule(): ScheduleLoop
    {
-        $totalTeamDifferences = count($this->TeamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors());
+        $totalTeamDifferences = count($this->teamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors());

        $forwardScheduleList = [];

        for ($i = 0; $i < $totalTeamDifferences - 1; ++$i) {
-            $teamPerformancesToTeamPerformanceDifferencesLayerLocalFactors = $this->TeamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors();
-            $teamDifferencesComparisonLayerLocalFactors = $this->TeamDifferencesComparisonLayer->getLocalFactors();
+            $teamPerformancesToTeamPerformanceDifferencesLayerLocalFactors = $this->teamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors();
+            $teamDifferencesComparisonLayerLocalFactors = $this->teamDifferencesComparisonLayer->getLocalFactors();

            $currentTeamPerfToTeamPerfDiff = $teamPerformancesToTeamPerformanceDifferencesLayerLocalFactors[$i];
            $currentTeamDiffComparison = $teamDifferencesComparisonLayerLocalFactors[$i];
@ -151,8 +154,8 @@ class IteratedTeamDifferencesInnerLayer extends TrueSkillFactorGraphLayer
        $backwardScheduleList = [];

        for ($i = 0; $i < $totalTeamDifferences - 1; ++$i) {
-            $teamPerformancesToTeamPerformanceDifferencesLayerLocalFactors = $this->TeamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors();
-            $teamDifferencesComparisonLayerLocalFactors = $this->TeamDifferencesComparisonLayer->getLocalFactors();
+            $teamPerformancesToTeamPerformanceDifferencesLayerLocalFactors = $this->teamPerformancesToTeamPerformanceDifferencesLayer->getLocalFactors();
+            $teamDifferencesComparisonLayerLocalFactors = $this->teamDifferencesComparisonLayer->getLocalFactors();

            $differencesFactor = $teamPerformancesToTeamPerformanceDifferencesLayerLocalFactors[$totalTeamDifferences - 1 - $i];
            $comparisonFactor = $teamDifferencesComparisonLayerLocalFactors[$totalTeamDifferences - 1 - $i];
--- a/src/TrueSkill/Layers/PlayerPerformancesToTeamPerformancesLayer.php
+++ b/src/TrueSkill/Layers/PlayerPerformancesToTeamPerformancesLayer.php
@ -11,8 +11,9 @@ use DNW\Skills\TrueSkill\Factors\GaussianWeightedSumFactor;
 use DNW\Skills\FactorGraphs\Variable;
 use DNW\Skills\FactorGraphs\KeyedVariable;

-class PlayerPerformancesToTeamPerformancesLayer extends TrueSkillFactorGraphLayer
+final class PlayerPerformancesToTeamPerformancesLayer extends TrueSkillFactorGraphLayer
 {
+    #[\Override]
    public function buildLayer(): void
    {
        $inputVariablesGroups = $this->getInputVariablesGroups();
@ -27,12 +28,13 @@ class PlayerPerformancesToTeamPerformancesLayer extends TrueSkillFactorGraphLaye
            $this->addLayerFactor($newSumFactor);

            // REVIEW: Does it make sense to have groups of one?
-            $outputVariablesGroups = &$this->getOutputVariablesGroups();
-            $outputVariablesGroups[] = [$teamPerformance];
+            $outputVarGroups = &$this->getOutputVariablesGroups();
+            $outputVarGroups[] = [$teamPerformance];
        }
    }

-    public function createPriorSchedule(): ?ScheduleSequence
+    #[\Override]
+    public function createPriorSchedule(): ScheduleSequence
    {
        $localFactors = $this->getLocalFactors();

@ -49,7 +51,7 @@ class PlayerPerformancesToTeamPerformancesLayer extends TrueSkillFactorGraphLaye
    /**
     * @param KeyedVariable[] $teamMembers
     */
-    protected function createPlayerToTeamSumFactor(array $teamMembers, Variable $sumVariable): GaussianWeightedSumFactor
+    private function createPlayerToTeamSumFactor(array $teamMembers, Variable $sumVariable): GaussianWeightedSumFactor
    {
        $weights = array_map(
            static function ($v): float {
@ -66,7 +68,8 @@ class PlayerPerformancesToTeamPerformancesLayer extends TrueSkillFactorGraphLaye
        );
    }

-    public function createPosteriorSchedule(): ?ScheduleSequence
+    #[\Override]
+    public function createPosteriorSchedule(): ScheduleSequence
    {
        $allFactors = [];
        $localFactors = $this->getLocalFactors();
--- a/src/TrueSkill/Layers/PlayerPriorValuesToSkillsLayer.php
+++ b/src/TrueSkill/Layers/PlayerPriorValuesToSkillsLayer.php
@ -17,7 +17,7 @@ use DNW\Skills\FactorGraphs\ScheduleSequence;

 // We intentionally have no Posterior schedule since the only purpose here is to
 // start the process.
-class PlayerPriorValuesToSkillsLayer extends TrueSkillFactorGraphLayer
+final class PlayerPriorValuesToSkillsLayer extends TrueSkillFactorGraphLayer
 {
    /**
     * @param Team[] $teams
@ -27,6 +27,7 @@ class PlayerPriorValuesToSkillsLayer extends TrueSkillFactorGraphLayer
        parent::__construct($parentGraph);
    }

+    #[\Override]
    public function buildLayer(): void
    {
        $teams = $this->teams;
@ -34,12 +35,12 @@ class PlayerPriorValuesToSkillsLayer extends TrueSkillFactorGraphLayer
            $localCurrentTeam = $currentTeam;
            $currentTeamSkills = [];

-            $currentTeamAllPlayers = $localCurrentTeam->getAllPlayers();
-            foreach ($currentTeamAllPlayers as $currentTeamPlayer) {
-                $localCurrentTeamPlayer = $currentTeamPlayer;
-                $currentTeamPlayerRating = $currentTeam->getRating($localCurrentTeamPlayer);
-                $playerSkill = $this->createSkillOutputVariable($localCurrentTeamPlayer);
-                $priorFactor = $this->createPriorFactor($currentTeamPlayerRating, $playerSkill);
+            $curTeamAllPlayers = $localCurrentTeam->getAllPlayers();
+            foreach ($curTeamAllPlayers as $curTeamPlayer) {
+                $localCurTeamPlayer = $curTeamPlayer;
+                $curTeamPlayerRating = $currentTeam->getRating($localCurTeamPlayer);
+                $playerSkill = $this->createSkillOutputVariable($localCurTeamPlayer);
+                $priorFactor = $this->createPriorFactor($curTeamPlayerRating, $playerSkill);
                $this->addLayerFactor($priorFactor);
                $currentTeamSkills[] = $playerSkill;
            }
@ -49,7 +50,8 @@ class PlayerPriorValuesToSkillsLayer extends TrueSkillFactorGraphLayer
        }
    }

-    public function createPriorSchedule(): ?ScheduleSequence
+    #[\Override]
+    public function createPriorSchedule(): ScheduleSequence
    {
        $localFactors = $this->getLocalFactors();

--- a/src/TrueSkill/Layers/PlayerSkillsToPerformancesLayer.php
+++ b/src/TrueSkill/Layers/PlayerSkillsToPerformancesLayer.php
@ -11,29 +11,30 @@ use DNW\Skills\Numerics\BasicMath;
 use DNW\Skills\TrueSkill\Factors\GaussianLikelihoodFactor;
 use DNW\Skills\FactorGraphs\ScheduleSequence;

-class PlayerSkillsToPerformancesLayer extends TrueSkillFactorGraphLayer
+final class PlayerSkillsToPerformancesLayer extends TrueSkillFactorGraphLayer
 {
+    #[\Override]
    public function buildLayer(): void
    {
-        $inputVariablesGroups = $this->getInputVariablesGroups();
-        $outputVariablesGroups = &$this->getOutputVariablesGroups();
+        $inputVarGroups = $this->getInputVariablesGroups();
+        $outputVarGroups = &$this->getOutputVariablesGroups();

-        foreach ($inputVariablesGroups as $currentTeam) {
+        foreach ($inputVarGroups as $currentTeam) {
            $currentTeamPlayerPerformances = [];

            /**
-             * @var Variable $playerSkillVariable
+             * @var Variable $playerSkillVar
             */
-            foreach ($currentTeam as $playerSkillVariable) {
-                $localPlayerSkillVariable = $playerSkillVariable;
-                $currentPlayer = ($localPlayerSkillVariable instanceof KeyedVariable) ? $localPlayerSkillVariable->getKey() : "";
+            foreach ($currentTeam as $playerSkillVar) {
+                $localPlayerSkillVar = $playerSkillVar;
+                $currentPlayer = ($localPlayerSkillVar instanceof KeyedVariable) ? $localPlayerSkillVar->getKey() : "";
                $playerPerformance = $this->createOutputVariable($currentPlayer);
-                $newLikelihoodFactor = $this->createLikelihood($localPlayerSkillVariable, $playerPerformance);
+                $newLikelihoodFactor = $this->createLikelihood($localPlayerSkillVar, $playerPerformance);
                $this->addLayerFactor($newLikelihoodFactor);
                $currentTeamPlayerPerformances[] = $playerPerformance;
            }

-            $outputVariablesGroups[] = $currentTeamPlayerPerformances;
+            $outputVarGroups[] = $currentTeamPlayerPerformances;
        }
    }

@ -51,7 +52,8 @@ class PlayerSkillsToPerformancesLayer extends TrueSkillFactorGraphLayer
        return $this->getParentFactorGraph()->getVariableFactory()->createKeyedVariable($key);
    }

-    public function createPriorSchedule(): ?ScheduleSequence
+    #[\Override]
+    public function createPriorSchedule(): ScheduleSequence
    {
        $localFactors = $this->getLocalFactors();

@ -65,7 +67,8 @@ class PlayerSkillsToPerformancesLayer extends TrueSkillFactorGraphLayer
        );
    }

-    public function createPosteriorSchedule(): ?ScheduleSequence
+    #[\Override]
+    public function createPosteriorSchedule(): ScheduleSequence
    {
        $localFactors = $this->getLocalFactors();

--- a/src/TrueSkill/Layers/TeamDifferencesComparisonLayer.php
+++ b/src/TrueSkill/Layers/TeamDifferencesComparisonLayer.php
@ -9,7 +9,7 @@ use DNW\Skills\TrueSkill\Factors\GaussianGreaterThanFactor;
 use DNW\Skills\TrueSkill\Factors\GaussianWithinFactor;
 use DNW\Skills\TrueSkill\TrueSkillFactorGraph;

-class TeamDifferencesComparisonLayer extends TrueSkillFactorGraphLayer
+final class TeamDifferencesComparisonLayer extends TrueSkillFactorGraphLayer
 {
    private readonly float $epsilon;

@ -23,6 +23,7 @@ class TeamDifferencesComparisonLayer extends TrueSkillFactorGraphLayer
        $this->epsilon = DrawMargin::getDrawMarginFromDrawProbability($gameInfo->getDrawProbability(), $gameInfo->getBeta());
    }

+    #[\Override]
    public function buildLayer(): void
    {
        $inputVarGroups = $this->getInputVariablesGroups();
--- a/src/TrueSkill/Layers/TeamPerformancesToTeamPerformanceDifferencesLayer.php
+++ b/src/TrueSkill/Layers/TeamPerformancesToTeamPerformanceDifferencesLayer.php
@ -7,8 +7,9 @@ namespace DNW\Skills\TrueSkill\Layers;
 use DNW\Skills\FactorGraphs\Variable;
 use DNW\Skills\TrueSkill\Factors\GaussianWeightedSumFactor;

-class TeamPerformancesToTeamPerformanceDifferencesLayer extends TrueSkillFactorGraphLayer
+final class TeamPerformancesToTeamPerformanceDifferencesLayer extends TrueSkillFactorGraphLayer
 {
+    #[\Override]
    public function buildLayer(): void
    {
        $inputVariablesGroups = $this->getInputVariablesGroups();
@ -28,11 +29,7 @@ class TeamPerformancesToTeamPerformanceDifferencesLayer extends TrueSkillFactorG
        }
    }

-    private function createTeamPerformanceToDifferenceFactor(
-        Variable $strongerTeam,
-        Variable $weakerTeam,
-        Variable $output
-    ): GaussianWeightedSumFactor
+    private function createTeamPerformanceToDifferenceFactor(Variable $strongerTeam, Variable $weakerTeam, Variable $output): GaussianWeightedSumFactor
    {
        $teams = [$strongerTeam, $weakerTeam];
        $weights = [1.0, -1.0];
--- a/src/TrueSkill/Layers/TrueSkillFactorGraphLayer.php
+++ b/src/TrueSkill/Layers/TrueSkillFactorGraphLayer.php
@ -9,8 +9,4 @@ use DNW\Skills\TrueSkill\TrueSkillFactorGraph;

 abstract class TrueSkillFactorGraphLayer extends FactorGraphLayer
 {
-    public function __construct(TrueSkillFactorGraph $parentGraph)
-    {
-        parent::__construct($parentGraph);
-    }
 }
--- a/src/TrueSkill/TrueSkillFactorGraph.php
+++ b/src/TrueSkill/TrueSkillFactorGraph.php
@ -23,16 +23,18 @@ use DNW\Skills\TrueSkill\Layers\PlayerSkillsToPerformancesLayer;
 use DNW\Skills\TrueSkill\Layers\TeamDifferencesComparisonLayer;
 use DNW\Skills\TrueSkill\Layers\TeamPerformancesToTeamPerformanceDifferencesLayer;

-class TrueSkillFactorGraph extends FactorGraph
+final class TrueSkillFactorGraph extends FactorGraph
 {
    /**
     * @var FactorGraphLayer[] $layers
     */
-    private array $layers;
+    private readonly array $layers;

    private readonly PlayerPriorValuesToSkillsLayer $priorLayer;

    /**
+     * Constructor
+     *
     * @param GameInfo $gameInfo  Parameters for the game.
     * @param Team[]   $teams     A mapping of team players and their ratings.
     * @param int[]    $teamRanks The ranks of the teams where 1 is first place. For a tie, repeat the number (e.g. 1, 2, 2).
@ -118,9 +120,9 @@ class TrueSkillFactorGraph extends FactorGraph
        $allLayersReverse = array_reverse($this->layers);

        foreach ($allLayersReverse as $currentLayer) {
-            $currentPosteriorSchedule = $currentLayer->createPosteriorSchedule();
-            if ($currentPosteriorSchedule != NULL) {
-                $fullSchedule[] = $currentPosteriorSchedule;
+            $curPosteriorSchedule = $currentLayer->createPosteriorSchedule();
+            if ($curPosteriorSchedule != NULL) {
+                $fullSchedule[] = $curPosteriorSchedule;
            }
        }

--- a/src/TrueSkill/TruncatedGaussianCorrectionFunctions.php
+++ b/src/TrueSkill/TruncatedGaussianCorrectionFunctions.php
@ -6,7 +6,7 @@ namespace DNW\Skills\TrueSkill;

 use DNW\Skills\Numerics\GaussianDistribution;

-class TruncatedGaussianCorrectionFunctions
+final class TruncatedGaussianCorrectionFunctions
 {
    // These functions from the bottom of page 4 of the TrueSkill paper.

@ -102,33 +102,33 @@ class TruncatedGaussianCorrectionFunctions
    }

    // the multiplicative correction of a double-sided truncated Gaussian with unit variance
-    public static function wWithinMarginScaled(float $teamPerformanceDifference, float $drawMargin, float $c): float
+    public static function wWithinMarginScaled(float $teamPerformanceDiff, float $drawMargin, float $c): float
    {
-        return self::wWithinMargin($teamPerformanceDifference / $c, $drawMargin / $c);
+        return self::wWithinMargin($teamPerformanceDiff / $c, $drawMargin / $c);
    }

    // From F#:
-    public static function wWithinMargin(float $teamPerformanceDifference, float $drawMargin): float
+    public static function wWithinMargin(float $teamPerformanceDiff, float $drawMargin): float
    {
-        $teamPerformanceDifferenceAbsoluteValue = abs($teamPerformanceDifference);
-        $denominator = GaussianDistribution::cumulativeTo($drawMargin - $teamPerformanceDifferenceAbsoluteValue)
+        $teamPerformanceDiffAbsValue = abs($teamPerformanceDiff);
+        $denominator = GaussianDistribution::cumulativeTo($drawMargin - $teamPerformanceDiffAbsValue)
            -
-            GaussianDistribution::cumulativeTo(-$drawMargin - $teamPerformanceDifferenceAbsoluteValue);
+            GaussianDistribution::cumulativeTo(-$drawMargin - $teamPerformanceDiffAbsValue);

        if ($denominator < 2.222758749e-162) {
            return 1.0;
        }

-        $vt = self::vWithinMargin($teamPerformanceDifferenceAbsoluteValue, $drawMargin);
+        $vt = self::vWithinMargin($teamPerformanceDiffAbsValue, $drawMargin);

        return $vt * $vt +
-        (($drawMargin - $teamPerformanceDifferenceAbsoluteValue)
+        (($drawMargin - $teamPerformanceDiffAbsValue)
            *
            GaussianDistribution::at(
-                $drawMargin - $teamPerformanceDifferenceAbsoluteValue
+                $drawMargin - $teamPerformanceDiffAbsValue
            )
-            - (-$drawMargin - $teamPerformanceDifferenceAbsoluteValue)
+            - (-$drawMargin - $teamPerformanceDiffAbsValue)
            *
-            GaussianDistribution::at(-$drawMargin - $teamPerformanceDifferenceAbsoluteValue)) / $denominator;
+            GaussianDistribution::at(-$drawMargin - $teamPerformanceDiffAbsValue)) / $denominator;
    }
 }
--- a/src/TrueSkill/TwoPlayerTrueSkillCalculator.php
+++ b/src/TrueSkill/TwoPlayerTrueSkillCalculator.php
@ -13,9 +13,7 @@ use DNW\Skills\RankSorter;
 use DNW\Skills\Rating;
 use DNW\Skills\RatingContainer;
 use DNW\Skills\SkillCalculator;
-use DNW\Skills\SkillCalculatorSupportedOptions;
 use DNW\Skills\TeamsRange;
-use DNW\Skills\Team;

 /**
 * Calculates the new ratings for only two players.
@ -23,21 +21,18 @@ use DNW\Skills\Team;
 * When you only have two players, a lot of the math simplifies. The main purpose of this class
 * is to show the bare minimum of what a TrueSkill implementation should have.
 */
-class TwoPlayerTrueSkillCalculator extends SkillCalculator
+final class TwoPlayerTrueSkillCalculator extends SkillCalculator
 {
    public function __construct()
    {
-        parent::__construct(SkillCalculatorSupportedOptions::NONE, TeamsRange::exactly(2), PlayersRange::exactly(1));
+        parent::__construct(SkillCalculator::NONE, TeamsRange::exactly(2), PlayersRange::exactly(1));
    }

    /**
     * {@inheritdoc}
     */
-    public function calculateNewRatings(
-        GameInfo $gameInfo,
-        array $teams,
-        array $teamRanks
-    ): RatingContainer
+    #[\Override]
+    public function calculateNewRatings(GameInfo $gameInfo, array $teams, array $teamRanks): RatingContainer
    {
        // Basic argument checking
        $this->validateTeamCountAndPlayersCountPerTeam($teams);
@ -96,7 +91,7 @@ class TwoPlayerTrueSkillCalculator extends SkillCalculator
            +
            BasicMath::square($opponentRating->getStandardDeviation())
            +
-            2 * BasicMath::square($gameInfo->getBeta())
+            2.0 * BasicMath::square($gameInfo->getBeta())
        );

        $winningMean = $selfRating->getMean();
@ -119,11 +114,11 @@ class TwoPlayerTrueSkillCalculator extends SkillCalculator
            // non-draw case
            $v = TruncatedGaussianCorrectionFunctions::vExceedsMarginScaled($meanDelta, $drawMargin, $c);
            $w = TruncatedGaussianCorrectionFunctions::wExceedsMarginScaled($meanDelta, $drawMargin, $c);
-            $rankMultiplier = $comparison->value;
+            $rankMultiplier = (float)$comparison->value;
        } else {
            $v = TruncatedGaussianCorrectionFunctions::vWithinMarginScaled($meanDelta, $drawMargin, $c);
            $w = TruncatedGaussianCorrectionFunctions::wWithinMarginScaled($meanDelta, $drawMargin, $c);
-            $rankMultiplier = 1;
+            $rankMultiplier = 1.0;
        }

        $meanMultiplier = (BasicMath::square($selfRating->getStandardDeviation()) + BasicMath::square($gameInfo->getDynamicsFactor())) / $c;
@ -132,7 +127,7 @@ class TwoPlayerTrueSkillCalculator extends SkillCalculator
        $stdDevMultiplier = $varianceWithDynamics / BasicMath::square($c);

        $newMean = $selfRating->getMean() + ($rankMultiplier * $meanMultiplier * $v);
-        $newStdDev = sqrt($varianceWithDynamics * (1 - $w * $stdDevMultiplier));
+        $newStdDev = sqrt($varianceWithDynamics * (1.0 - $w * $stdDevMultiplier));

        return new Rating($newMean, $newStdDev);
    }
@ -140,6 +135,7 @@ class TwoPlayerTrueSkillCalculator extends SkillCalculator
    /**
     * {@inheritdoc}
     */
+    #[\Override]
    public function calculateMatchQuality(GameInfo $gameInfo, array $teams): float
    {
        $this->validateTeamCountAndPlayersCountPerTeam($teams);
@ -160,16 +156,16 @@ class TwoPlayerTrueSkillCalculator extends SkillCalculator

        // This is the square root part of the equation:
        $sqrtPart = sqrt(
-            (2 * $betaSquared)
+            (2.0 * $betaSquared)
            /
-            (2 * $betaSquared + $player1SigmaSquared + $player2SigmaSquared)
+            (2.0 * $betaSquared + $player1SigmaSquared + $player2SigmaSquared)
        );

        // This is the exponent part of the equation:
        $expPart = exp(
-            (-1 * BasicMath::square($player1Rating->getMean() - $player2Rating->getMean()))
+            (-1.0 * BasicMath::square($player1Rating->getMean() - $player2Rating->getMean()))
            /
-            (2 * (2 * $betaSquared + $player1SigmaSquared + $player2SigmaSquared))
+            (2.0 * (2.0 * $betaSquared + $player1SigmaSquared + $player2SigmaSquared))
        );

        return $sqrtPart * $expPart;
--- a/src/TrueSkill/TwoTeamTrueSkillCalculator.php
+++ b/src/TrueSkill/TwoTeamTrueSkillCalculator.php
@ -13,7 +13,6 @@ use DNW\Skills\RankSorter;
 use DNW\Skills\Rating;
 use DNW\Skills\RatingContainer;
 use DNW\Skills\SkillCalculator;
-use DNW\Skills\SkillCalculatorSupportedOptions;
 use DNW\Skills\Team;
 use DNW\Skills\TeamsRange;

@ -22,16 +21,17 @@ use DNW\Skills\TeamsRange;
 *
 * When you only have two teams, the math is still simple: no factor graphs are used yet.
 */
-class TwoTeamTrueSkillCalculator extends SkillCalculator
+final class TwoTeamTrueSkillCalculator extends SkillCalculator
 {
    public function __construct()
    {
-        parent::__construct(SkillCalculatorSupportedOptions::NONE, TeamsRange::exactly(2), PlayersRange::atLeast(1));
+        parent::__construct(SkillCalculator::NONE, TeamsRange::exactly(2), PlayersRange::atLeast(1));
    }

    /**
     * {@inheritdoc}
     */
+    #[\Override]
    public function calculateNewRatings(GameInfo $gameInfo, array $teams, array $teamRanks): RatingContainer
    {
        $this->validateTeamCountAndPlayersCountPerTeam($teams);
@ -64,13 +64,7 @@ class TwoTeamTrueSkillCalculator extends SkillCalculator
        return $results;
    }

-    private static function updatePlayerRatings(
-        GameInfo $gameInfo,
-        RatingContainer $newPlayerRatings,
-        Team $selfTeam,
-        Team $otherTeam,
-        PairwiseComparison $selfToOtherTeamComparison
-    ): void
+    private static function updatePlayerRatings(GameInfo $gameInfo, RatingContainer $newPlayerRatings, Team $selfTeam, Team $otherTeam, PairwiseComparison $selfToOtherTeamComparison): void
    {
        $drawMargin = DrawMargin::getDrawMarginFromDrawProbability(
            $gameInfo->getDrawProbability(),
@ -94,7 +88,7 @@ class TwoTeamTrueSkillCalculator extends SkillCalculator
            +
            BasicMath::sum($otherTeam->getAllRatings(), $varianceGetter)
            +
-            $totalPlayers * $betaSquared
+            (float)$totalPlayers * $betaSquared
        );

        $winningMean = $selfMeanSum;
@ -117,18 +111,18 @@ class TwoTeamTrueSkillCalculator extends SkillCalculator
            // non-draw case
            $v = TruncatedGaussianCorrectionFunctions::vExceedsMarginScaled($meanDelta, $drawMargin, $c);
            $w = TruncatedGaussianCorrectionFunctions::wExceedsMarginScaled($meanDelta, $drawMargin, $c);
-            $rankMultiplier = $selfToOtherTeamComparison->value;
+            $rankMultiplier = (float)$selfToOtherTeamComparison->value;
        } else {
            // assume draw
            $v = TruncatedGaussianCorrectionFunctions::vWithinMarginScaled($meanDelta, $drawMargin, $c);
            $w = TruncatedGaussianCorrectionFunctions::wWithinMarginScaled($meanDelta, $drawMargin, $c);
-            $rankMultiplier = 1;
+            $rankMultiplier = 1.0;
        }

        $selfTeamAllPlayers = $selfTeam->getAllPlayers();
-        foreach ($selfTeamAllPlayers as $selfTeamCurrentPlayer) {
-            $localSelfTeamCurrentPlayer = $selfTeamCurrentPlayer;
-            $previousPlayerRating = $selfTeam->getRating($localSelfTeamCurrentPlayer);
+        foreach ($selfTeamAllPlayers as $selfTeamCurPlayer) {
+            $localSelfTeamCurPlayer = $selfTeamCurPlayer;
+            $previousPlayerRating = $selfTeam->getRating($localSelfTeamCurPlayer);

            $meanMultiplier = (BasicMath::square($previousPlayerRating->getStandardDeviation()) + $tauSquared) / $c;
            $stdDevMultiplier = (BasicMath::square($previousPlayerRating->getStandardDeviation()) + $tauSquared) / BasicMath::square($c);
@ -137,16 +131,17 @@ class TwoTeamTrueSkillCalculator extends SkillCalculator
            $newMean = $previousPlayerRating->getMean() + $playerMeanDelta;

            $newStdDev = sqrt(
-                (BasicMath::square($previousPlayerRating->getStandardDeviation()) + $tauSquared) * (1 - $w * $stdDevMultiplier)
+                (BasicMath::square($previousPlayerRating->getStandardDeviation()) + $tauSquared) * (1.0 - $w * $stdDevMultiplier)
            );

-            $newPlayerRatings->setRating($localSelfTeamCurrentPlayer, new Rating($newMean, $newStdDev));
+            $newPlayerRatings->setRating($localSelfTeamCurPlayer, new Rating($newMean, $newStdDev));
        }
    }

    /**
     * {@inheritdoc}
     */
+    #[\Override]
    public function calculateMatchQuality(GameInfo $gameInfo, array $teams): float
    {
        $this->validateTeamCountAndPlayersCountPerTeam($teams);
@ -158,7 +153,7 @@ class TwoTeamTrueSkillCalculator extends SkillCalculator
        $team2Ratings = $teams[1]->getAllRatings();
        $team2Count = count($team2Ratings);

-        $totalPlayers = $team1Count + $team2Count;
+        $totalPlayers = (float)($team1Count + $team2Count);

        $betaSquared = BasicMath::square($gameInfo->getBeta());

@ -183,9 +178,9 @@ class TwoTeamTrueSkillCalculator extends SkillCalculator
        );

        $expPart = exp(
-            (-1 * BasicMath::square($team1MeanSum - $team2MeanSum))
+            (-1.0 * BasicMath::square($team1MeanSum - $team2MeanSum))
            /
-            (2 * ($totalPlayers * $betaSquared + $team1StdDevSquared + $team2StdDevSquared))
+            (2.0 * ($totalPlayers * $betaSquared + $team1StdDevSquared + $team2StdDevSquared))
        );

        return $expPart * $sqrtPart;
--- a/tests/FactorGraphs/VariableTest.php
+++ b/tests/FactorGraphs/VariableTest.php
@ -12,7 +12,7 @@ use PHPUnit\Framework\Attributes\UsesClass;

 #[CoversClass(Variable::class)]
 #[UsesClass(GaussianDistribution::class)]
-class VariableTest extends TestCase
+final class VariableTest extends TestCase
 {
    public function testGetterSetter(): void
    {
--- a/tests/GameInfoTest.php
+++ b/tests/GameInfoTest.php
@ -12,7 +12,7 @@ use PHPUnit\Framework\Attributes\UsesClass;

 #[CoversClass(GameInfo::class)]
 #[UsesClass(Rating::class)]
-class GameInfoTest extends TestCase
+final class GameInfoTest extends TestCase
 {
    public function testMembers(): void
    {
--- a/tests/GuardTest.php
+++ b/tests/GuardTest.php
@ -10,7 +10,7 @@ use PHPUnit\Framework\TestCase;
 use PHPUnit\Framework\Attributes\CoversClass;

 #[CoversClass(Guard::class)]
-class GuardTest extends TestCase
+final class GuardTest extends TestCase
 {
    public function testargumentIsValidIndexArgumentAbove(): void
    {
@ -28,7 +28,9 @@ class GuardTest extends TestCase

    public function testargumentIsValidIndexArgumentValid(): void
    {
-        Guard::argumentIsValidIndex(5, 10, "dummy");
+        Guard::argumentIsValidIndex(0, 10, "dummy");
+        Guard::argumentIsValidIndex(1, 10, "dummy");
+        Guard::argumentIsValidIndex(9, 10, "dummy");
        $this->expectNotToPerformAssertions();
    }

@ -48,7 +50,12 @@ class GuardTest extends TestCase

    public function testargumentInRangeInclusiveValid(): void
    {
+        Guard::argumentInRangeInclusive(0, 0, 100, "dummy");
+        Guard::argumentInRangeInclusive(1, 0, 100, "dummy");
        Guard::argumentInRangeInclusive(50, 0, 100, "dummy");
+        Guard::argumentInRangeInclusive(99, 0, 100, "dummy");
+        Guard::argumentInRangeInclusive(100, 0, 100, "dummy");
+
        $this->expectNotToPerformAssertions();
    }
 }
--- a/tests/HashMapTest.php
+++ b/tests/HashMapTest.php
@ -7,9 +7,10 @@ namespace DNW\Skills\Tests;
 use DNW\Skills\HashMap;
 use PHPUnit\Framework\TestCase;
 use PHPUnit\Framework\Attributes\CoversClass;
+use stdClass;

 #[CoversClass(HashMap::class)]
-class HashMapTest extends TestCase
+final class HashMapTest extends TestCase
 {
    public function testHashmap(): void
    {
@ -19,13 +20,14 @@ class HashMapTest extends TestCase
        $this->assertEquals([], $h->getAllValues());


-        $o1 = new \stdClass();
-        $o2 = new \stdClass();
+        $o1 = new stdClass();
+        $o2 = new stdClass();

        $h->setValue($o1, 1);
        $h->setvalue($o2, 2);

        $this->assertEquals([1, 2], $h->getAllValues());
+        $this->assertEquals([$o1, $o2], $h->getAllKeys());

        $this->assertEquals(1, $h->getvalue($o1));
        $this->assertEquals(2, $h->getvalue($o2));
--- a/tests/Numerics/BasicMathTest.php
+++ b/tests/Numerics/BasicMathTest.php
@ -9,7 +9,7 @@ use PHPUnit\Framework\TestCase;
 use PHPUnit\Framework\Attributes\CoversClass;

 #[CoversClass(BasicMath::class)]
-class BasicMathTest extends TestCase
+final class BasicMathTest extends TestCase
 {
    public function testSquare(): void
    {
@ -23,7 +23,7 @@ class BasicMathTest extends TestCase
        $arr = [1, 1, 1, 1];

        $func_return = static fn(float $f): float => $f;
-        $func_double = static fn(float $f): float => $f * 2;
+        $func_double = static fn(float $f): float => $f * 2.0;
        $this->assertEquals(4, BasicMath::sum($arr, $func_return));
        $this->assertEquals(8, BasicMath::sum($arr, $func_double));
    }
--- a/tests/Numerics/GaussianDistributionTest.php
+++ b/tests/Numerics/GaussianDistributionTest.php
@ -12,9 +12,9 @@ use PHPUnit\Framework\Attributes\UsesClass;

 #[CoversClass(GaussianDistribution::class)]
 #[UsesClass(BasicMath::class)]
-class GaussianDistributionTest extends TestCase
+final class GaussianDistributionTest extends TestCase
 {
-    private const ERROR_TOLERANCE = 0.000001;
+    private const float ERROR_TOLERANCE = 0.000001;

    public function testGetters(): void
    {
@ -24,7 +24,7 @@ class GaussianDistributionTest extends TestCase
        $this->assertEquals(9, $gd->getVariance());
        $this->assertEquals(3, $gd->getStandardDeviation());
        $this->assertEquals(1 / 9, $gd->getPrecision());
-        $this->assertEquals(1 / 9 * 10, $gd->getPrecisionMean());
+        $this->assertEquals(1.0 / 9.0 * 10.0, $gd->getPrecisionMean());
        $this->assertEqualsWithDelta(0.13298076013, $gd->getNormalizationConstant(), GaussianDistributionTest::ERROR_TOLERANCE);
    }

@ -57,7 +57,7 @@ class GaussianDistributionTest extends TestCase

        $product2 = GaussianDistribution::multiply($m4s5, $m6s7);

-        $expectedMean = (4 * BasicMath::square(7) + 6 * BasicMath::square(5)) / (BasicMath::square(5) + BasicMath::square(7));
+        $expectedMean = (4.0 * BasicMath::square(7) + 6.0 * BasicMath::square(5)) / (BasicMath::square(5) + BasicMath::square(7));
        $this->assertEqualsWithDelta($expectedMean, $product2->getMean(), GaussianDistributionTest::ERROR_TOLERANCE);

        $expectedSigma = sqrt(((BasicMath::square(5) * BasicMath::square(7)) / (BasicMath::square(5) + BasicMath::square(7))));
@ -74,7 +74,7 @@ class GaussianDistributionTest extends TestCase
        $this->assertEqualsWithDelta(2.0, $productDividedByStandardNormal->getMean(), GaussianDistributionTest::ERROR_TOLERANCE);
        $this->assertEqualsWithDelta(3.0, $productDividedByStandardNormal->getStandardDeviation(), GaussianDistributionTest::ERROR_TOLERANCE);

-        $product2              = new GaussianDistribution((4 * BasicMath::square(7) + 6 * BasicMath::square(5)) / (BasicMath::square(5) + BasicMath::square(7)), sqrt(((BasicMath::square(5) * BasicMath::square(7)) / (BasicMath::square(5) + BasicMath::square(7)))));
+        $product2              = new GaussianDistribution((4.0 * BasicMath::square(7) + 6.0 * BasicMath::square(5)) / (BasicMath::square(5) + BasicMath::square(7)), sqrt(((BasicMath::square(5) * BasicMath::square(7)) / (BasicMath::square(5) + BasicMath::square(7)))));
        $m4s5                  = new GaussianDistribution(4, 5);
        $product2DividedByM4S5 = GaussianDistribution::divide($product2, $m4s5);
        $this->assertEqualsWithDelta(6.0, $product2DividedByM4S5->getMean(), GaussianDistributionTest::ERROR_TOLERANCE);
@ -92,6 +92,21 @@ class GaussianDistributionTest extends TestCase
        $m3s4 = new GaussianDistribution(3, 4);
        $lpn2 = GaussianDistribution::logProductNormalization($m1s2, $m3s4);
        $this->assertEqualsWithDelta(-2.5168046699816684, $lpn2, GaussianDistributionTest::ERROR_TOLERANCE);
+
+        $numerator = GaussianDistribution::fromPrecisionMean(1, 0);
+        $denominator = GaussianDistribution::fromPrecisionMean(1, 0);
+        $lrn  = GaussianDistribution::logProductNormalization($numerator, $denominator);
+        $this->assertEquals(0, $lrn);
+
+        $numerator = GaussianDistribution::fromPrecisionMean(1, 1);
+        $denominator = GaussianDistribution::fromPrecisionMean(1, 0);
+        $lrn  = GaussianDistribution::logProductNormalization($numerator, $denominator);
+        $this->assertEquals(0, $lrn);
+
+        $numerator = GaussianDistribution::fromPrecisionMean(1, 0);
+        $denominator = GaussianDistribution::fromPrecisionMean(1, 1);
+        $lrn  = GaussianDistribution::logProductNormalization($numerator, $denominator);
+        $this->assertEquals(0, $lrn);
    }

    public function testLogRatioNormalization(): void
@ -101,6 +116,21 @@ class GaussianDistributionTest extends TestCase
        $m3s4 = new GaussianDistribution(3, 4);
        $lrn  = GaussianDistribution::logRatioNormalization($m1s2, $m3s4);
        $this->assertEqualsWithDelta(2.6157405972171204, $lrn, GaussianDistributionTest::ERROR_TOLERANCE);
+
+        $numerator = GaussianDistribution::fromPrecisionMean(1, 0);
+        $denominator = GaussianDistribution::fromPrecisionMean(1, 0);
+        $lrn  = GaussianDistribution::logRatioNormalization($numerator, $denominator);
+        $this->assertEquals(0, $lrn);
+
+        $numerator = GaussianDistribution::fromPrecisionMean(1, 1);
+        $denominator = GaussianDistribution::fromPrecisionMean(1, 0);
+        $lrn  = GaussianDistribution::logRatioNormalization($numerator, $denominator);
+        $this->assertEquals(0, $lrn);
+
+        $numerator = GaussianDistribution::fromPrecisionMean(1, 0);
+        $denominator = GaussianDistribution::fromPrecisionMean(1, 1);
+        $lrn  = GaussianDistribution::logRatioNormalization($numerator, $denominator);
+        $this->assertEquals(0, $lrn);
    }

    public function testAbsoluteDifference(): void
@ -115,4 +145,27 @@ class GaussianDistributionTest extends TestCase
        $absDiff2 = GaussianDistribution::absoluteDifference($m1s2, $m3s4);
        $this->assertEqualsWithDelta(0.4330127018922193, $absDiff2, GaussianDistributionTest::ERROR_TOLERANCE);
    }
+
+    public function testSubtract(): void
+    {
+        // Verified with Ralf Herbrich's F# implementation
+        $standardNormal = new GaussianDistribution(0, 1);
+        $absDiff        = GaussianDistribution::subtract($standardNormal, $standardNormal);
+        $this->assertEqualsWithDelta(0.0, $absDiff, GaussianDistributionTest::ERROR_TOLERANCE);
+
+        $m1s2 = new GaussianDistribution(1, 2);
+        $m3s4 = new GaussianDistribution(3, 4);
+        $absDiff2 = GaussianDistribution::subtract($m1s2, $m3s4);
+        $this->assertEqualsWithDelta(0.4330127018922193, $absDiff2, GaussianDistributionTest::ERROR_TOLERANCE);
+    }
+
+    public function testfromPrecisionMean(): void
+    {
+        $gd = GaussianDistribution::fromPrecisionMean(0, 0);
+        $this->assertInfinite($gd->getVariance());
+        $this->assertInfinite($gd->getStandardDeviation());
+        $this->assertNan($gd->getMean());
+        $this->assertEquals(0, $gd->getPrecisionMean());
+        $this->assertEquals(0, $gd->getPrecision());
+    }
 }
--- a/tests/Numerics/MatrixTest.php
+++ b/tests/Numerics/MatrixTest.php
@ -20,8 +20,85 @@ use Exception;
 #[CoversClass(DiagonalMatrix::class)]
 #[CoversClass(Vector::class)]
 // phpcs:disable PSR2.Methods.FunctionCallSignature,Generic.Functions.FunctionCallArgumentSpacing.TooMuchSpaceAfterComma
-class MatrixTest extends TestCase
+final class MatrixTest extends TestCase
 {
+    public function testEmptyMatrix(): void
+    {
+        $m1 = new Matrix();
+        $this->assertEquals(0, $m1->getRowCount());
+        $this->assertEquals(0, $m1->getColumnCount());
+
+        $m2 = new Matrix(0, 0);
+        $this->assertEquals(0, $m2->getRowCount());
+        $this->assertEquals(0, $m2->getColumnCount());
+
+        $this->assertEquals(new Matrix(), Matrix::multiply($m1, $m2));
+    }
+
+    public function testIndexing(): void
+    {
+        $m = new Matrix(5, 5);
+        $m->setValue(0, 0, 1);
+        $this->assertEquals(1, $m->getValue(0, 0));
+        $m->setValue(0, 1, 2);
+        $this->assertEquals(2, $m->getValue(0, 1));
+        $m->setValue(1, 0, 3);
+        $this->assertEquals(3, $m->getValue(1, 0));
+        $m->setValue(1, 1, 4);
+        $this->assertEquals(4, $m->getValue(1, 1));
+
+        $m->setValue(3, 3, 11);
+        $this->assertEquals(11, $m->getValue(3, 3));
+        $m->setValue(4, 3, 22);
+        $this->assertEquals(22, $m->getValue(4, 3));
+        $m->setValue(3, 4, 33);
+        $this->assertEquals(33, $m->getValue(3, 4));
+        $m->setValue(4, 4, 44);
+        $this->assertEquals(44, $m->getValue(4, 4));
+
+        try {
+            $m->getValue(-1, -1);
+            $this->fail("No exception");
+        } catch (Exception $exception) {
+            $this->assertInstanceOf(Exception::class, $exception);
+        }
+
+        try {
+            $m->getValue(-1, 0);
+            $this->fail("No exception");
+        } catch (Exception $exception) {
+            $this->assertInstanceOf(Exception::class, $exception);
+        }
+
+        try {
+            $m->getValue(0, -1);
+            $this->fail("No exception");
+        } catch (Exception $exception) {
+            $this->assertInstanceOf(Exception::class, $exception);
+        }
+
+        try {
+            $m->getValue(5, 5);
+            $this->fail("No exception");
+        } catch (Exception $exception) {
+            $this->assertInstanceOf(Exception::class, $exception);
+        }
+
+        try {
+            $m->getValue(5, 4);
+            $this->fail("No exception");
+        } catch (Exception $exception) {
+            $this->assertInstanceOf(Exception::class, $exception);
+        }
+
+        try {
+            $m->getValue(4, 5);
+            $this->fail("No exception");
+        } catch (Exception $exception) {
+            $this->assertInstanceOf(Exception::class, $exception);
+        }
+    }
+
    public function testOneByOneDeterminant(): void
    {
        $a = new SquareMatrix(1);
@ -218,7 +295,7 @@ class MatrixTest extends TestCase
                              1, 0, 6);

        $cInverse = $c->getInverse();
-        $d = Matrix::scalarMultiply((1.0 / 22), new SquareMatrix(24, -12, -2,
+        $d = Matrix::scalarMultiply((1.0 / 22.0), new SquareMatrix(24, -12, -2,
                                                                  5,   3, -5,
                                                                 -4, 2, 4));

--- a/tests/Numerics/RangeTest.php
+++ b/tests/Numerics/RangeTest.php
@ -10,7 +10,7 @@ use PHPUnit\Framework\Attributes\CoversClass;
 use Exception;

 #[CoversClass(Range::class)]
-class RangeTest extends TestCase
+final class RangeTest extends TestCase
 {
    public function testConstructInvalidParam(): void
    {
--- a/tests/PartialPlayTest.php
+++ b/tests/PartialPlayTest.php
@ -14,7 +14,7 @@ use PHPUnit\Framework\Attributes\UsesClass;
 #[CoversClass(PartialPlay::class)]
 #[UsesClass(Player::class)]
 #[UsesClass(Guard::class)]
-class PartialPlayTest extends TestCase
+final class PartialPlayTest extends TestCase
 {
    public function testgetPartialPlayPercentage(): void
    {
--- a/tests/PlayerTest.php
+++ b/tests/PlayerTest.php
@ -12,7 +12,7 @@ use PHPUnit\Framework\Attributes\UsesClass;

 #[CoversClass(Player::class)]
 #[UsesClass(Guard::class)]
-class PlayerTest extends TestCase
+final class PlayerTest extends TestCase
 {
    public function testPlayerObjectGetterSetter(): void
    {
--- a/tests/RankSorterTest.php
+++ b/tests/RankSorterTest.php
@ -9,7 +9,7 @@ use PHPUnit\Framework\TestCase;
 use PHPUnit\Framework\Attributes\CoversClass;

 #[CoversClass(RankSorter::class)]
-class RankSorterTest extends TestCase
+final class RankSorterTest extends TestCase
 {
    public function testSort(): void
    {
--- a/tests/RatingContainerTest.php
+++ b/tests/RatingContainerTest.php
@ -18,7 +18,7 @@ use PHPUnit\Framework\Attributes\UsesClass;
 #[UsesClass(Player::class)]
 #[UsesClass(Rating::class)]
 #[UsesClass(Guard::class)]
-class RatingContainerTest extends TestCase
+final class RatingContainerTest extends TestCase
 {
    public function testRatingContainer(): void
    {
--- a/tests/RatingTest.php
+++ b/tests/RatingTest.php
@ -14,7 +14,7 @@ use PHPUnit\Framework\Attributes\UsesClass;
 #[CoversClass(Rating::class)]
 #[UsesClass(BasicMath::class)]
 #[UsesClass(GaussianDistribution::class)]
-class RatingTest extends TestCase
+final class RatingTest extends TestCase
 {
    public function testGetRatingParameters(): void
    {
--- a/tests/SkillCalculatorTest.php
+++ b/tests/SkillCalculatorTest.php
@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DNW\Skills\Tests;
+
+use DNW\Skills\SkillCalculator;
+use DNW\Skills\TeamsRange;
+use DNW\Skills\PlayersRange;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\UsesClass;
+use PHPUnit\Framework\Attributes\RequiresPhpunit;
+
+#[CoversClass(SkillCalculator::class)]
+#[UsesClass(\DNW\Skills\Numerics\Range::class)]
+#[UsesClass(PlayersRange::class)]
+#[UsesClass(TeamsRange::class)]
+#[RequiresPhpunit('<12.0')]
+final class SkillCalculatorTest extends TestCase
+{
+    public function testisSupported(): void
+    {
+        $calculator = $this->getMockForAbstractClass(SkillCalculator::class, [SkillCalculator::PARTIAL_PLAY, new TeamsRange(1, 2), new PlayersRange(1, 2)]);
+
+        $this->assertEquals(TRUE, $calculator->isSupported(SkillCalculator::PARTIAL_PLAY));
+        $this->assertEquals(FALSE, $calculator->isSupported(SkillCalculator::PARTIAL_UPDATE));
+    }
+}
--- a/tests/TeamTest.php
+++ b/tests/TeamTest.php
@ -20,7 +20,7 @@ use PHPUnit\Framework\Attributes\UsesClass;
 #[UsesClass(Player::class)]
 #[UsesClass(Rating::class)]
 #[UsesClass(Guard::class)]
-class TeamTest extends TestCase
+final class TeamTest extends TestCase
 {
    public function testTeam(): void
    {
--- a/tests/TrueSkill/DrawMarginTest.php
+++ b/tests/TrueSkill/DrawMarginTest.php
@ -14,9 +14,9 @@ use PHPUnit\Framework\Attributes\UsesClass;
 #[CoversClass(DrawMargin::class)]
 #[UsesClass(BasicMath::class)]
 #[UsesClass(GaussianDistribution::class)]
-class DrawMarginTest extends TestCase
+final class DrawMarginTest extends TestCase
 {
-    private const ERROR_TOLERANCE = 0.000001;
+    private const float ERROR_TOLERANCE = 0.000001;

    public function testGetDrawMarginFromDrawProbability(): void
    {
--- a/tests/TrueSkill/FactorGraphTrueSkillCalculatorTest.php
+++ b/tests/TrueSkill/FactorGraphTrueSkillCalculatorTest.php
@ -4,22 +4,15 @@ declare(strict_types=1);

 namespace DNW\Skills\Tests\TrueSkill;

+use DNW\Skills\SkillCalculator;
 use DNW\Skills\GameInfo;
 use DNW\Skills\Player;
 use DNW\Skills\Team;
 use DNW\Skills\TrueSkill\FactorGraphTrueSkillCalculator;
-use DNW\Skills\SkillCalculatorSupportedOptions;
 use PHPUnit\Framework\TestCase;
-use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\CoversNothing;
-use PHPUnit\Framework\Attributes\UsesClass;

-#[CoversClass(FactorGraphTrueSkillCalculator::class)]
-#[UsesClass(\DNW\Skills\Numerics\Range::class)]
-#[UsesClass(\DNW\Skills\PlayersRange::class)]
-#[UsesClass(\DNW\Skills\SkillCalculator::class)]
-#[UsesClass(\DNW\Skills\TeamsRange::class)]
-class FactorGraphTrueSkillCalculatorTest extends TestCase
+final class FactorGraphTrueSkillCalculatorTest extends TestCase
 {
    #[CoversNothing]
    public function testMicrosoftResearchExample(): void
@ -75,9 +68,10 @@ class FactorGraphTrueSkillCalculatorTest extends TestCase
        TrueSkillCalculatorTests::testPartialPlayScenarios($this, $calculator);
    }

+    #[CoversNothing]
    public function testMethodisSupported(): void
    {
        $calculator = new FactorGraphTrueSkillCalculator();
-        $this->assertEquals(TRUE, $calculator->isSupported(SkillCalculatorSupportedOptions::PARTIAL_PLAY));
+        $this->assertEquals(TRUE, $calculator->isSupported(SkillCalculator::PARTIAL_PLAY));
    }
 }
--- a/tests/TrueSkill/TrueSkillCalculatorTests.php
+++ b/tests/TrueSkill/TrueSkillCalculatorTests.php
@ -9,14 +9,13 @@ use DNW\Skills\Player;
 use DNW\Skills\Rating;
 use DNW\Skills\SkillCalculator;
 use DNW\Skills\Team;
-use DNW\Skills\Teams;
 use PHPUnit\Framework\TestCase;

-class TrueSkillCalculatorTests
+final class TrueSkillCalculatorTests
 {
-    private const ERROR_TOLERANCE_TRUESKILL = 0.085;
+    private const float ERROR_TOLERANCE_TRUESKILL = 0.085;

-    private const ERROR_TOLERANCE_MATCH_QUALITY = 0.0005;
+    private const float ERROR_TOLERANCE_MATCH_QUALITY = 0.0005;

    // These are the roll-up ones

@ -70,7 +69,6 @@ class TrueSkillCalculatorTests
    // online calculator at http://atom.research.microsoft.com/trueskill/rankcalculator.aspx
    //
    // All match quality expected values came from the online calculator
-
    // In both cases, there may be some discrepancy after the first decimal point. I think this is due to my implementation
    // using slightly higher precision in GaussianDistribution.

@ -813,15 +811,15 @@ class TrueSkillCalculatorTests

    private static function sixteenTeamsOfOneNotDrawn(TestCase $testClass, SkillCalculator $calculator): void
    {
-        $player1 = new Player(1);
-        $player2 = new Player(2);
-        $player3 = new Player(3);
-        $player4 = new Player(4);
-        $player5 = new Player(5);
-        $player6 = new Player(6);
-        $player7 = new Player(7);
-        $player8 = new Player(8);
-        $player9 = new Player(9);
+        $player1  = new Player(1);
+        $player2  = new Player(2);
+        $player3  = new Player(3);
+        $player4  = new Player(4);
+        $player5  = new Player(5);
+        $player6  = new Player(6);
+        $player7  = new Player(7);
+        $player8  = new Player(8);
+        $player9  = new Player(9);
        $player10 = new Player(10);
        $player11 = new Player(11);
        $player12 = new Player(12);
@ -832,15 +830,15 @@ class TrueSkillCalculatorTests

        $gameInfo = new GameInfo();

-        $team1 = new Team($player1, $gameInfo->getDefaultRating());
-        $team2 = new Team($player2, $gameInfo->getDefaultRating());
-        $team3 = new Team($player3, $gameInfo->getDefaultRating());
-        $team4 = new Team($player4, $gameInfo->getDefaultRating());
-        $team5 = new Team($player5, $gameInfo->getDefaultRating());
-        $team6 = new Team($player6, $gameInfo->getDefaultRating());
-        $team7 = new Team($player7, $gameInfo->getDefaultRating());
-        $team8 = new Team($player8, $gameInfo->getDefaultRating());
-        $team9 = new Team($player9, $gameInfo->getDefaultRating());
+        $team1 =  new Team($player1, $gameInfo->getDefaultRating());
+        $team2 =  new Team($player2, $gameInfo->getDefaultRating());
+        $team3 =  new Team($player3, $gameInfo->getDefaultRating());
+        $team4 =  new Team($player4, $gameInfo->getDefaultRating());
+        $team5 =  new Team($player5, $gameInfo->getDefaultRating());
+        $team6 =  new Team($player6, $gameInfo->getDefaultRating());
+        $team7 =  new Team($player7, $gameInfo->getDefaultRating());
+        $team8 =  new Team($player8, $gameInfo->getDefaultRating());
+        $team9 =  new Team($player9, $gameInfo->getDefaultRating());
        $team10 = new Team($player10, $gameInfo->getDefaultRating());
        $team11 = new Team($player11, $gameInfo->getDefaultRating());
        $team12 = new Team($player12, $gameInfo->getDefaultRating());
@ -849,24 +847,7 @@ class TrueSkillCalculatorTests
        $team15 = new Team($player15, $gameInfo->getDefaultRating());
        $team16 = new Team($player16, $gameInfo->getDefaultRating());

-        $teams = [
-            $team1,
-            $team2,
-            $team3,
-            $team4,
-            $team5,
-            $team6,
-            $team7,
-            $team8,
-            $team9,
-            $team10,
-            $team11,
-            $team12,
-            $team13,
-            $team14,
-            $team15,
-            $team16
-        ];
+        $teams = [$team1, $team2, $team3, $team4, $team5, $team6, $team7, $team8, $team9, $team10, $team11, $team12, $team13, $team14, $team15, $team16];

        $newRatings = $calculator->calculateNewRatings(
            $gameInfo,
--- a/tests/TrueSkill/TruncatedGaussianCorrectionFunctionsTest.php
+++ b/tests/TrueSkill/TruncatedGaussianCorrectionFunctionsTest.php
@ -14,7 +14,7 @@ use PHPUnit\Framework\Attributes\UsesClass;
 #[CoversClass(TruncatedGaussianCorrectionFunctions::class)]
 #[UsesClass(BasicMath::class)]
 #[UsesClass(GaussianDistribution::class)]
-class TruncatedGaussianCorrectionFunctionsTest extends TestCase
+final class TruncatedGaussianCorrectionFunctionsTest extends TestCase
 {
    public function testvGreaterThan(): void
    {
--- a/tests/TrueSkill/TwoPlayerTrueSkillCalculatorTest.php
+++ b/tests/TrueSkill/TwoPlayerTrueSkillCalculatorTest.php
@ -6,11 +6,9 @@ namespace DNW\Skills\Tests\TrueSkill;

 use DNW\Skills\TrueSkill\TwoPlayerTrueSkillCalculator;
 use PHPUnit\Framework\TestCase;
-use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\CoversNothing;

-#[CoversClass(TwoPlayerTrueSkillCalculator::class)]
-class TwoPlayerTrueSkillCalculatorTest extends TestCase
+final class TwoPlayerTrueSkillCalculatorTest extends TestCase
 {
    #[CoversNothing]
    public function testTwoPlayerTrueSkillCalculator(): void
--- a/tests/TrueSkill/TwoTeamTrueSkillCalculatorTest.php
+++ b/tests/TrueSkill/TwoTeamTrueSkillCalculatorTest.php
@ -6,11 +6,9 @@ namespace DNW\Skills\Tests\TrueSkill;

 use DNW\Skills\TrueSkill\TwoTeamTrueSkillCalculator;
 use PHPUnit\Framework\TestCase;
-use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\CoversNothing;

-#[CoversClass(TwoTeamTrueSkillCalculator::class)]
-class TwoTeamTrueSkillCalculatorTest extends TestCase
+final class TwoTeamTrueSkillCalculatorTest extends TestCase
 {
    #[CoversNothing]
    public function testTwoTeamTrueSkillCalculator(): void
Author	SHA1	Message	Date
Jens True	ec2e637315	Warning removal	2025-07-08 09:41:38 +00:00
Jens True	1d06fa0b0a	Requirement update	2025-06-24 12:55:00 +00:00
Jens True	a097fa7f71	Few more comments	2025-06-18 11:49:40 +00:00
Jens True	ad9d7f94de	Upodate PHPUnit to latest version	2025-06-06 14:24:46 +00:00
Jens True	1725979b1c	Bumping versions	2025-06-02 08:49:46 +00:00
Jens True	ac7e3f5c2d	CodeStandard as HTML / MarkDown	2025-05-14 09:28:51 +00:00
Jens True	adc587ac0d	More coding standards. Diagrams in API documentation	2025-05-13 12:46:11 +00:00
Jens True	d729caac1f	Simplifying some casts	2025-05-12 09:40:44 +00:00
Jens True	bd9fccb87b	Regular updates and fixing static analysis findings	2025-05-12 09:19:17 +00:00
Jens True	55656b7889	More standards	2025-04-29 13:21:47 +00:00
Jens True	38f332b223	Continuing the process of making this modern	2025-04-25 09:22:08 +00:00
Jens True	b38a9656eb	Much stricter coding standards for phpstan, phpstan and psalm.	2025-04-15 08:14:08 +00:00
Jens True	3c617e9869	Move	2025-04-01 11:53:37 +00:00
Jens True	5a414b8307	More warnings from Psalm. Reduced Psalm config size	2025-01-28 09:38:14 +00:00
Jens True	e2620fde53	PHP8.3 style overrides added	2025-01-28 09:20:03 +00:00
Jens True	22002891c5	Upgrade to PHP8.4	2025-01-28 09:18:50 +00:00
Jens True	2212d45f61	Package update and implemented new fixes for Rector findings	2025-01-13 08:57:13 +00:00
Jens True	24665d6e57	PHPCBF added All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2024-09-13 07:26:48 +00:00
Jens True	79f4495a77	Package update All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2024-09-12 13:36:35 +00:00
Jens True	9df860b08b	SkillTest deprecated method All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2024-08-16 07:57:08 +00:00
Jens True	1e381bfab7	Quality of life All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2024-07-31 07:27:13 +00:00
Jens True	f6acee18e5	More tests more resistance to mutation testing. All checks were successful ci/woodpecker/manual/woodpecker Pipeline was successful Details	2024-07-25 11:24:13 +00:00
Jens True	1b7e26a6b5	Requirements update. (Psalm to dev but analysis tool only)	2024-07-23 10:04:02 +00:00
Jens True	cf588f3fc2	PHPMD reintroduced.	2024-07-04 09:38:03 +00:00
Jens True	5dc0c7058d	Readding metrics to output	2024-07-01 09:31:35 +00:00
Jens True	ed9013df34	Typical update	2024-06-18 12:50:00 +00:00
Jens True	da5d782e40	Simplifying	2024-05-21 12:24:59 +00:00