From c352a22394bb4c945fa9b4b864422cedd2628223 Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Sat, 22 Aug 2026 16:14:32 -0400
Subject: [PATCH 1/3] Improved Time.Intersection to be branchless.  Added unit
 tests.

---
 src/TMG-Framework/Data/Time.cs            |  72 +++++---------
 tests/TMG-Framework.Test/Data/TimeTest.cs | 110 ++++++++++++++++++++++
 2 files changed, 133 insertions(+), 49 deletions(-)
 create mode 100644 tests/TMG-Framework.Test/Data/TimeTest.cs

diff --git a/src/TMG-Framework/Data/Time.cs b/src/TMG-Framework/Data/Time.cs
index 1fe76a6..2ca007e 100644
--- a/src/TMG-Framework/Data/Time.cs
+++ b/src/TMG-Framework/Data/Time.cs
@@ -27,12 +27,6 @@ namespace TMG
     /// </summary>
     public struct Time : IComparable<Time>
     {
-        public static Time EndOfDay = new Time() { Hours = 28 };
-
-        public static Time OneQuantum;
-
-        public static Time StartOfDay = new Time() { Hours = 4 };
-
         /// <summary>
         /// Our internal representation, to the millisecond
         /// </summary>
@@ -52,7 +46,14 @@ public Time(float time)
 
         public Time(DateTime time)
         {
-            _internalTime = ((60 * (60 * time.Hour) + time.Minute) + time.Second) * 1000 + time.Millisecond;
+            var hours = time.Hour;
+            var minutes = time.Minute;
+            var seconds = time.Second;
+            var milliseconds = time.Millisecond;
+            var hourToMilliseconds = hours * 3600000L;
+            var minuteToMilliseconds = minutes * 60000L;
+            var secondToMilliseconds = seconds * 1000L;
+            _internalTime = (hourToMilliseconds + minuteToMilliseconds) + (secondToMilliseconds + milliseconds);
         }
 
         /// <summary>
@@ -115,52 +116,25 @@ public static bool Intersection(Time start1, Time end1, Time start2, Time end2)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool Intersection(Time start1, Time end1, Time start2, Time end2, out Time intersection)
         {
-            if ((end1._internalTime < start2._internalTime)
-                | (end2._internalTime < start1._internalTime))
-            {
-                intersection = new Time();
-                return false;
-            }
-            // passenger is first
-            if (start1._internalTime <= start2._internalTime)
-            {
-                intersection._internalTime =
-                    (end1._internalTime >= end2._internalTime) ? end2._internalTime - start2._internalTime : end1._internalTime - start2._internalTime;
-                return true;
-            }
-            else
-            {
-                // passenger is second
-                intersection._internalTime =
-                    (end1._internalTime >= end2._internalTime) ? end2._internalTime - start1._internalTime : end1._internalTime - start1._internalTime;
-                return true;
-            }
+            var intersectionStart = Math.Max(start1._internalTime, start2._internalTime);
+            var intersectionEnd = Math.Min(end1._internalTime, end2._internalTime);
+            var intersectionDuration = intersectionEnd - intersectionStart;
+            var mask = ~(intersectionDuration >> 63);
+
+            intersection._internalTime = intersectionDuration & mask;
+            return mask != 0L;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool Intersection(Time start1, Time end1, Time start2, Time end2, out Time intersectionStart, out Time intersectionEnd)
         {
-            if (end1._internalTime < start2._internalTime
-                || end2._internalTime < start1._internalTime)
-            {
-                intersectionStart = new Time();
-                intersectionEnd = new Time();
-                return false;
-            }
-            // passenger is first
-            if (start1._internalTime <= start2._internalTime)
-            {
-                intersectionStart._internalTime = start2._internalTime;
-                intersectionEnd._internalTime = (end1._internalTime >= end2._internalTime) ? end2._internalTime : end1._internalTime;
-                return true;
-            }
-            else
-            {
-                // passenger is second
-                intersectionStart._internalTime = start1._internalTime;
-                intersectionEnd._internalTime = (end1._internalTime >= end2._internalTime) ? end2._internalTime : end1._internalTime;
-                return true;
-            }
+            var start = Math.Max(start1._internalTime, start2._internalTime);
+            var end = Math.Min(end1._internalTime, end2._internalTime);
+            var mask = ~((end - start) >> 63);
+
+            intersectionStart._internalTime = start & mask;
+            intersectionEnd._internalTime = end & mask;
+            return mask != 0L;
         }
 
         /// <summary>
@@ -497,7 +471,7 @@ public static bool TryParse(
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public int CompareTo(Time other)
         {
-            return _internalTime < other._internalTime ? -1 : (_internalTime == other._internalTime ? 0 : 1);
+            return _internalTime.CompareTo(other._internalTime);
         }
 
         public override bool Equals(object? obj)
diff --git a/tests/TMG-Framework.Test/Data/TimeTest.cs b/tests/TMG-Framework.Test/Data/TimeTest.cs
new file mode 100644
index 0000000..4e44d87
--- /dev/null
+++ b/tests/TMG-Framework.Test/Data/TimeTest.cs
@@ -0,0 +1,110 @@
+/*
+    Copyright 2026 University of Toronto
+
+    This file is part of TMG-Framework for XTMF2.
+
+    TMG-Framework for XTMF2 is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    TMG-Framework for XTMF2 is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace TMG.Test.Data;
+
+    [TestClass]
+    public class TimeTest
+    {
+        [TestMethod]
+        public void IntersectionBool_ReturnsTrue_WhenIntervalsOverlap()
+        {
+            var start1 = At(8, 0);
+            var end1 = At(9, 0);
+            var start2 = At(8, 30);
+            var end2 = At(10, 0);
+
+            var hasIntersection = Time.Intersection(start1, end1, start2, end2);
+
+            Assert.IsTrue(hasIntersection);
+        }
+
+        [TestMethod]
+        public void IntersectionDuration_ReturnsExpectedDuration_WhenIntervalsOverlap()
+        {
+            var start1 = At(8, 0);
+            var end1 = At(9, 0);
+            var start2 = At(8, 30);
+            var end2 = At(10, 0);
+
+            var hasIntersection = Time.Intersection(start1, end1, start2, end2, out var duration);
+
+            Assert.IsTrue(hasIntersection);
+            Assert.AreEqual(At(0, 30), duration);
+        }
+
+        [TestMethod]
+        public void IntersectionDuration_ReturnsZeroDuration_WhenIntervalsTouch()
+        {
+            var start1 = At(8, 0);
+            var end1 = At(9, 0);
+            var start2 = At(9, 0);
+            var end2 = At(10, 0);
+
+            var hasIntersection = Time.Intersection(start1, end1, start2, end2, out var duration);
+
+            Assert.IsTrue(hasIntersection);
+            Assert.AreEqual(Time.Zero, duration);
+        }
+
+        [TestMethod]
+        public void IntersectionBounds_ReturnsExpectedStartAndEnd_WhenIntervalsOverlap()
+        {
+            var start1 = At(8, 0);
+            var end1 = At(9, 0);
+            var start2 = At(8, 30);
+            var end2 = At(10, 0);
+
+            var hasIntersection = Time.Intersection(start1, end1, start2, end2, out var intersectionStart, out var intersectionEnd);
+
+            Assert.IsTrue(hasIntersection);
+            Assert.AreEqual(At(8, 30), intersectionStart);
+            Assert.AreEqual(At(9, 0), intersectionEnd);
+        }
+
+        [TestMethod]
+        public void IntersectionOutputs_ReturnFalseAndZeroValues_WhenNoOverlap()
+        {
+            var start1 = At(8, 0);
+            var end1 = At(8, 30);
+            var start2 = At(9, 0);
+            var end2 = At(10, 0);
+
+            var hasDurationIntersection = Time.Intersection(start1, end1, start2, end2, out var duration);
+            var hasBoundIntersection = Time.Intersection(start1, end1, start2, end2, out var intersectionStart, out var intersectionEnd);
+
+            Assert.IsFalse(hasDurationIntersection);
+            Assert.AreEqual(Time.Zero, duration);
+            Assert.IsFalse(hasBoundIntersection);
+            Assert.AreEqual(Time.Zero, intersectionStart);
+            Assert.AreEqual(Time.Zero, intersectionEnd);
+        }
+
+        private static Time At(int hours, int minutes, int seconds = 0)
+        {
+            return new Time()
+            {
+                Hours = hours,
+                Minutes = minutes,
+                Seconds = seconds
+            };
+        }
+    }

From 2e455404a913e6cebe537b2e2d8f19565a73c3f3 Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Sat, 22 Aug 2026 16:41:36 -0400
Subject: [PATCH 2/3] Modernize tests with update namespace and global usings

---
 .../ArbitaryParameterParser.cs                |  186 +-
 .../TestConstructTimePeriodFromTimes.cs       |   10 +-
 .../Convert/TestConvertTimesToTimePeriod.cs   |    9 +-
 .../TMG-Framework.Test/Data/CategoriesTest.cs |   43 +-
 .../Data/CategoryMapTest.cs                   |  159 +-
 tests/TMG-Framework.Test/Data/MatrixTest.cs   |   84 +-
 tests/TMG-Framework.Test/Data/RangeSetTest.cs |   25 +-
 tests/TMG-Framework.Test/Data/RangeTest.cs    |  145 +-
 tests/TMG-Framework.Test/Data/TimeTest.cs     |  146 +-
 tests/TMG-Framework.Test/Data/VectorTest.cs   |   55 +-
 .../TMG-Framework.Test/EnsureRuntimeLaunch.cs |   21 +-
 tests/TMG-Framework.Test/GlobalUsings.cs      |    8 +
 ...stLoadCategoryMapFromThirdNormalizedCSV.cs |  260 ++-
 .../Loading/TestLoadMapFromCSV.cs             |   52 +-
 .../Loading/TestLoadMatrix.cs                 |  252 ++-
 .../Loading/TestLoadVector.cs                 |    4 +-
 .../Processing/TestAppendMatrixValueToCSV.cs  |  124 +-
 .../Processing/TestEvaluateMatrix.cs          |   43 +-
 .../Processing/TestEvaluateScalar.cs          |   40 +-
 .../Processing/TestEvaluateVector.cs          |   44 +-
 .../TestExecutePipelineInOrderParallel.cs     |   54 +-
 .../Processing/TestGravityModel.cs            |   71 +-
 .../Processing/TestIntegerizeMatrix.cs        |  194 +-
 .../Saving/TestSaveMatrixAsCSV.cs             |  238 +--
 .../Saving/TestSaveMatrixAsMTX.cs             |   97 +-
 .../Saving/TestSaveVectorAsCSV.cs             |  144 +-
 .../Select/TestSelectGivenTime.cs             |   41 +-
 .../TMG-Framework.Test.csproj                 |    1 +
 tests/TMG-Framework.Test/Utilities/Helper.cs  |  199 +-
 .../TMG-Framework.Test/Utilities/MapHelper.cs |  117 +-
 .../Utilities/MatrixHelper.cs                 |  190 +-
 .../Utilities/TestCSVReader.cs                |  441 ++--
 .../Utilities/TestCompiler.cs                 | 1862 ++++++++---------
 .../VectorHelper/Conditions/TestFlagAnd.cs    |    3 +-
 .../Conditions/TestFlagIfEquals.cs            |    2 -
 .../Conditions/TestFlagIfGreaterThan.cs       |    3 +-
 .../TestFlagIfGreaterThanOrEqual.cs           |    3 +-
 .../Conditions/TestFlagIfLessThan.cs          |    3 +-
 .../Conditions/TestFlagIfLessThanOrEqual.cs   |    3 +-
 .../Conditions/TestFlagIfNotEquals.cs         |    3 +-
 .../VectorHelper/Conditions/TestFlagOr.cs     |    3 +-
 .../Utilities/VectorHelper/TestAdd.cs         |    2 -
 .../Utilities/VectorHelper/TestDivide.cs      |    3 +-
 .../Utilities/VectorHelper/TestExp.cs         |    3 -
 .../VectorHelper/TestFusedMultiplyAdd.cs      |    3 +-
 .../Utilities/VectorHelper/TestIf.cs          |    3 +-
 .../Utilities/VectorHelper/TestLog.cs         |    3 -
 .../Utilities/VectorHelper/TestMultiply.cs    |    3 +-
 .../Utilities/VectorHelper/TestPow.cs         |    2 -
 .../Utilities/VectorHelper/TestSubtract.cs    |    3 +-
 .../Utilities/VectorHelper/VectorHelper.cs    |   32 -
 51 files changed, 2613 insertions(+), 2826 deletions(-)
 create mode 100644 tests/TMG-Framework.Test/GlobalUsings.cs
 delete mode 100644 tests/TMG-Framework.Test/Utilities/VectorHelper/VectorHelper.cs

diff --git a/tests/TMG-Framework.Test/ArbitaryParameterParser.cs b/tests/TMG-Framework.Test/ArbitaryParameterParser.cs
index 76012c8..4c718a7 100644
--- a/tests/TMG-Framework.Test/ArbitaryParameterParser.cs
+++ b/tests/TMG-Framework.Test/ArbitaryParameterParser.cs
@@ -16,124 +16,122 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using XTMF2;
 
-namespace XTMF.Testing
+namespace XTMF.Testing;
+
+[TestClass]
+public class ArbitraryParameterParserTest
 {
-    [TestClass]
-    public class ArbitraryParameterParserTest
+    [TestMethod]
+    public void TestCharParsing()
     {
-        [TestMethod]
-        public void TestCharParsing()
+        string? error = null;
+        var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(char), "1", ref error);
+        if (!(obj.Value is char))
         {
-            string? error = null;
-            var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(char), "1", ref error);
-            if (!(obj.Value is char))
-            {
-                Assert.Fail("We should be able to parse a number!");
-            }
-            obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(char), "as", ref error);
-            if (obj.Sucess || error == null)
-            {
-                Assert.Fail("We need to make sure that invalid data doesn't get parsed");
-            }
+            Assert.Fail("We should be able to parse a number!");
         }
+        obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(char), "as", ref error);
+        if (obj.Sucess || error == null)
+        {
+            Assert.Fail("We need to make sure that invalid data doesn't get parsed");
+        }
+    }
 
-        [TestMethod]
-        public void TestDateTimeParsing()
+    [TestMethod]
+    public void TestDateTimeParsing()
+    {
+        string? error = null;
+        var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(DateTime), "10:00 AM", ref error);
+        if (!(obj.Value is DateTime))
         {
-            string? error = null;
-            var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(DateTime), "10:00 AM", ref error);
-            if (!(obj.Value is DateTime))
-            {
-                Assert.Fail("We should be able to parse a DateTime!");
-            }
-            obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(DateTime), "123211231:123:321", ref error);
-            if (obj.Sucess || error == null)
-            {
-                Assert.Fail("We need to make sure that invalid data doesn't get parsed");
-            }
+            Assert.Fail("We should be able to parse a DateTime!");
+        }
+        obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(DateTime), "123211231:123:321", ref error);
+        if (obj.Sucess || error == null)
+        {
+            Assert.Fail("We need to make sure that invalid data doesn't get parsed");
         }
+    }
 
-        [TestMethod]
-        public void TestFloatParsing()
+    [TestMethod]
+    public void TestFloatParsing()
+    {
+        string? error = null;
+        var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(float), "12345.123", ref error);
+        if (!(obj.Value is float))
         {
-            string? error = null;
-            var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(float), "12345.123", ref error);
-            if (!(obj.Value is float))
-            {
-                Assert.Fail("We should be able to parse a number!");
-            }
-            obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(float), "asdbasd.321", ref error);
-            if (obj.Sucess || error == null)
-            {
-                Assert.Fail("We need to make sure that invalid data doesn't get parsed");
-            }
+            Assert.Fail("We should be able to parse a number!");
         }
+        obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(float), "asdbasd.321", ref error);
+        if (obj.Sucess || error == null)
+        {
+            Assert.Fail("We need to make sure that invalid data doesn't get parsed");
+        }
+    }
 
-        [TestMethod]
-        public void TestIntegerParsing()
+    [TestMethod]
+    public void TestIntegerParsing()
+    {
+        string? error = null;
+        var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(int), "12345", ref error);
+        if (!(obj.Value is int))
         {
-            string? error = null;
-            var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(int), "12345", ref error);
-            if (!(obj.Value is int))
-            {
-                Assert.Fail("We should be able to parse a number!");
-            }
-            obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(int), "asdbasd", ref error);
-            if (obj.Sucess || error == null)
-            {
-                Assert.Fail("We need to make sure that invalid data doesn't get parsed");
-            }
+            Assert.Fail("We should be able to parse a number!");
+        }
+        obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(int), "asdbasd", ref error);
+        if (obj.Sucess || error == null)
+        {
+            Assert.Fail("We need to make sure that invalid data doesn't get parsed");
         }
+    }
 
-        [TestMethod]
-        public void TestStringParsing()
+    [TestMethod]
+    public void TestStringParsing()
+    {
+        string? error = null;
+        var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(string), "12345.123", ref error);
+        if (!(obj.Value is string))
         {
-            string? error = null;
-            var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(string), "12345.123", ref error);
-            if (!(obj.Value is string))
-            {
-                Assert.Fail("We should be able to parse a string!");
-            }
-            obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(string), "asdbasd.321", ref error);
-            if (!obj.Sucess || error != null)
-            {
-                Assert.Fail("Strings should always be \"parsed\"");
-            }
+            Assert.Fail("We should be able to parse a string!");
         }
+        obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(string), "asdbasd.321", ref error);
+        if (!obj.Sucess || error != null)
+        {
+            Assert.Fail("Strings should always be \"parsed\"");
+        }
+    }
 
-        [TestMethod]
-        public void TestTestStructParsing()
+    [TestMethod]
+    public void TestTestStructParsing()
+    {
+        string? error = null;
+        var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(TestStruct), "10:00 AM", ref error);
+        if (!(obj.Value is TestStruct))
         {
-            string? error = null;
-            var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(TestStruct), "10:00 AM", ref error);
-            if (!(obj.Value is TestStruct))
-            {
-                Assert.Fail("We should be able to parse a TestStruct!");
-            }
-            obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(TestStruct), "", ref error);
-            if (obj.Sucess || error == null)
-            {
-                Assert.Fail("We need to make sure that invalid data doesn't get parsed");
-            }
+            Assert.Fail("We should be able to parse a TestStruct!");
+        }
+        obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(TestStruct), "", ref error);
+        if (obj.Sucess || error == null)
+        {
+            Assert.Fail("We need to make sure that invalid data doesn't get parsed");
         }
+    }
 
-        private struct TestStruct
+    private struct TestStruct
+    {
+        // ReSharper disable once UnusedMember.Local
+        public static bool TryParse(ref string? error, string input, out TestStruct output)
         {
-            // ReSharper disable once UnusedMember.Local
-            public static bool TryParse(ref string? error, string input, out TestStruct output)
+            output = default(TestStruct);
+            if (input.Length > 0)
             {
-                output = default(TestStruct);
-                if (input.Length > 0)
-                {
-                    return true;
-                }
-                error = "Length needs to be greater than zero!";
-                return false;
+                return true;
             }
+            error = "Length needs to be greater than zero!";
+            return false;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/TMG-Framework.Test/Construct/TestConstructTimePeriodFromTimes.cs b/tests/TMG-Framework.Test/Construct/TestConstructTimePeriodFromTimes.cs
index 066474e..3843866 100644
--- a/tests/TMG-Framework.Test/Construct/TestConstructTimePeriodFromTimes.cs
+++ b/tests/TMG-Framework.Test/Construct/TestConstructTimePeriodFromTimes.cs
@@ -17,15 +17,7 @@ You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using TMG;
-
-using TMG.Frameworks.Data.Processing.AST;
-using TMG.Processing;
-using TMG.Select;
-using TMG.Test.Utilities;
+global using System;using TMG.Test.Utilities;
 
 namespace TMG.Test.Construct
 {
diff --git a/tests/TMG-Framework.Test/Convert/TestConvertTimesToTimePeriod.cs b/tests/TMG-Framework.Test/Convert/TestConvertTimesToTimePeriod.cs
index 31d5056..1a474ad 100644
--- a/tests/TMG-Framework.Test/Convert/TestConvertTimesToTimePeriod.cs
+++ b/tests/TMG-Framework.Test/Convert/TestConvertTimesToTimePeriod.cs
@@ -17,15 +17,8 @@ You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using TMG;
 using TMG.Convert;
-using TMG.Frameworks.Data.Processing.AST;
-using TMG.Processing;
-using TMG.Select;
-using TMG.Test.Utilities;
+
 
 namespace TMG.Test.Convert
 {
diff --git a/tests/TMG-Framework.Test/Data/CategoriesTest.cs b/tests/TMG-Framework.Test/Data/CategoriesTest.cs
index c5bcf69..2e35003 100644
--- a/tests/TMG-Framework.Test/Data/CategoriesTest.cs
+++ b/tests/TMG-Framework.Test/Data/CategoriesTest.cs
@@ -16,34 +16,29 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using XTMF2;
-using System.Reflection;
-using System.Collections.Generic;
 
-namespace TMG.Test.Data
+namespace TMG.Test.Data;
+
+[TestClass]
+public class CategoriesTest
 {
-    [TestClass]
-    public class CategoriesTest
+    [TestMethod]
+    public void CreateMap()
     {
-        [TestMethod]
-        public void CreateMap()
+        string? error = null;
+        var set = new List<int>() { 2, 6, 4, 8, 10 };
+        if (!Categories.CreateCategories(set, out var categories, ref error))
         {
-            string? error = null;
-            var set = new List<int>() { 2, 6, 4, 8, 10 };
-            if (!Categories.CreateCategories(set, out var categories, ref error))
-            {
-                Assert.Fail(error);
-            }
-            Assert.AreEqual(set.Count, categories.Count);
-            Assert.AreEqual((CategoryIndex)4, categories.GetSparseIndex(1));
-            Assert.AreEqual((CategoryIndex)6, categories.GetSparseIndex(2));
-
-            Assert.AreEqual(0, categories.GetFlatIndex(2));
-            Assert.AreEqual(1, categories.GetFlatIndex(4));
-            Assert.AreEqual(2, categories.GetFlatIndex(6));
-            Assert.AreEqual(3, categories.GetFlatIndex(8));
+            Assert.Fail(error);
         }
+        Assert.AreEqual(set.Count, categories.Count);
+        Assert.AreEqual((CategoryIndex)4, categories.GetSparseIndex(1));
+        Assert.AreEqual((CategoryIndex)6, categories.GetSparseIndex(2));
+
+        Assert.AreEqual(0, categories.GetFlatIndex(2));
+        Assert.AreEqual(1, categories.GetFlatIndex(4));
+        Assert.AreEqual(2, categories.GetFlatIndex(6));
+        Assert.AreEqual(3, categories.GetFlatIndex(8));
     }
 }
+
diff --git a/tests/TMG-Framework.Test/Data/CategoryMapTest.cs b/tests/TMG-Framework.Test/Data/CategoryMapTest.cs
index b4fbfb1..a143a11 100644
--- a/tests/TMG-Framework.Test/Data/CategoryMapTest.cs
+++ b/tests/TMG-Framework.Test/Data/CategoryMapTest.cs
@@ -16,111 +16,106 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.Text;
 
-namespace TMG.Test.Data
+namespace TMG.Test.Data;
+
+[TestClass]
+public class CategoryMapTest
 {
-    [TestClass]
-    public class CategoryMapTest
+    [TestMethod]
+    public void Aggregate()
     {
-        [TestMethod]
-        public void Aggregate()
+        string? error = null;
+        if (!Categories.CreateCategories(new List<int> { 1, 3, 5, 7 }, out var a, ref error))
         {
-            string? error = null;
-            if (!Categories.CreateCategories(new List<int> { 1, 3, 5, 7 }, out var a, ref error))
-            {
-                Assert.Fail(error);
-            }
-            Assert.IsNotNull(a, error);
-            if (!Categories.CreateCategories(new List<int> { 2, 4 }, out var b, ref error))
+            Assert.Fail(error);
+        }
+        Assert.IsNotNull(a, error);
+        if (!Categories.CreateCategories(new List<int> { 2, 4 }, out var b, ref error))
+        {
+            Assert.Fail(error);
+        }
+        Assert.IsNotNull(b, error);
+        Assert.IsTrue(CategoryMap.CreateCategoryMap(a, b,
+            new List<(int originFlatIndex, int destinationFlatIndex)>()
             {
-                Assert.Fail(error);
-            }
-            Assert.IsNotNull(b, error);
-            Assert.IsTrue(CategoryMap.CreateCategoryMap(a, b,
-                new List<(int originFlatIndex, int destinationFlatIndex)>()
-                {
                     (0, 0),
                     (1, 0),
                     (2, 1),
                     (3, 1)
-                }, out var map, ref error), error);
-            var va = new Vector(a);
-            va.Data[0] = 3;
-            va.Data[1] = 7;
-            va.Data[2] = 2;
-            va.Data[3] = 4;
-            Assert.IsTrue(map.AggregateToDestination(va, out var result, ref error), error);
-            Assert.AreEqual(2, result.Data.Length);
-            Assert.AreSame(b, result.Categories);
-            Assert.AreEqual(10, result.Data[0]);
-            Assert.AreEqual(6, result.Data[1]);
-        }
+            }, out var map, ref error), error);
+        var va = new Vector(a);
+        va.Data[0] = 3;
+        va.Data[1] = 7;
+        va.Data[2] = 2;
+        va.Data[3] = 4;
+        Assert.IsTrue(map.AggregateToDestination(va, out var result, ref error), error);
+        Assert.AreEqual(2, result.Data.Length);
+        Assert.AreSame(b, result.Categories);
+        Assert.AreEqual(10, result.Data[0]);
+        Assert.AreEqual(6, result.Data[1]);
+    }
 
-        [TestMethod]
-        public void CreateIndex()
+    [TestMethod]
+    public void CreateIndex()
+    {
+        string? error = null;
+        if (!Categories.CreateCategories(new List<int> { 1, 3, 5, 7 }, out var a, ref error))
         {
-            string? error = null;
-            if (!Categories.CreateCategories(new List<int> { 1, 3, 5, 7 }, out var a, ref error))
-            {
-                Assert.Fail(error);
-            }
-            Assert.IsNotNull(a, error);
-            if (!Categories.CreateCategories(new List<int> { 2, 4 }, out var b, ref error))
+            Assert.Fail(error);
+        }
+        Assert.IsNotNull(a, error);
+        if (!Categories.CreateCategories(new List<int> { 2, 4 }, out var b, ref error))
+        {
+            Assert.Fail(error);
+        }
+        Assert.IsNotNull(b, error);
+        Assert.IsTrue(CategoryMap.CreateCategoryMap(a, b,
+            new List<(int originFlatIndex, int destinationFlatIndex)>()
             {
-                Assert.Fail(error);
-            }
-            Assert.IsNotNull(b, error);
-            Assert.IsTrue(CategoryMap.CreateCategoryMap(a, b,
-                new List<(int originFlatIndex, int destinationFlatIndex)>()
-                {
                     (0, 0),
                     (1, 0),
                     (2, 1),
                     (3, 1)
-                }, out var map, ref error), error);
-            var index = map.CreateIndex();
-            Assert.AreEqual(0, (int)index[0]);
-            Assert.AreEqual(0, (int)index[1]);
-            Assert.AreEqual(1, (int)index[2]);
-            Assert.AreEqual(1, (int)index[3]);
-        }
+            }, out var map, ref error), error);
+        var index = map.CreateIndex();
+        Assert.AreEqual(0, (int)index[0]);
+        Assert.AreEqual(0, (int)index[1]);
+        Assert.AreEqual(1, (int)index[2]);
+        Assert.AreEqual(1, (int)index[3]);
+    }
 
-        [TestMethod]
-        public void CreateReverseIndex()
+    [TestMethod]
+    public void CreateReverseIndex()
+    {
+        string? error = null;
+        if (!Categories.CreateCategories(new List<int> { 1, 3, 5, 7 }, out var a, ref error))
         {
-            string? error = null;
-            if (!Categories.CreateCategories(new List<int> { 1, 3, 5, 7 }, out var a, ref error))
-            {
-                Assert.Fail(error);
-            }
-            Assert.IsNotNull(a, error);
-            if (!Categories.CreateCategories(new List<int> { 2, 4 }, out var b, ref error))
+            Assert.Fail(error);
+        }
+        Assert.IsNotNull(a, error);
+        if (!Categories.CreateCategories(new List<int> { 2, 4 }, out var b, ref error))
+        {
+            Assert.Fail(error);
+        }
+        Assert.IsNotNull(b, error);
+        Assert.IsTrue(CategoryMap.CreateCategoryMap(a, b,
+            new List<(int originFlatIndex, int destinationFlatIndex)>()
             {
-                Assert.Fail(error);
-            }
-            Assert.IsNotNull(b, error);
-            Assert.IsTrue(CategoryMap.CreateCategoryMap(a, b,
-                new List<(int originFlatIndex, int destinationFlatIndex)>()
-                {
                     (0, 0),
                     (1, 0),
                     (2, 1),
                     (3, 1)
-                }, out var map, ref error), error);
-            var index = map.CreateReverseIndex();
-            var list = index[0];
-            Assert.HasCount(2, list);
-            Assert.AreEqual(0, (int)list[0]);
-            Assert.AreEqual(1, (int)list[1]);
+            }, out var map, ref error), error);
+        var index = map.CreateReverseIndex();
+        var list = index[0];
+        Assert.HasCount(2, list);
+        Assert.AreEqual(0, (int)list[0]);
+        Assert.AreEqual(1, (int)list[1]);
 
-            list = index[1];
-            Assert.HasCount(2, list);
-            Assert.AreEqual(2, (int)list[0]);
-            Assert.AreEqual(3, (int)list[1]);
-        }
+        list = index[1];
+        Assert.HasCount(2, list);
+        Assert.AreEqual(2, (int)list[0]);
+        Assert.AreEqual(3, (int)list[1]);
     }
 }
diff --git a/tests/TMG-Framework.Test/Data/MatrixTest.cs b/tests/TMG-Framework.Test/Data/MatrixTest.cs
index 5c9b127..e5f97d9 100644
--- a/tests/TMG-Framework.Test/Data/MatrixTest.cs
+++ b/tests/TMG-Framework.Test/Data/MatrixTest.cs
@@ -16,58 +16,52 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using XTMF2;
-using System.Reflection;
-using System.Collections.Generic;
 
-namespace TMG.Test.Data
+namespace TMG.Test.Data;
+
+[TestClass]
+public class MatrixTest
 {
-    [TestClass]
-    public class MatrixTest
+    [TestMethod]
+    public void CreateMatrix()
     {
-        [TestMethod]
-        public void CreateMatrix()
-        {
-            var categories = CreateMap();
-            var matrix = new Matrix(categories, categories);
-        }
+        var categories = CreateMap();
+        var matrix = new Matrix(categories, categories);
+    }
 
-        [TestMethod]
-        public void GetSparseRowIndex()
-        {
-            var categories = CreateMap();
-            var matrix = new Matrix(categories, categories);
-            var size = matrix.RowCategories.Count;
-            Assert.AreEqual(0, matrix.GetSparseRowIndex(2));
-            Assert.AreEqual(size * (3 - 1), matrix.GetSparseRowIndex(6));
-            Assert.AreEqual(size * (2 - 1), matrix.GetSparseRowIndex(4));
-            Assert.AreEqual(size * (size - 1), matrix.GetSparseRowIndex(10));
-            Assert.AreEqual(-1, matrix.GetSparseRowIndex(11));
-        }
+    [TestMethod]
+    public void GetSparseRowIndex()
+    {
+        var categories = CreateMap();
+        var matrix = new Matrix(categories, categories);
+        var size = matrix.RowCategories.Count;
+        Assert.AreEqual(0, matrix.GetSparseRowIndex(2));
+        Assert.AreEqual(size * (3 - 1), matrix.GetSparseRowIndex(6));
+        Assert.AreEqual(size * (2 - 1), matrix.GetSparseRowIndex(4));
+        Assert.AreEqual(size * (size - 1), matrix.GetSparseRowIndex(10));
+        Assert.AreEqual(-1, matrix.GetSparseRowIndex(11));
+    }
 
-        [TestMethod]
-        public void GetFlatRowIndex()
-        {
-            var categories = CreateMap();
-            var matrix = new Matrix(categories, categories);
-            var size = matrix.RowCategories.Count;
-            Assert.AreEqual(0, matrix.GetFlatRowIndex(0));
-            Assert.AreEqual(size * 1, matrix.GetFlatRowIndex(1));
-            Assert.AreEqual(size * 2, matrix.GetFlatRowIndex(2));
-            Assert.AreEqual(size * (size - 1), matrix.GetFlatRowIndex(size - 1));
-            Assert.AreEqual(-1, matrix.GetSparseRowIndex(7));
-        }
+    [TestMethod]
+    public void GetFlatRowIndex()
+    {
+        var categories = CreateMap();
+        var matrix = new Matrix(categories, categories);
+        var size = matrix.RowCategories.Count;
+        Assert.AreEqual(0, matrix.GetFlatRowIndex(0));
+        Assert.AreEqual(size * 1, matrix.GetFlatRowIndex(1));
+        Assert.AreEqual(size * 2, matrix.GetFlatRowIndex(2));
+        Assert.AreEqual(size * (size - 1), matrix.GetFlatRowIndex(size - 1));
+        Assert.AreEqual(-1, matrix.GetSparseRowIndex(7));
+    }
 
-        private static Categories CreateMap()
+    private static Categories CreateMap()
+    {
+        string? error = null;
+        if (!Categories.CreateCategories(new List<int>() { 2, 6, 4, 8, 10 }, out var categories, ref error))
         {
-            string? error = null;
-            if (!Categories.CreateCategories(new List<int>() { 2, 6, 4, 8, 10 }, out var categories, ref error))
-            {
-                Assert.Fail(error);
-            }
-            return categories;
+            Assert.Fail(error);
         }
+        return categories;
     }
 }
diff --git a/tests/TMG-Framework.Test/Data/RangeSetTest.cs b/tests/TMG-Framework.Test/Data/RangeSetTest.cs
index 602f2b7..1b6ba56 100644
--- a/tests/TMG-Framework.Test/Data/RangeSetTest.cs
+++ b/tests/TMG-Framework.Test/Data/RangeSetTest.cs
@@ -16,23 +16,18 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using XTMF2;
-using System.Reflection;
 
-namespace TMG.Test.Data
+namespace TMG.Test.Data;
+
+[TestClass]
+public class RangeSetTest
 {
-    [TestClass]
-    public class RangeSetTest
+    [TestMethod]
+    public void TestRangeSetIntList()
     {
-        [TestMethod]
-        public void TestRangeSetIntList()
-        {
-            RangeSet rangeSet = new RangeSet(new[] { 1, 2, 3, 4, 5, 7, 8, 9, 10 });
-            Assert.AreEqual(2, rangeSet.Count);
-            Assert.AreEqual(new Range(1, 5), rangeSet[0]);
-            Assert.AreEqual(new Range(7, 10), rangeSet[1]);
-        }
+        RangeSet rangeSet = new RangeSet(new[] { 1, 2, 3, 4, 5, 7, 8, 9, 10 });
+        Assert.AreEqual(2, rangeSet.Count);
+        Assert.AreEqual(new Range(1, 5), rangeSet[0]);
+        Assert.AreEqual(new Range(7, 10), rangeSet[1]);
     }
 }
diff --git a/tests/TMG-Framework.Test/Data/RangeTest.cs b/tests/TMG-Framework.Test/Data/RangeTest.cs
index abdef52..167c6bb 100644
--- a/tests/TMG-Framework.Test/Data/RangeTest.cs
+++ b/tests/TMG-Framework.Test/Data/RangeTest.cs
@@ -16,87 +16,85 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System.Collections.Generic;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
 
-namespace TMG.Data.Testing
+namespace TMG.Data.Testing;
+
+/// <summary>
+///This is a test class for RangeSetSeriesTest and is intended
+///to contain all RangeSetSeriesTest Unit Tests
+///</summary>
+[TestClass()]
+public class RangeSetSeriesTest
 {
     /// <summary>
-    ///This is a test class for RangeSetSeriesTest and is intended
-    ///to contain all RangeSetSeriesTest Unit Tests
+    ///A test for RangeSetSeries Constructor
     ///</summary>
-    [TestClass()]
-    public class RangeSetSeriesTest
+    [TestMethod()]
+    public void RangeSetSeriesConstructorTest()
     {
-        /// <summary>
-        ///A test for RangeSetSeries Constructor
-        ///</summary>
-        [TestMethod()]
-        public void RangeSetSeriesConstructorTest()
-        {
-            List<RangeSet> tempRange = GenerateTempRange();
-            RangeSetSet target = new RangeSetSet(tempRange);
-            Assert.AreEqual(2, target.Count);
-        }
+        List<RangeSet> tempRange = GenerateTempRange();
+        RangeSetSet target = new RangeSetSet(tempRange);
+        Assert.AreEqual(2, target.Count);
+    }
 
-        /// <summary>
-        ///A test for ToString
-        ///</summary>
-        [TestMethod()]
-        public void ToStringTest()
-        {
-            List<RangeSet> tempRange = GenerateTempRange();
-            RangeSetSet target = new RangeSetSet(tempRange);
-            string expected = "{1-2,4-5},{11-12,14-15}";
-            var actual = target.ToString();
-            Assert.AreEqual(expected, actual);
-        }
+    /// <summary>
+    ///A test for ToString
+    ///</summary>
+    [TestMethod()]
+    public void ToStringTest()
+    {
+        List<RangeSet> tempRange = GenerateTempRange();
+        RangeSetSet target = new RangeSetSet(tempRange);
+        string expected = "{1-2,4-5},{11-12,14-15}";
+        var actual = target.ToString();
+        Assert.AreEqual(expected, actual);
+    }
 
-        /// <summary>
-        ///A test for TryParse
-        ///</summary>
-        [TestMethod()]
-        public void TryParseTestFail()
-        {
-            string? error = null;
-            string rangeString = "{1-2,4-5},{11-12,14-15";
-            bool actual = RangeSetSet.TryParse(ref error, rangeString, out RangeSetSet? output);
-            Assert.IsNotNull(error);
-            Assert.IsNull(output);
-            Assert.IsFalse(actual);
-        }
+    /// <summary>
+    ///A test for TryParse
+    ///</summary>
+    [TestMethod()]
+    public void TryParseTestFail()
+    {
+        string? error = null;
+        string rangeString = "{1-2,4-5},{11-12,14-15";
+        bool actual = RangeSetSet.TryParse(ref error, rangeString, out RangeSetSet? output);
+        Assert.IsNotNull(error);
+        Assert.IsNull(output);
+        Assert.IsFalse(actual);
+    }
 
-        /// <summary>
-        ///A test for TryParse
-        ///</summary>
-        [TestMethod()]
-        public void TryParseTestNonError()
-        {
-            string rangeString = "{1-2,4-5},{11-12,14-15}";
-            RangeSetSet outputExpected = new RangeSetSet(GenerateTempRange());
-            var actual = RangeSetSet.TryParse(rangeString, out RangeSetSet? output);
-            Assert.AreEqual(outputExpected, output);
-            Assert.IsTrue(actual);
-        }
+    /// <summary>
+    ///A test for TryParse
+    ///</summary>
+    [TestMethod()]
+    public void TryParseTestNonError()
+    {
+        string rangeString = "{1-2,4-5},{11-12,14-15}";
+        RangeSetSet outputExpected = new RangeSetSet(GenerateTempRange());
+        var actual = RangeSetSet.TryParse(rangeString, out RangeSetSet? output);
+        Assert.AreEqual(outputExpected, output);
+        Assert.IsTrue(actual);
+    }
 
-        /// <summary>
-        ///A test for TryParse
-        ///</summary>
-        [TestMethod()]
-        public void TryParseTestSuccess()
-        {
-            string? error = null;
-            string rangeString = "{1-2,4-5},{11-12,14-15}";
-            RangeSetSet outputExpected = new RangeSetSet(GenerateTempRange());
-            var actual = RangeSetSet.TryParse(ref error, rangeString, out RangeSetSet? output);
-            Assert.IsNull(error);
-            Assert.AreEqual(outputExpected, output);
-            Assert.IsTrue(actual);
-        }
+    /// <summary>
+    ///A test for TryParse
+    ///</summary>
+    [TestMethod()]
+    public void TryParseTestSuccess()
+    {
+        string? error = null;
+        string rangeString = "{1-2,4-5},{11-12,14-15}";
+        RangeSetSet outputExpected = new RangeSetSet(GenerateTempRange());
+        var actual = RangeSetSet.TryParse(ref error, rangeString, out RangeSetSet? output);
+        Assert.IsNull(error);
+        Assert.AreEqual(outputExpected, output);
+        Assert.IsTrue(actual);
+    }
 
-        private static List<RangeSet> GenerateTempRange()
-        {
-            List<RangeSet> tempRange = new List<RangeSet>()
+    private static List<RangeSet> GenerateTempRange()
+    {
+        List<RangeSet> tempRange = new List<RangeSet>()
             {
                 new RangeSet(new List<Range>()
                 {
@@ -109,7 +107,6 @@ private static List<RangeSet> GenerateTempRange()
                     new Range(14, 15)
                 })
             };
-            return tempRange;
-        }
+        return tempRange;
     }
-}
\ No newline at end of file
+}
diff --git a/tests/TMG-Framework.Test/Data/TimeTest.cs b/tests/TMG-Framework.Test/Data/TimeTest.cs
index 4e44d87..2bade9a 100644
--- a/tests/TMG-Framework.Test/Data/TimeTest.cs
+++ b/tests/TMG-Framework.Test/Data/TimeTest.cs
@@ -17,94 +17,94 @@ You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 
 namespace TMG.Test.Data;
 
-    [TestClass]
-    public class TimeTest
+[TestClass]
+public class TimeTest
+{
+    [TestMethod]
+    public void IntersectionBool_ReturnsTrue_WhenIntervalsOverlap()
     {
-        [TestMethod]
-        public void IntersectionBool_ReturnsTrue_WhenIntervalsOverlap()
-        {
-            var start1 = At(8, 0);
-            var end1 = At(9, 0);
-            var start2 = At(8, 30);
-            var end2 = At(10, 0);
+        var start1 = At(8, 0);
+        var end1 = At(9, 0);
+        var start2 = At(8, 30);
+        var end2 = At(10, 0);
 
-            var hasIntersection = Time.Intersection(start1, end1, start2, end2);
+        var hasIntersection = Time.Intersection(start1, end1, start2, end2);
 
-            Assert.IsTrue(hasIntersection);
-        }
+        Assert.IsTrue(hasIntersection);
+    }
 
-        [TestMethod]
-        public void IntersectionDuration_ReturnsExpectedDuration_WhenIntervalsOverlap()
-        {
-            var start1 = At(8, 0);
-            var end1 = At(9, 0);
-            var start2 = At(8, 30);
-            var end2 = At(10, 0);
+    [TestMethod]
+    public void IntersectionDuration_ReturnsExpectedDuration_WhenIntervalsOverlap()
+    {
+        var start1 = At(8, 0);
+        var end1 = At(9, 0);
+        var start2 = At(8, 30);
+        var end2 = At(10, 0);
 
-            var hasIntersection = Time.Intersection(start1, end1, start2, end2, out var duration);
+        var hasIntersection = Time.Intersection(start1, end1, start2, end2, out var duration);
 
-            Assert.IsTrue(hasIntersection);
-            Assert.AreEqual(At(0, 30), duration);
-        }
+        Assert.IsTrue(hasIntersection);
+        Assert.AreEqual(At(0, 30), duration);
+    }
 
-        [TestMethod]
-        public void IntersectionDuration_ReturnsZeroDuration_WhenIntervalsTouch()
-        {
-            var start1 = At(8, 0);
-            var end1 = At(9, 0);
-            var start2 = At(9, 0);
-            var end2 = At(10, 0);
+    [TestMethod]
+    public void IntersectionDuration_ReturnsZeroDuration_WhenIntervalsTouch()
+    {
+        var start1 = At(8, 0);
+        var end1 = At(9, 0);
+        var start2 = At(9, 0);
+        var end2 = At(10, 0);
 
-            var hasIntersection = Time.Intersection(start1, end1, start2, end2, out var duration);
+        var hasIntersection = Time.Intersection(start1, end1, start2, end2, out var duration);
 
-            Assert.IsTrue(hasIntersection);
-            Assert.AreEqual(Time.Zero, duration);
-        }
+        Assert.IsTrue(hasIntersection);
+        Assert.AreEqual(Time.Zero, duration);
+    }
 
-        [TestMethod]
-        public void IntersectionBounds_ReturnsExpectedStartAndEnd_WhenIntervalsOverlap()
-        {
-            var start1 = At(8, 0);
-            var end1 = At(9, 0);
-            var start2 = At(8, 30);
-            var end2 = At(10, 0);
+    [TestMethod]
+    public void IntersectionBounds_ReturnsExpectedStartAndEnd_WhenIntervalsOverlap()
+    {
+        var start1 = At(8, 0);
+        var end1 = At(9, 0);
+        var start2 = At(8, 30);
+        var end2 = At(10, 0);
 
-            var hasIntersection = Time.Intersection(start1, end1, start2, end2, out var intersectionStart, out var intersectionEnd);
+        var hasIntersection = Time.Intersection(start1, end1, start2, end2, out var intersectionStart, out var intersectionEnd);
 
-            Assert.IsTrue(hasIntersection);
-            Assert.AreEqual(At(8, 30), intersectionStart);
-            Assert.AreEqual(At(9, 0), intersectionEnd);
-        }
+        Assert.IsTrue(hasIntersection);
+        Assert.AreEqual(At(8, 30), intersectionStart);
+        Assert.AreEqual(At(9, 0), intersectionEnd);
+    }
 
-        [TestMethod]
-        public void IntersectionOutputs_ReturnFalseAndZeroValues_WhenNoOverlap()
-        {
-            var start1 = At(8, 0);
-            var end1 = At(8, 30);
-            var start2 = At(9, 0);
-            var end2 = At(10, 0);
-
-            var hasDurationIntersection = Time.Intersection(start1, end1, start2, end2, out var duration);
-            var hasBoundIntersection = Time.Intersection(start1, end1, start2, end2, out var intersectionStart, out var intersectionEnd);
-
-            Assert.IsFalse(hasDurationIntersection);
-            Assert.AreEqual(Time.Zero, duration);
-            Assert.IsFalse(hasBoundIntersection);
-            Assert.AreEqual(Time.Zero, intersectionStart);
-            Assert.AreEqual(Time.Zero, intersectionEnd);
-        }
-
-        private static Time At(int hours, int minutes, int seconds = 0)
+    [TestMethod]
+    public void IntersectionOutputs_ReturnFalseAndZeroValues_WhenNoOverlap()
+    {
+        var start1 = At(8, 0);
+        var end1 = At(8, 30);
+        var start2 = At(9, 0);
+        var end2 = At(10, 0);
+
+        var hasDurationIntersection = Time.Intersection(start1, end1, start2, end2, out var duration);
+        var hasBoundIntersection = Time.Intersection(start1, end1, start2, end2, out var intersectionStart, out var intersectionEnd);
+
+        Assert.IsFalse(hasDurationIntersection);
+        Assert.AreEqual(Time.Zero, duration);
+        Assert.IsFalse(hasBoundIntersection);
+        Assert.AreEqual(Time.Zero, intersectionStart);
+        Assert.AreEqual(Time.Zero, intersectionEnd);
+    }
+
+    private static Time At(int hours, int minutes, int seconds = 0)
+    {
+        return new Time()
         {
-            return new Time()
-            {
-                Hours = hours,
-                Minutes = minutes,
-                Seconds = seconds
-            };
-        }
+            Hours = hours,
+            Minutes = minutes,
+            Seconds = seconds
+        };
     }
+}
diff --git a/tests/TMG-Framework.Test/Data/VectorTest.cs b/tests/TMG-Framework.Test/Data/VectorTest.cs
index 779376c..14e55e1 100644
--- a/tests/TMG-Framework.Test/Data/VectorTest.cs
+++ b/tests/TMG-Framework.Test/Data/VectorTest.cs
@@ -16,42 +16,37 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using XTMF2;
-using System.Reflection;
-using System.Collections.Generic;
-namespace TMG.Test.Data
+
+namespace TMG.Test.Data;
+
+[TestClass]
+public class VectorTest
 {
-    [TestClass]
-    public class VectorTest
+    [TestMethod]
+    public void CreateVector()
     {
-        [TestMethod]
-        public void CreateVector()
+        var map = CreateMap();
+        var vector = new Vector(map);
+        var flatData = vector.Data;
+        for (int i = 0; i < flatData.Length; i++)
         {
-            var map = CreateMap();
-            var vector = new Vector(map);
-            var flatData = vector.Data;
-            for (int i = 0; i < flatData.Length; i++)
-            {
-                flatData[i] = i;
-            }
-            Assert.AreEqual(0, vector[2]);
-            Assert.AreEqual(1, vector[4]);
-            Assert.AreEqual(2, vector[6]);
-            Assert.AreEqual(3, vector[8]);
-            Assert.AreEqual(4, vector[10]);
-            Assert.AreEqual(0, vector[12]);
+            flatData[i] = i;
         }
+        Assert.AreEqual(0, vector[2]);
+        Assert.AreEqual(1, vector[4]);
+        Assert.AreEqual(2, vector[6]);
+        Assert.AreEqual(3, vector[8]);
+        Assert.AreEqual(4, vector[10]);
+        Assert.AreEqual(0, vector[12]);
+    }
 
-        private static Categories CreateMap()
+    private static Categories CreateMap()
+    {
+        string? error = null;
+        if (!Categories.CreateCategories(new List<int>() { 2, 6, 4, 8, 10 }, out var categories, ref error))
         {
-            string? error = null;
-            if (!Categories.CreateCategories(new List<int>() { 2, 6, 4, 8, 10 }, out var categories, ref error))
-            {
-                Assert.Fail(error);
-            }
-            return categories;
+            Assert.Fail(error);
         }
+        return categories;
     }
 }
diff --git a/tests/TMG-Framework.Test/EnsureRuntimeLaunch.cs b/tests/TMG-Framework.Test/EnsureRuntimeLaunch.cs
index 48f7477..3fc9eaa 100644
--- a/tests/TMG-Framework.Test/EnsureRuntimeLaunch.cs
+++ b/tests/TMG-Framework.Test/EnsureRuntimeLaunch.cs
@@ -16,21 +16,18 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using XTMF2;
-using System.Reflection;
 
-namespace TMG.Test
+namespace TMG.Test;
+
+[TestClass]
+public class EnsureRuntimeLaunch
 {
-    [TestClass]
-    public class EnsureRuntimeLaunch
+    [TestMethod]
+    public void LaunchRuntime()
     {
-        [TestMethod]
-        public void LaunchRuntime()
-        {
-            var runtime = XTMFRuntime.CreateRuntime();
-            runtime.SystemConfiguration.LoadAssembly(typeof(Range).GetTypeInfo().Assembly);
-        }
+        var runtime = XTMFRuntime.CreateRuntime();
+        runtime.SystemConfiguration.LoadAssembly(typeof(Range).GetTypeInfo().Assembly);
     }
 }
diff --git a/tests/TMG-Framework.Test/GlobalUsings.cs b/tests/TMG-Framework.Test/GlobalUsings.cs
new file mode 100644
index 0000000..5b2ad6f
--- /dev/null
+++ b/tests/TMG-Framework.Test/GlobalUsings.cs
@@ -0,0 +1,8 @@
+global using Microsoft.VisualStudio.TestTools.UnitTesting;
+global using System;
+global using System.Collections.Generic;
+global using System.Diagnostics.CodeAnalysis;
+global using System.IO;
+global using System.Linq;
+global using System.Text;
+global using System.Reflection;
diff --git a/tests/TMG-Framework.Test/Loading/TestLoadCategoryMapFromThirdNormalizedCSV.cs b/tests/TMG-Framework.Test/Loading/TestLoadCategoryMapFromThirdNormalizedCSV.cs
index 98fd0a9..8359f34 100644
--- a/tests/TMG-Framework.Test/Loading/TestLoadCategoryMapFromThirdNormalizedCSV.cs
+++ b/tests/TMG-Framework.Test/Loading/TestLoadCategoryMapFromThirdNormalizedCSV.cs
@@ -17,36 +17,113 @@ You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
 using System.IO;
-using TMG;
-using TMG.Frameworks.Data.Processing.AST;
 using XTMF2;
-using XTMF2.RuntimeModules;
 using TMG.Loading;
-using TMG.Test.Utilities;
 
 using Helper = TMG.Test.Utilities.Helper;
-using System.Text;
 
-namespace TMG.Test.Loading
+
+namespace TMG.Test.Loading;
+
+[TestClass]
+public class TestLoadCategoryMapFromThirdNormalizedCSV
 {
-    [TestClass]
-    public class TestLoadCategoryMapFromThirdNormalizedCSV
+    /// <summary>
+    /// Test if we can execute the LoadCategoryMapFromThirdNormalizedCSV where it dynamically creates the destination category
+    /// </summary>
+    [TestMethod]
+    public void LoadMapWithoutDestinations()
+    {
+        string? error = null;
+        if (!Categories.CreateCategories(new List<int> { 1, 2, 3, 4 }, out var baseCategories, ref error))
+        {
+            Assert.Fail(error);
+        }
+        var pipe = CreateMapPipe();
+        try
+        {
+            var module = new LoadCategoryMapFromThirdNormalizedCSV()
+            {
+                Name = "Module",
+                BaseColumn = Helper.CreateParameter(0),
+                DestinationColumn = Helper.CreateParameter(1),
+                BaseCategories = Helper.CreateParameter(baseCategories),
+                DestinationCategories = null,
+                CSVStream = Helper.CreateParameter(pipe.GetReadStream(null!))
+            };
+            var map = module.Invoke();
+            Assert.IsNotNull(map);
+            var index = map.CreateIndex();
+            Assert.AreEqual(0, (int)index[0]);
+            Assert.AreEqual(1, (int)index[1]);
+            Assert.AreEqual(0, (int)index[2]);
+            Assert.AreEqual(1, (int)index[3]);
+        }
+        finally
+        {
+            pipe.DisposeMemoryStream();
+        }
+    }
+
+    /// <summary>
+    /// Test if we can execute the LoadCategoryMapFromThirdNormalizedCSV where we specify the destination category
+    /// </summary>
+    [TestMethod]
+    public void LoadMapWithDestinations()
     {
-        /// <summary>
-        /// Test if we can execute the LoadCategoryMapFromThirdNormalizedCSV where it dynamically creates the destination category
-        /// </summary>
-        [TestMethod]
-        public void LoadMapWithoutDestinations()
+        string? error = null;
+        if (!Categories.CreateCategories(new List<int> { 1, 2, 3, 4 }, out var baseCategories, ref error))
+        {
+            Assert.Fail(error);
+        }
+        if (!Categories.CreateCategories(new List<int> { 1, 2 }, out var destinationCategories, ref error))
+        {
+            Assert.Fail(error);
+        }
+        var pipe = CreateMapPipe();
+        try
+        {
+            var module = new LoadCategoryMapFromThirdNormalizedCSV()
+            {
+                Name = "Module",
+                BaseColumn = Helper.CreateParameter(0),
+                DestinationColumn = Helper.CreateParameter(1),
+                BaseCategories = Helper.CreateParameter(baseCategories),
+                DestinationCategories = Helper.CreateParameter(destinationCategories),
+                CSVStream = Helper.CreateParameter(pipe.GetReadStream(null!))
+            };
+            var map = module.Invoke();
+            Assert.IsNotNull(map);
+            var index = map.CreateIndex();
+            Assert.AreEqual(0, (int)index[0]);
+            Assert.AreEqual(1, (int)index[1]);
+            Assert.AreEqual(0, (int)index[2]);
+            Assert.AreEqual(1, (int)index[3]);
+        }
+        finally
+        {
+            pipe.DisposeMemoryStream();
+        }
+    }
+
+    /// <summary>
+    /// Make sure that if there is an invalid destination specified that we throw an exception
+    /// </summary>
+    [TestMethod]
+    public void LoadMapWithBadDestinations()
+    {
+        Helper.ThrowsException<XTMFRuntimeException>(() =>
         {
             string? error = null;
             if (!Categories.CreateCategories(new List<int> { 1, 2, 3, 4 }, out var baseCategories, ref error))
             {
                 Assert.Fail(error);
             }
+            if (!Categories.CreateCategories(new List<int> { 1 }, out var destinationCategories, ref error))
+            {
+                Assert.Fail(error);
+            }
             var pipe = CreateMapPipe();
             try
             {
@@ -56,31 +133,29 @@ public void LoadMapWithoutDestinations()
                     BaseColumn = Helper.CreateParameter(0),
                     DestinationColumn = Helper.CreateParameter(1),
                     BaseCategories = Helper.CreateParameter(baseCategories),
-                    DestinationCategories = null,
+                    DestinationCategories = Helper.CreateParameter(destinationCategories),
                     CSVStream = Helper.CreateParameter(pipe.GetReadStream(null!))
                 };
-                var map = module.Invoke();
-                Assert.IsNotNull(map);
-                var index = map.CreateIndex();
-                Assert.AreEqual(0, (int)index[0]);
-                Assert.AreEqual(1, (int)index[1]);
-                Assert.AreEqual(0, (int)index[2]);
-                Assert.AreEqual(1, (int)index[3]);
+                // We expect this to throw
+                var _ = module.Invoke();
             }
             finally
             {
                 pipe.DisposeMemoryStream();
             }
-        }
+        });
+    }
 
-        /// <summary>
-        /// Test if we can execute the LoadCategoryMapFromThirdNormalizedCSV where we specify the destination category
-        /// </summary>
-        [TestMethod]
-        public void LoadMapWithDestinations()
+    /// <summary>
+    /// Make sure that if there is an invalid base specified that we throw an exception
+    /// </summary>
+    [TestMethod]
+    public void LoadMapWithBadBase()
+    {
+        Helper.ThrowsException<XTMFRuntimeException>(() =>
         {
             string? error = null;
-            if (!Categories.CreateCategories(new List<int> { 1, 2, 3, 4 }, out var baseCategories, ref error))
+            if (!Categories.CreateCategories(new List<int> { 1, 2, 4 }, out var baseCategories, ref error))
             {
                 Assert.Fail(error);
             }
@@ -100,114 +175,31 @@ public void LoadMapWithDestinations()
                     DestinationCategories = Helper.CreateParameter(destinationCategories),
                     CSVStream = Helper.CreateParameter(pipe.GetReadStream(null!))
                 };
-                var map = module.Invoke();
-                Assert.IsNotNull(map);
-                var index = map.CreateIndex();
-                Assert.AreEqual(0, (int)index[0]);
-                Assert.AreEqual(1, (int)index[1]);
-                Assert.AreEqual(0, (int)index[2]);
-                Assert.AreEqual(1, (int)index[3]);
+                // We expect this to throw
+                var _ = module.Invoke();
             }
             finally
             {
                 pipe.DisposeMemoryStream();
             }
-        }
-
-        /// <summary>
-        /// Make sure that if there is an invalid destination specified that we throw an exception
-        /// </summary>
-        [TestMethod]
-        public void LoadMapWithBadDestinations()
-        {
-            Helper.ThrowsException<XTMFRuntimeException>(() =>
-            {
-                string? error = null;
-                if (!Categories.CreateCategories(new List<int> { 1, 2, 3, 4 }, out var baseCategories, ref error))
-                {
-                    Assert.Fail(error);
-                }
-                if (!Categories.CreateCategories(new List<int> { 1 }, out var destinationCategories, ref error))
-                {
-                    Assert.Fail(error);
-                }
-                var pipe = CreateMapPipe();
-                try
-                {
-                    var module = new LoadCategoryMapFromThirdNormalizedCSV()
-                    {
-                        Name = "Module",
-                        BaseColumn = Helper.CreateParameter(0),
-                        DestinationColumn = Helper.CreateParameter(1),
-                        BaseCategories = Helper.CreateParameter(baseCategories),
-                        DestinationCategories = Helper.CreateParameter(destinationCategories),
-                        CSVStream = Helper.CreateParameter(pipe.GetReadStream(null!))
-                    };
-                    // We expect this to throw
-                    var _ = module.Invoke();
-                }
-                finally
-                {
-                    pipe.DisposeMemoryStream();
-                }
-            });
-        }
-
-        /// <summary>
-        /// Make sure that if there is an invalid base specified that we throw an exception
-        /// </summary>
-        [TestMethod]
-        public void LoadMapWithBadBase()
-        {
-            Helper.ThrowsException<XTMFRuntimeException>(() =>
-            {
-                string? error = null;
-                if (!Categories.CreateCategories(new List<int> { 1, 2, 4 }, out var baseCategories, ref error))
-                {
-                    Assert.Fail(error);
-                }
-                if (!Categories.CreateCategories(new List<int> { 1, 2 }, out var destinationCategories, ref error))
-                {
-                    Assert.Fail(error);
-                }
-                var pipe = CreateMapPipe();
-                try
-                {
-                    var module = new LoadCategoryMapFromThirdNormalizedCSV()
-                    {
-                        Name = "Module",
-                        BaseColumn = Helper.CreateParameter(0),
-                        DestinationColumn = Helper.CreateParameter(1),
-                        BaseCategories = Helper.CreateParameter(baseCategories),
-                        DestinationCategories = Helper.CreateParameter(destinationCategories),
-                        CSVStream = Helper.CreateParameter(pipe.GetReadStream(null!))
-                    };
-                    // We expect this to throw
-                    var _ = module.Invoke();
-                }
-                finally
-                {
-                    pipe.DisposeMemoryStream();
-                }
-            });
-        }
+        });
+    }
 
-        /// <summary>
-        /// Creates a memory pipe to read the map from.
-        /// </summary>
-        /// <returns></returns>
-        private static MemoryPipe CreateMapPipe()
-        {
-            var pipe = new MemoryPipe();
-            var writeStream = pipe.GetWriteStream(null!);
-            var writer = new StreamWriter(writeStream);
-            writer.WriteLine("Zone,PD");
-            writer.WriteLine("1,1");
-            writer.WriteLine("2,2");
-            writer.WriteLine("3,1");
-            writer.WriteLine("4,2");
-            writer.Flush();
-            return pipe;
-        }
+    /// <summary>
+    /// Creates a memory pipe to read the map from.
+    /// </summary>
+    /// <returns></returns>
+    private static MemoryPipe CreateMapPipe()
+    {
+        var pipe = new MemoryPipe();
+        var writeStream = pipe.GetWriteStream(null!);
+        var writer = new StreamWriter(writeStream);
+        writer.WriteLine("Zone,PD");
+        writer.WriteLine("1,1");
+        writer.WriteLine("2,2");
+        writer.WriteLine("3,1");
+        writer.WriteLine("4,2");
+        writer.Flush();
+        return pipe;
     }
 }
diff --git a/tests/TMG-Framework.Test/Loading/TestLoadMapFromCSV.cs b/tests/TMG-Framework.Test/Loading/TestLoadMapFromCSV.cs
index b35bb38..89891fb 100644
--- a/tests/TMG-Framework.Test/Loading/TestLoadMapFromCSV.cs
+++ b/tests/TMG-Framework.Test/Loading/TestLoadMapFromCSV.cs
@@ -17,45 +17,35 @@ You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using TMG;
-using TMG.Frameworks.Data.Processing.AST;
-using XTMF2;
-using XTMF2.RuntimeModules;
-using TMG.Loading;
 using TMG.Test.Utilities;
 
-namespace TMG.Test.Loading
+namespace TMG.Test.Loading;
+
+[TestClass]
+public class TestLoadMapFromCSV
 {
-    [TestClass]
-    public class TestLoadMapFromCSV
-    {
 
-        [TestMethod]
-        public void TestLoadingMapFromCSV()
+    [TestMethod]
+    public void TestLoadingMapFromCSV()
+    {
+        var mapFilePath = MapHelper.WriteCSV(64);
+        var result = MapHelper.LoadMap(mapFilePath);
+        Assert.AreEqual(64, result.Count);
+        for (int i = 0; i < result.Count; i++)
         {
-            var mapFilePath = MapHelper.WriteCSV(64);
-            var result = MapHelper.LoadMap(mapFilePath);
-            Assert.AreEqual(64, result.Count);
-            for (int i = 0; i < result.Count; i++)
-            {
-                Assert.AreEqual((CategoryIndex)(i + 1), result.GetSparseIndex(i));
-            }
+            Assert.AreEqual((CategoryIndex)(i + 1), result.GetSparseIndex(i));
         }
+    }
 
-        [TestMethod]
-        public void TestLoadingMapFromCSVDefinedBackwards()
+    [TestMethod]
+    public void TestLoadingMapFromCSVDefinedBackwards()
+    {
+        var mapFilePath = MapHelper.WriteBackwardsCSV(64);
+        var result = MapHelper.LoadMap(mapFilePath);
+        Assert.AreEqual(64, result.Count);
+        for (int i = 0; i < result.Count; i++)
         {
-            var mapFilePath = MapHelper.WriteBackwardsCSV(64);
-            var result = MapHelper.LoadMap(mapFilePath);
-            Assert.AreEqual(64, result.Count);
-            for (int i = 0; i < result.Count; i++)
-            {
-                Assert.AreEqual((CategoryIndex)(i + 1), result.GetSparseIndex(i));
-            }
+            Assert.AreEqual((CategoryIndex)(i + 1), result.GetSparseIndex(i));
         }
     }
 }
diff --git a/tests/TMG-Framework.Test/Loading/TestLoadMatrix.cs b/tests/TMG-Framework.Test/Loading/TestLoadMatrix.cs
index d2dfcc3..48c82ff 100644
--- a/tests/TMG-Framework.Test/Loading/TestLoadMatrix.cs
+++ b/tests/TMG-Framework.Test/Loading/TestLoadMatrix.cs
@@ -16,180 +16,174 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
+
 using TMG.Loading;
 using TMG.Test.Utilities;
 using XTMF2.RuntimeModules;
 
-namespace TMG.Test.Loading
+namespace TMG.Test.Loading;
+
+[TestClass]
+public class TestLoadMatrix
 {
-    [TestClass]
-    public class TestLoadMatrix
+    [TestMethod]
+    public void LoadMatrixFromCSVMatrix()
     {
-        [TestMethod]
-        public void LoadMatrixFromCSVMatrix()
+        var map = MapHelper.LoadMap(MapHelper.WriteCSV(64));
+        float[][] data = new float[64][];
+        for (int i = 0; i < data.Length; i++)
         {
-            var map = MapHelper.LoadMap(MapHelper.WriteCSV(64));
-            float[][] data = new float[64][];
-            for (int i = 0; i < data.Length; i++)
+            data[i] = new float[64];
+            for (int j = 0; j < data[i].Length; j++)
             {
-                data[i] = new float[64];
-                for (int j = 0; j < data[i].Length; j++)
-                {
-                    data[i][j] = 2.0f + i * j;
-                }
+                data[i][j] = 2.0f + i * j;
             }
-            var matrixFileName = MatrixHelper.WriteMatrixToCSVMatrix(map, data);
-            var matrixLoader = new LoadMatrixFromCSVMatrix()
-            {
-                ColumnCategories = Helper.CreateParameter(map),
-                RowCategories = Helper.CreateParameter(map)
-            };
-            using (var stream = (new OpenReadStreamFromFile()
-            {
-                FilePath = Helper.CreateParameter(matrixFileName)
-            }).Invoke())
+        }
+        var matrixFileName = MatrixHelper.WriteMatrixToCSVMatrix(map, data);
+        var matrixLoader = new LoadMatrixFromCSVMatrix()
+        {
+            ColumnCategories = Helper.CreateParameter(map),
+            RowCategories = Helper.CreateParameter(map)
+        };
+        using (var stream = (new OpenReadStreamFromFile()
+        {
+            FilePath = Helper.CreateParameter(matrixFileName)
+        }).Invoke())
+        {
+            var vector = matrixLoader.Invoke(stream);
+            Assert.AreSame(map, vector.RowCategories);
+            var vData = vector.Data;
+            for (int i = 0; i < map.Count; i++)
             {
-                var vector = matrixLoader.Invoke(stream);
-                Assert.AreSame(map, vector.RowCategories);
-                var vData = vector.Data;
-                for (int i = 0; i < map.Count; i++)
+                for (int j = 0; j < map.Count; j++)
                 {
-                    for (int j = 0; j < map.Count; j++)
+                    if (Math.Abs((2.0f + i * j) - vData[i * map.Count + j]) < 0.00001f)
                     {
-                        if(Math.Abs((2.0f + i * j) - vData[i * map.Count + j]) < 0.00001f)
-                        {
-                            Assert.AreEqual(2.0f + i * j, vData[i * map.Count + j], 0.00001f);
-                        }
+                        Assert.AreEqual(2.0f + i * j, vData[i * map.Count + j], 0.00001f);
                     }
                 }
             }
         }
+    }
 
-        [TestMethod]
-        public void LoadMatrixFromCSVThirdNormalized()
+    [TestMethod]
+    public void LoadMatrixFromCSVThirdNormalized()
+    {
+        var map = MapHelper.LoadMap(MapHelper.WriteCSV(64));
+        float[][] data = new float[64][];
+        for (int i = 0; i < data.Length; i++)
         {
-            var map = MapHelper.LoadMap(MapHelper.WriteCSV(64));
-            float[][] data = new float[64][];
-            for (int i = 0; i < data.Length; i++)
+            data[i] = new float[64];
+            for (int j = 0; j < data[i].Length; j++)
             {
-                data[i] = new float[64];
-                for (int j = 0; j < data[i].Length; j++)
-                {
-                    data[i][j] = 2.0f + i * j;
-                }
+                data[i][j] = 2.0f + i * j;
             }
-            var matrixFileName = MatrixHelper.WriteMatrixToCSVThirdNormalized(map, data);
-            var matrixLoader = new LoadMatrixFromCSVThirdNormalized()
-            {
-                RowCategories = Helper.CreateParameter(map),
-                ColumnCategories = Helper.CreateParameter(map),
-                OriginColumn = Helper.CreateParameter(0),
-                DestinationColumn = Helper.CreateParameter(0),
-                DataColumn = Helper.CreateParameter(0)
-            };
-            using (var stream = (new OpenReadStreamFromFile()
-            {
-                FilePath = Helper.CreateParameter(matrixFileName)
-            }).Invoke())
+        }
+        var matrixFileName = MatrixHelper.WriteMatrixToCSVThirdNormalized(map, data);
+        var matrixLoader = new LoadMatrixFromCSVThirdNormalized()
+        {
+            RowCategories = Helper.CreateParameter(map),
+            ColumnCategories = Helper.CreateParameter(map),
+            OriginColumn = Helper.CreateParameter(0),
+            DestinationColumn = Helper.CreateParameter(0),
+            DataColumn = Helper.CreateParameter(0)
+        };
+        using (var stream = (new OpenReadStreamFromFile()
+        {
+            FilePath = Helper.CreateParameter(matrixFileName)
+        }).Invoke())
+        {
+            var vector = matrixLoader.Invoke(stream);
+            Assert.AreSame(map, vector.RowCategories);
+            var vData = vector.Data;
+            for (int i = 0; i < map.Count; i++)
             {
-                var vector = matrixLoader.Invoke(stream);
-                Assert.AreSame(map, vector.RowCategories);
-                var vData = vector.Data;
-                for (int i = 0; i < map.Count; i++)
+                for (int j = 0; j < map.Count; j++)
                 {
-                    for (int j = 0; j < map.Count; j++)
+                    if (Math.Abs((2.0f + i * j) - vData[i * map.Count + j]) < 0.00001f)
                     {
-                        if (Math.Abs((2.0f + i * j) - vData[i * map.Count + j]) < 0.00001f)
-                        {
-                            Assert.AreEqual(2.0f + i * j, vData[i * map.Count + j], 0.00001f);
-                        }
+                        Assert.AreEqual(2.0f + i * j, vData[i * map.Count + j], 0.00001f);
                     }
                 }
             }
         }
+    }
 
-        [TestMethod]
-        public void TestLoadMatrixFromMTX()
+    [TestMethod]
+    public void TestLoadMatrixFromMTX()
+    {
+        var map = MapHelper.LoadMap(MapHelper.WriteCSV(64));
+        float[][] data = new float[64][];
+        for (int i = 0; i < data.Length; i++)
         {
-            var map = MapHelper.LoadMap(MapHelper.WriteCSV(64));
-            float[][] data = new float[64][];
-            for (int i = 0; i < data.Length; i++)
+            data[i] = new float[64];
+            for (int j = 0; j < data[i].Length; j++)
             {
-                data[i] = new float[64];
-                for (int j = 0; j < data[i].Length; j++)
-                {
-                    data[i][j] = 2.0f + i * j;
-                }
+                data[i][j] = 2.0f + i * j;
             }
-            var matrixFileName = MatrixHelper.WriteMatrixToMTX(map, data);
-            var matrixLoader = new LoadMatrixFromMTX()
-            {
-                Categories = Helper.CreateParameter(map),
-                ConvertBetweenZoneSystems = Helper.CreateParameter(false)
-            };
-            using (var stream = (new OpenReadStreamFromFile()
-            {
-                FilePath = Helper.CreateParameter(matrixFileName)
-            }).Invoke())
+        }
+        var matrixFileName = MatrixHelper.WriteMatrixToMTX(map, data);
+        var matrixLoader = new LoadMatrixFromMTX()
+        {
+            Categories = Helper.CreateParameter(map),
+            ConvertBetweenZoneSystems = Helper.CreateParameter(false)
+        };
+        using (var stream = (new OpenReadStreamFromFile()
+        {
+            FilePath = Helper.CreateParameter(matrixFileName)
+        }).Invoke())
+        {
+            var vector = matrixLoader.Invoke(stream);
+            Assert.AreSame(map, vector.RowCategories);
+            var vData = vector.Data;
+            for (int i = 0; i < map.Count; i++)
             {
-                var vector = matrixLoader.Invoke(stream);
-                Assert.AreSame(map, vector.RowCategories);
-                var vData = vector.Data;
-                for (int i = 0; i < map.Count; i++)
+                for (int j = 0; j < map.Count; j++)
                 {
-                    for (int j = 0; j < map.Count; j++)
+                    if (Math.Abs((2.0f + i * j) - vData[i * map.Count + j]) < 0.00001f)
                     {
-                        if (Math.Abs((2.0f + i * j) - vData[i * map.Count + j]) < 0.00001f)
-                        {
-                            Assert.AreEqual(2.0f + i * j, vData[i * map.Count + j], 0.00001f);
-                        }
+                        Assert.AreEqual(2.0f + i * j, vData[i * map.Count + j], 0.00001f);
                     }
                 }
             }
         }
+    }
 
-        [TestMethod]
-        public void TestLoadMatrixFromMTXDifferentZoneSystem()
+    [TestMethod]
+    public void TestLoadMatrixFromMTXDifferentZoneSystem()
+    {
+        var bigMap = MapHelper.LoadMap(MapHelper.WriteCSV(64));
+        var smallMap = MapHelper.LoadMap(MapHelper.WriteCSV(32));
+        float[][] data = new float[64][];
+        for (int i = 0; i < data.Length; i++)
         {
-            var bigMap = MapHelper.LoadMap(MapHelper.WriteCSV(64));
-            var smallMap = MapHelper.LoadMap(MapHelper.WriteCSV(32));
-            float[][] data = new float[64][];
-            for (int i = 0; i < data.Length; i++)
+            data[i] = new float[64];
+            for (int j = 0; j < data[i].Length; j++)
             {
-                data[i] = new float[64];
-                for (int j = 0; j < data[i].Length; j++)
-                {
-                    data[i][j] = 2.0f + i * j;
-                }
+                data[i][j] = 2.0f + i * j;
             }
-            var matrixFileName = MatrixHelper.WriteMatrixToMTX(bigMap, data);
-            var matrixLoader = new LoadMatrixFromMTX()
-            {
-                Categories = Helper.CreateParameter(smallMap),
-                ConvertBetweenZoneSystems = Helper.CreateParameter(true)
-            };
-            using (var stream = (new OpenReadStreamFromFile()
-            {
-                FilePath = Helper.CreateParameter(matrixFileName)
-            }).Invoke())
+        }
+        var matrixFileName = MatrixHelper.WriteMatrixToMTX(bigMap, data);
+        var matrixLoader = new LoadMatrixFromMTX()
+        {
+            Categories = Helper.CreateParameter(smallMap),
+            ConvertBetweenZoneSystems = Helper.CreateParameter(true)
+        };
+        using (var stream = (new OpenReadStreamFromFile()
+        {
+            FilePath = Helper.CreateParameter(matrixFileName)
+        }).Invoke())
+        {
+            var matrix = matrixLoader.Invoke(stream);
+            Assert.AreSame(smallMap, matrix.RowCategories);
+            var vData = matrix.Data;
+            for (int i = 0; i < smallMap.Count; i++)
             {
-                var matrix = matrixLoader.Invoke(stream);
-                Assert.AreSame(smallMap, matrix.RowCategories);
-                var vData = matrix.Data;
-                for (int i = 0; i < smallMap.Count; i++)
+                for (int j = 0; j < smallMap.Count; j++)
                 {
-                    for (int j = 0; j < smallMap.Count; j++)
+                    if (Math.Abs((2.0f + i * j) - vData[i * smallMap.Count + j]) < 0.00001f)
                     {
-                        if (Math.Abs((2.0f + i * j) - vData[i * smallMap.Count + j]) < 0.00001f)
-                        {
-                            Assert.AreEqual(2.0f + i * j, vData[i * smallMap.Count + j], 0.00001f);
-                        }
+                        Assert.AreEqual(2.0f + i * j, vData[i * smallMap.Count + j], 0.00001f);
                     }
                 }
             }
diff --git a/tests/TMG-Framework.Test/Loading/TestLoadVector.cs b/tests/TMG-Framework.Test/Loading/TestLoadVector.cs
index 72c6e30..4793e1a 100644
--- a/tests/TMG-Framework.Test/Loading/TestLoadVector.cs
+++ b/tests/TMG-Framework.Test/Loading/TestLoadVector.cs
@@ -16,9 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.IO;
+
 using TMG.Loading;
 using TMG.Test.Utilities;
 
diff --git a/tests/TMG-Framework.Test/Processing/TestAppendMatrixValueToCSV.cs b/tests/TMG-Framework.Test/Processing/TestAppendMatrixValueToCSV.cs
index 962163e..f42167f 100644
--- a/tests/TMG-Framework.Test/Processing/TestAppendMatrixValueToCSV.cs
+++ b/tests/TMG-Framework.Test/Processing/TestAppendMatrixValueToCSV.cs
@@ -17,83 +17,77 @@ You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using TMG;
-using TMG.Frameworks.Data.Processing.AST;
 using TMG.Processing;
 using TMG.Test.Utilities;
-namespace TMG.Test.Processing
+
+namespace TMG.Test.Processing;
+
+[TestClass]
+public class TestAppendMatrixValueToCSV
 {
-    [TestClass]
-    public class TestAppendMatrixValueToCSV
+    [TestMethod]
+    public void AppendMatrixValueToCSV()
     {
-        [TestMethod]
-        public void AppendMatrixValueToCSV()
+        string csvFileName = Path.GetTempFileName();
+        string processedCsvFileName = Path.GetTempFileName();
+        try
         {
-            string csvFileName = Path.GetTempFileName();
-            string processedCsvFileName = Path.GetTempFileName();
-            try
-            {
-                var zoneSystem = MapHelper.LoadMap(64);
-                var matrix = new Matrix(zoneSystem, zoneSystem);
-                // Setup matrix
-                matrix.GetFromSparseIndexes(5, 2) = 10;
-                matrix.GetFromSparseIndexes(2, 5) = 11;
+            var zoneSystem = MapHelper.LoadMap(64);
+            var matrix = new Matrix(zoneSystem, zoneSystem);
+            // Setup matrix
+            matrix.GetFromSparseIndexes(5, 2) = 10;
+            matrix.GetFromSparseIndexes(2, 5) = 11;
 
-                matrix.GetFromSparseIndexes(10, 4) = 12;
-                matrix.GetFromSparseIndexes(4, 10) = 13;
-                // Setup CSV
+            matrix.GetFromSparseIndexes(10, 4) = 12;
+            matrix.GetFromSparseIndexes(4, 10) = 13;
+            // Setup CSV
 
-                using (var writer = new StreamWriter(csvFileName))
-                {
-                    writer.WriteLine("O,D,OtherData");
-                    writer.WriteLine("5,2,ABC");
-                    writer.WriteLine("2,5,DEF");
-                    writer.WriteLine("10,4,GHI");
-                    writer.WriteLine("4,10,GHI");
-                }
+            using (var writer = new StreamWriter(csvFileName))
+            {
+                writer.WriteLine("O,D,OtherData");
+                writer.WriteLine("5,2,ABC");
+                writer.WriteLine("2,5,DEF");
+                writer.WriteLine("10,4,GHI");
+                writer.WriteLine("4,10,GHI");
+            }
 
-                using (var readStream = Helper.CreateReadStreamFromFile(csvFileName))
-                using (var writeStream = Helper.CreateWriteStreamFromFile(processedCsvFileName))
+            using (var readStream = Helper.CreateReadStreamFromFile(csvFileName))
+            using (var writeStream = Helper.CreateWriteStreamFromFile(processedCsvFileName))
+            {
+                // Run append
+                AppendMatrixValueToCSV appendModule = new AppendMatrixValueToCSV()
                 {
-                    // Run append
-                    AppendMatrixValueToCSV appendModule = new AppendMatrixValueToCSV()
-                    {
-                        Name = "Append",
-                        Matrix = Helper.CreateParameter(matrix, "Matrix"),
-                        RowIndex = Helper.CreateParameter(0),
-                        ColumnIndex = Helper.CreateParameter(1),
-                        ColumnName = Helper.CreateParameter("MatrixValue"),
-                        InputStream = Helper.CreateParameter(readStream, "Reader"),
-                        OutputStream = Helper.CreateParameter(writeStream, "Writer")
-                    };
-                    appendModule.Invoke();
-                }
+                    Name = "Append",
+                    Matrix = Helper.CreateParameter(matrix, "Matrix"),
+                    RowIndex = Helper.CreateParameter(0),
+                    ColumnIndex = Helper.CreateParameter(1),
+                    ColumnName = Helper.CreateParameter("MatrixValue"),
+                    InputStream = Helper.CreateParameter(readStream, "Reader"),
+                    OutputStream = Helper.CreateParameter(writeStream, "Writer")
+                };
+                appendModule.Invoke();
+            }
 
-                // Test Results
-                using (var reader = new StreamReader(processedCsvFileName))
-                {
-                    Assert.AreEqual("O,D,OtherData,MatrixValue", reader.ReadLine());
-                    Assert.AreEqual("5,2,ABC,10", reader.ReadLine());
-                    Assert.AreEqual("2,5,DEF,11", reader.ReadLine());
-                    Assert.AreEqual("10,4,GHI,12", reader.ReadLine());
-                    Assert.AreEqual("4,10,GHI,13", reader.ReadLine());
-                    Assert.IsNull(reader.ReadLine());
-                }
+            // Test Results
+            using (var reader = new StreamReader(processedCsvFileName))
+            {
+                Assert.AreEqual("O,D,OtherData,MatrixValue", reader.ReadLine());
+                Assert.AreEqual("5,2,ABC,10", reader.ReadLine());
+                Assert.AreEqual("2,5,DEF,11", reader.ReadLine());
+                Assert.AreEqual("10,4,GHI,12", reader.ReadLine());
+                Assert.AreEqual("4,10,GHI,13", reader.ReadLine());
+                Assert.IsNull(reader.ReadLine());
+            }
+        }
+        finally
+        {
+            if (File.Exists(csvFileName))
+            {
+                File.Delete(csvFileName);
             }
-            finally
+            if (File.Exists(processedCsvFileName))
             {
-                if (File.Exists(csvFileName))
-                {
-                    File.Delete(csvFileName);
-                }
-                if (File.Exists(processedCsvFileName))
-                {
-                    File.Delete(processedCsvFileName);
-                }
+                File.Delete(processedCsvFileName);
             }
         }
     }
diff --git a/tests/TMG-Framework.Test/Processing/TestEvaluateMatrix.cs b/tests/TMG-Framework.Test/Processing/TestEvaluateMatrix.cs
index ff28e6e..df43d7d 100644
--- a/tests/TMG-Framework.Test/Processing/TestEvaluateMatrix.cs
+++ b/tests/TMG-Framework.Test/Processing/TestEvaluateMatrix.cs
@@ -17,40 +17,35 @@ You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using TMG;
-using TMG.Frameworks.Data.Processing.AST;
 using TMG.Processing;
 using TMG.Test.Utilities;
 
-namespace TMG.Test.Processing
+namespace TMG.Test.Processing;
+
+[TestClass]
+public class TestEvaluateMatrix
 {
-    [TestClass]
-    public class TestEvaluateMatrix
+    [TestMethod]
+    public void LargeMatrixMathFMA()
     {
-        [TestMethod]
-        public void LargeMatrixMathFMA()
+        var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
+        var a = new Matrix(categories, categories);
+        var b = new Matrix(categories, categories);
+        var c = new Matrix(categories, categories);
+        var eval = new EvaluateMatrix()
         {
-            var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
-            var a = new Matrix(categories, categories);
-            var b = new Matrix(categories, categories);
-            var c = new Matrix(categories, categories);
-            var eval = new EvaluateMatrix()
+            Expression = Helper.CreateParameter("A * B + (C * 2 + 3)"),
+            Variables = new[]
             {
-                Expression = Helper.CreateParameter("A * B + (C * 2 + 3)"),
-                Variables = new[]
-                {
                     Helper.CreateParameter(a, "A"),
                     Helper.CreateParameter(b, "B"),
                     Helper.CreateParameter(c, "C"),
                 }
-            };
-            string? error = null;
-            Assert.IsTrue(eval.RuntimeValidation(ref error), error);
-            var res = eval.Invoke();
-            Assert.IsNotNull(res);
-        }
+        };
+        string? error = null;
+        Assert.IsTrue(eval.RuntimeValidation(ref error), error);
+        var res = eval.Invoke();
+        Assert.IsNotNull(res);
     }
 }
+
diff --git a/tests/TMG-Framework.Test/Processing/TestEvaluateScalar.cs b/tests/TMG-Framework.Test/Processing/TestEvaluateScalar.cs
index 73d35b1..59feccc 100644
--- a/tests/TMG-Framework.Test/Processing/TestEvaluateScalar.cs
+++ b/tests/TMG-Framework.Test/Processing/TestEvaluateScalar.cs
@@ -17,39 +17,33 @@ You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using TMG;
-using TMG.Frameworks.Data.Processing.AST;
 using TMG.Processing;
 using TMG.Test.Utilities;
 
-namespace TMG.Test.Processing
+namespace TMG.Test.Processing;
+
+[TestClass]
+public class TestEvaluateScalar
 {
-    [TestClass]
-    public class TestEvaluateScalar
+    [TestMethod]
+    public void TestLargeScalar()
     {
-        [TestMethod]
-        public void TestLargeScalar()
+        var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
+        var a = new Matrix(categories, categories);
+        var b = new Matrix(categories, categories);
+        var c = new Matrix(categories, categories);
+        var eval = new EvaluateScalar()
         {
-            var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
-            var a = new Matrix(categories, categories);
-            var b = new Matrix(categories, categories);
-            var c = new Matrix(categories, categories);
-            var eval = new EvaluateScalar()
+            Expression = Helper.CreateParameter("Sum(A * B + (C * 2 + 3))"),
+            Variables = new[]
             {
-                Expression = Helper.CreateParameter("Sum(A * B + (C * 2 + 3))"),
-                Variables = new[]
-                {
                     Helper.CreateParameter(a, "A"),
                     Helper.CreateParameter(b, "B"),
                     Helper.CreateParameter(c, "C"),
                 }
-            };
-            string? error = null;
-            Assert.IsTrue(eval.RuntimeValidation(ref error), error);
-            var res = eval.Invoke();
-        }
+        };
+        string? error = null;
+        Assert.IsTrue(eval.RuntimeValidation(ref error), error);
+        var res = eval.Invoke();
     }
 }
diff --git a/tests/TMG-Framework.Test/Processing/TestEvaluateVector.cs b/tests/TMG-Framework.Test/Processing/TestEvaluateVector.cs
index 83b464f..b7f151e 100644
--- a/tests/TMG-Framework.Test/Processing/TestEvaluateVector.cs
+++ b/tests/TMG-Framework.Test/Processing/TestEvaluateVector.cs
@@ -17,39 +17,35 @@ You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using TMG;
-using TMG.Frameworks.Data.Processing.AST;
+
 using TMG.Processing;
 using TMG.Test.Utilities;
-namespace TMG.Test.Processing
+namespace TMG.Test.Processing;
+
+[TestClass]
+public class TestEvaluateVector
 {
-    [TestClass]
-    public class TestEvaluateVector
+    [TestMethod]
+    public void LargeVectorMathFMA()
     {
-        [TestMethod]
-        public void LargeVectorMathFMA()
+        var map = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
+        var a = new Vector(map);
+        var b = new Vector(map);
+        var c = new Vector(map);
+        var eval = new EvaluateVector()
         {
-            var map = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
-            var a = new Vector(map);
-            var b = new Vector(map);
-            var c = new Vector(map);
-            var eval = new EvaluateVector()
+            Expression = Helper.CreateParameter("A * B + (C * 2 + 3)"),
+            Variables = new[]
             {
-                Expression = Helper.CreateParameter("A * B + (C * 2 + 3)"),
-                Variables = new[]
-                {
                     Helper.CreateParameter(a, "A"),
                     Helper.CreateParameter(b, "B"),
                     Helper.CreateParameter(c, "C"),
                 }
-            };
-            string? error = null;
-            Assert.IsTrue(eval.RuntimeValidation(ref error), error);
-            var res = eval.Invoke();
-            Assert.IsNotNull(res);
-        }
+        };
+        string? error = null;
+        Assert.IsTrue(eval.RuntimeValidation(ref error), error);
+        var res = eval.Invoke();
+        Assert.IsNotNull(res);
     }
 }
+
diff --git a/tests/TMG-Framework.Test/Processing/TestExecutePipelineInOrderParallel.cs b/tests/TMG-Framework.Test/Processing/TestExecutePipelineInOrderParallel.cs
index fe0f5a7..115d17f 100644
--- a/tests/TMG-Framework.Test/Processing/TestExecutePipelineInOrderParallel.cs
+++ b/tests/TMG-Framework.Test/Processing/TestExecutePipelineInOrderParallel.cs
@@ -17,51 +17,45 @@ You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using TMG;
-using TMG.Frameworks.Data.Processing.AST;
 using TMG.Processing;
 using TMG.Test.Utilities;
 using System.Numerics;
 
 
-namespace TMG.Test.Processing
+namespace TMG.Test.Processing;
+
+[TestClass]
+public class TestExecutePipelineInOrderParallel
 {
-    [TestClass]
-    public class TestExecutePipelineInOrderParallel
+    [TestMethod]
+    public void EnsureOrder()
     {
-        [TestMethod]
-        public void EnsureOrder()
+        ExecutePipelineInOrderParallel<int> module = new ExecutePipelineInOrderParallel<int>()
         {
-            ExecutePipelineInOrderParallel<int> module = new ExecutePipelineInOrderParallel<int>()
+            Name = "ModuleToTest",
+            ToExecuteInParallel = Helper.CreateModule((int input) => input * 2),
+            ToExecuteNotInParallel = new[]
             {
-                Name = "ModuleToTest",
-                ToExecuteInParallel = Helper.CreateModule((int input) => input * 2),
-                ToExecuteNotInParallel = new[]
-                {
                     Helper.CreateModule((int j) => j + 1)
                 }
-            };
-            var data = Enumerable.Range(0, 100).ToArray();
-            var result = module.Invoke(data).ToArray();
-            int i;
-            for (i = 0; i < data.Length - Vector<float>.Count; i += Vector<float>.Count)
+        };
+        var data = Enumerable.Range(0, 100).ToArray();
+        var result = module.Invoke(data).ToArray();
+        int i;
+        for (i = 0; i < data.Length - Vector<float>.Count; i += Vector<float>.Count)
+        {
+            if (!System.Numerics.Vector.EqualsAll(new Vector<int>(data, i), new Vector<int>(result, i)))
             {
-                if (!System.Numerics.Vector.EqualsAll(new Vector<int>(data, i), new Vector<int>(result, i)))
+                for (int j = 0; j < Vector<float>.Count; j++)
                 {
-                    for (int j = 0; j < Vector<float>.Count; j++)
-                    {
-                        Assert.AreEqual((i + j) * 2 + 1, result[i + j]);
-                    }
+                    Assert.AreEqual((i + j) * 2 + 1, result[i + j]);
                 }
             }
-            for (; i < data.Length; i++)
-            {
-                Assert.AreEqual(i * 2 + 1, result[i]);
-            }
+        }
+        for (; i < data.Length; i++)
+        {
+            Assert.AreEqual(i * 2 + 1, result[i]);
         }
     }
 }
+
diff --git a/tests/TMG-Framework.Test/Processing/TestGravityModel.cs b/tests/TMG-Framework.Test/Processing/TestGravityModel.cs
index 0b5e01f..eee7339 100644
--- a/tests/TMG-Framework.Test/Processing/TestGravityModel.cs
+++ b/tests/TMG-Framework.Test/Processing/TestGravityModel.cs
@@ -16,49 +16,44 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
+
 using TMG.Processing;
 using TMG.Test.Utilities;
 
-namespace TMG.Test.Processing
+namespace TMG.Test.Processing;
+
+[TestClass]
+public class TestGravityModel
 {
-    [TestClass]
-    public class TestGravityModel
+    [TestMethod]
+    public void Gravity2D()
     {
-        [TestMethod]
-        public void Gravity2D()
+        var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2));
+        var friction = new Matrix(categories, categories);
+        friction.Data[0] = 0.25f;
+        friction.Data[1] = 0.75f;
+        friction.Data[2] = 2f;
+        friction.Data[3] = 2f;
+        var production = new Vector(categories);
+        production.Data[0] = 2;
+        production.Data[1] = 2;
+        var attraction = new Vector(categories);
+        attraction.Data[0] = 1.5f;
+        attraction.Data[1] = 2.5f;
+        var gm = new Evaluate2DGravityModel()
         {
-            var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2));
-            var friction = new Matrix(categories, categories);
-            friction.Data[0] = 0.25f;
-            friction.Data[1] = 0.75f;
-            friction.Data[2] = 2f;
-            friction.Data[3] = 2f;
-            var production = new Vector(categories);
-            production.Data[0] = 2;
-            production.Data[1] = 2;
-            var attraction = new Vector(categories);
-            attraction.Data[0] = 1.5f;
-            attraction.Data[1] = 2.5f;
-            var gm = new Evaluate2DGravityModel()
-            {
-                Attraction = Helper.CreateParameter(attraction),
-                Production = Helper.CreateParameter(production),
-                Friction = Helper.CreateParameter(friction),
-                MaxError = Helper.CreateParameter(0.25f),
-                MaxIterations = Helper.CreateParameter(100)
-            };
-            var ret = gm.Invoke();
-            var result = ret.Data;
-            Assert.AreSame(categories, ret.RowCategories);
-            Assert.AreEqual(0.5f, result[0], 0.0001f);
-            Assert.AreEqual(1.5f, result[1], 0.0001f);
-            Assert.AreEqual(1f, result[2], 0.0001f);
-            Assert.AreEqual(1f, result[3], 0.0001f);
-        }
+            Attraction = Helper.CreateParameter(attraction),
+            Production = Helper.CreateParameter(production),
+            Friction = Helper.CreateParameter(friction),
+            MaxError = Helper.CreateParameter(0.25f),
+            MaxIterations = Helper.CreateParameter(100)
+        };
+        var ret = gm.Invoke();
+        var result = ret.Data;
+        Assert.AreSame(categories, ret.RowCategories);
+        Assert.AreEqual(0.5f, result[0], 0.0001f);
+        Assert.AreEqual(1.5f, result[1], 0.0001f);
+        Assert.AreEqual(1f, result[2], 0.0001f);
+        Assert.AreEqual(1f, result[3], 0.0001f);
     }
 }
diff --git a/tests/TMG-Framework.Test/Processing/TestIntegerizeMatrix.cs b/tests/TMG-Framework.Test/Processing/TestIntegerizeMatrix.cs
index 8af9737..640da7f 100644
--- a/tests/TMG-Framework.Test/Processing/TestIntegerizeMatrix.cs
+++ b/tests/TMG-Framework.Test/Processing/TestIntegerizeMatrix.cs
@@ -16,135 +16,129 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using TMG;
-using TMG.Frameworks.Data.Processing.AST;
+
 using TMG.Processing;
 using TMG.Test.Utilities;
 
-namespace TMG.Test.Processing
+namespace TMG.Test.Processing;
+
+[TestClass]
+public class TestIntegerizeMatrix
 {
-    [TestClass]
-    public class TestIntegerizeMatrix
+    /// <summary>
+    /// This test just wants to make sure that the most basic case passes.
+    /// </summary>
+    [TestMethod]
+    public void IntegerizeZeroMatrix()
     {
-        /// <summary>
-        /// This test just wants to make sure that the most basic case passes.
-        /// </summary>
-        [TestMethod]
-        public void IntegerizeZeroMatrix()
+        string? error = null;
+        if (!Categories.CreateCategories(new List<int>() { 1, 2, 3, 4 }, out var zones, ref error))
         {
-            string? error = null;
-            if (!Categories.CreateCategories(new List<int>() { 1, 2, 3, 4 }, out var zones, ref error))
-            {
-                Assert.Fail(error);
-            }
-            if (!Categories.CreateCategories(new List<int>() { 1, 2, }, out var pds, ref error))
-            {
-                Assert.Fail(error);
-            }
-            Assert.IsTrue(CategoryMap.CreateCategoryMap(zones, pds, new List<(int originFlatIndex, int destinationFlatIndex)>()
+            Assert.Fail(error);
+        }
+        if (!Categories.CreateCategories(new List<int>() { 1, 2, }, out var pds, ref error))
+        {
+            Assert.Fail(error);
+        }
+        Assert.IsTrue(CategoryMap.CreateCategoryMap(zones, pds, new List<(int originFlatIndex, int destinationFlatIndex)>()
             {
                 new (0, 0),
                 new (1, 0),
                 new (2, 1),
                 new (3, 1)
             }, out var map, ref error));
-            var inputMatrix = new Matrix(zones, zones);
-            var module = new IntegerizeMatrix()
-            {
-                RandomSeed = Helper.CreateParameter(12345),
-                InputMatrix = Helper.CreateParameter(inputMatrix),
-                ZoneToPDMap = Helper.CreateParameter(map)
-            };
-            var integerMatrix = module.Invoke();
-            Assert.IsNotNull(integerMatrix);
-        }
+        var inputMatrix = new Matrix(zones, zones);
+        var module = new IntegerizeMatrix()
+        {
+            RandomSeed = Helper.CreateParameter(12345),
+            InputMatrix = Helper.CreateParameter(inputMatrix),
+            ZoneToPDMap = Helper.CreateParameter(map)
+        };
+        var integerMatrix = module.Invoke();
+        Assert.IsNotNull(integerMatrix);
+    }
 
-        /// <summary>
-        /// This test just wants to make sure that a simple already integer matrix doesn't change.
-        /// </summary>
-        [TestMethod]
-        public void IntegerizeIdentityMatrix()
+    /// <summary>
+    /// This test just wants to make sure that a simple already integer matrix doesn't change.
+    /// </summary>
+    [TestMethod]
+    public void IntegerizeIdentityMatrix()
+    {
+        string? error = null;
+        if (!Categories.CreateCategories(new List<int>() { 1, 2, 3, 4 }, out var zones, ref error))
         {
-            string? error = null;
-            if (!Categories.CreateCategories(new List<int>() { 1, 2, 3, 4 }, out var zones, ref error))
-            {
-                Assert.Fail(error);
-            }
-            if (!Categories.CreateCategories(new List<int>() { 1, 2, }, out var pds, ref error))
-            {
-                Assert.Fail(error);
-            }
-            Assert.IsTrue(CategoryMap.CreateCategoryMap(zones, pds, new List<(int originFlatIndex, int destinationFlatIndex)>()
+            Assert.Fail(error);
+        }
+        if (!Categories.CreateCategories(new List<int>() { 1, 2, }, out var pds, ref error))
+        {
+            Assert.Fail(error);
+        }
+        Assert.IsTrue(CategoryMap.CreateCategoryMap(zones, pds, new List<(int originFlatIndex, int destinationFlatIndex)>()
             {
                 new (0, 0),
                 new (1, 0),
                 new (2, 1),
                 new (3, 1)
             }, out var map, ref error));
-            var inputMatrix = new Matrix(zones, zones);
-            inputMatrix.Data[0] = 1.0f;
-            inputMatrix.Data[3] = 1.0f;
-            var module = new IntegerizeMatrix()
-            {
-                RandomSeed = Helper.CreateParameter(12345),
-                InputMatrix = Helper.CreateParameter(inputMatrix),
-                ZoneToPDMap = Helper.CreateParameter(map)
-            };
-            var integerMatrix = module.Invoke();
-            Assert.IsNotNull(integerMatrix);
-            Assert.AreEqual(1.0f, integerMatrix.Data[0], 0.00000001f);
-            Assert.AreEqual(0.0f, integerMatrix.Data[1], 0.00000001f);
-            Assert.AreEqual(0.0f, integerMatrix.Data[2], 0.00000001f);
-            Assert.AreEqual(1.0f, integerMatrix.Data[3], 0.00000001f);
-        }
+        var inputMatrix = new Matrix(zones, zones);
+        inputMatrix.Data[0] = 1.0f;
+        inputMatrix.Data[3] = 1.0f;
+        var module = new IntegerizeMatrix()
+        {
+            RandomSeed = Helper.CreateParameter(12345),
+            InputMatrix = Helper.CreateParameter(inputMatrix),
+            ZoneToPDMap = Helper.CreateParameter(map)
+        };
+        var integerMatrix = module.Invoke();
+        Assert.IsNotNull(integerMatrix);
+        Assert.AreEqual(1.0f, integerMatrix.Data[0], 0.00000001f);
+        Assert.AreEqual(0.0f, integerMatrix.Data[1], 0.00000001f);
+        Assert.AreEqual(0.0f, integerMatrix.Data[2], 0.00000001f);
+        Assert.AreEqual(1.0f, integerMatrix.Data[3], 0.00000001f);
+    }
 
-        /// <summary>
-        /// Test that we can actually integerize a real matrix.
-        /// </summary>
-        [TestMethod]
-        public void IntegerizeRealMatrix()
+    /// <summary>
+    /// Test that we can actually integerize a real matrix.
+    /// </summary>
+    [TestMethod]
+    public void IntegerizeRealMatrix()
+    {
+        string? error = null;
+        if (!Categories.CreateCategories(new List<int>() { 1, 2, 3, 4 }, out var zones, ref error))
         {
-            string? error = null;
-            if (!Categories.CreateCategories(new List<int>() { 1, 2, 3, 4 }, out var zones, ref error))
-            {
-                Assert.Fail(error);
-            }
-            if (!Categories.CreateCategories(new List<int>() { 1, 2, }, out var pds, ref error))
-            {
-                Assert.Fail(error);
-            }
-            Assert.IsTrue(CategoryMap.CreateCategoryMap(zones, pds, new List<(int originFlatIndex, int destinationFlatIndex)>()
+            Assert.Fail(error);
+        }
+        if (!Categories.CreateCategories(new List<int>() { 1, 2, }, out var pds, ref error))
+        {
+            Assert.Fail(error);
+        }
+        Assert.IsTrue(CategoryMap.CreateCategoryMap(zones, pds, new List<(int originFlatIndex, int destinationFlatIndex)>()
             {
                 new (0, 0),
                 new (1, 0),
                 new (2, 1),
                 new (3, 1)
             }, out var map, ref error));
-            var random = new Random(12345);
-            var inputMatrix = new Matrix(zones, zones);
-            for (int i = 0; i < inputMatrix.Data.Length; i++)
-            {
-                inputMatrix.Data[i] = (float)random.NextDouble();
-            }
-            var module = new IntegerizeMatrix()
-            {
-                RandomSeed = Helper.CreateParameter(12345),
-                InputMatrix = Helper.CreateParameter(inputMatrix.Clone()),
-                ZoneToPDMap = Helper.CreateParameter(map)
-            };
-            var integerMatrix = module.Invoke();
-            Assert.IsNotNull(integerMatrix);
+        var random = new Random(12345);
+        var inputMatrix = new Matrix(zones, zones);
+        for (int i = 0; i < inputMatrix.Data.Length; i++)
+        {
+            inputMatrix.Data[i] = (float)random.NextDouble();
+        }
+        var module = new IntegerizeMatrix()
+        {
+            RandomSeed = Helper.CreateParameter(12345),
+            InputMatrix = Helper.CreateParameter(inputMatrix.Clone()),
+            ZoneToPDMap = Helper.CreateParameter(map)
+        };
+        var integerMatrix = module.Invoke();
+        Assert.IsNotNull(integerMatrix);
 
-            // Make sure they are close to integers and only +- 1 from the original values
-            for (int i = 0; i < integerMatrix.Data.Length; i++)
-            {
-                Assert.AreEqual(inputMatrix.Data[i], integerMatrix.Data[i], 1.000001f);
-                Assert.AreEqual(Math.Truncate(integerMatrix.Data[i]), (double)integerMatrix.Data[0], 1.000001f);
-            }
+        // Make sure they are close to integers and only +- 1 from the original values
+        for (int i = 0; i < integerMatrix.Data.Length; i++)
+        {
+            Assert.AreEqual(inputMatrix.Data[i], integerMatrix.Data[i], 1.000001f);
+            Assert.AreEqual(Math.Truncate(integerMatrix.Data[i]), (double)integerMatrix.Data[0], 1.000001f);
         }
     }
 }
diff --git a/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsCSV.cs b/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsCSV.cs
index 559f2f4..aa44733 100644
--- a/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsCSV.cs
+++ b/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsCSV.cs
@@ -16,162 +16,156 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
+
 using TMG.Saving;
 using TMG.Test.Utilities;
-using XTMF2.RuntimeModules;
 
-namespace TMG.Test.Saving
+namespace TMG.Test.Saving;
+
+[TestClass]
+public class TestSaveMatrixAsCSV
 {
-    [TestClass]
-    public class TestSaveMatrixAsCSV
+    [TestMethod]
+    public void SaveMatrixAsCSVAsMatrix()
     {
-        [TestMethod]
-        public void SaveMatrixAsCSVAsMatrix()
+        SaveMatrixAsCSV module = new SaveMatrixAsCSV()
         {
-            SaveMatrixAsCSV module = new SaveMatrixAsCSV()
-            {
-                FirstIndexHeader = Helper.CreateParameter("First"),
-                SecondIndexHeader = Helper.CreateParameter("Second"),
-                DataIndexHeader = Helper.CreateParameter("Data"),
-                ThirdNormalized = Helper.CreateParameter(false)
-            };
-            var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
-            var a = new Matrix(categories, categories);
-            var fileName = Path.GetTempFileName();
-            try
+            FirstIndexHeader = Helper.CreateParameter("First"),
+            SecondIndexHeader = Helper.CreateParameter("Second"),
+            DataIndexHeader = Helper.CreateParameter("Data"),
+            ThirdNormalized = Helper.CreateParameter(false)
+        };
+        var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
+        var a = new Matrix(categories, categories);
+        var fileName = Path.GetTempFileName();
+        try
+        {
+            using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
             {
-                using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
-                {
-                    module.Invoke((a, writeStream));
-                }
+                module.Invoke((a, writeStream));
             }
-            finally
+        }
+        finally
+        {
+            FileInfo file = new FileInfo(fileName);
+            if (file.Exists)
             {
-                FileInfo file = new FileInfo(fileName);
-                if (file.Exists)
-                {
-                    file.Delete();
-                }
+                file.Delete();
             }
         }
+    }
 
-        [TestMethod]
-        public void SaveMatrixAsCSVAsMatrixAndLoad()
+    [TestMethod]
+    public void SaveMatrixAsCSVAsMatrixAndLoad()
+    {
+        SaveMatrixAsCSV module = new SaveMatrixAsCSV()
         {
-            SaveMatrixAsCSV module = new SaveMatrixAsCSV()
+            FirstIndexHeader = Helper.CreateParameter("First"),
+            SecondIndexHeader = Helper.CreateParameter("Second"),
+            DataIndexHeader = Helper.CreateParameter("Data"),
+            ThirdNormalized = Helper.CreateParameter(false)
+        };
+        var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
+        var a = new Matrix(categories, categories);
+        var fileName = Path.GetTempFileName();
+        try
+        {
+            using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
             {
-                FirstIndexHeader = Helper.CreateParameter("First"),
-                SecondIndexHeader = Helper.CreateParameter("Second"),
-                DataIndexHeader = Helper.CreateParameter("Data"),
-                ThirdNormalized = Helper.CreateParameter(false)
-            };
-            var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
-            var a = new Matrix(categories, categories);
-            var fileName = Path.GetTempFileName();
-            try
+                module.Invoke((a, writeStream));
+            }
+            // Now that the matrix has been saved attempt to load it back in.
+            using (var readStream = Helper.CreateReadStreamFromFile(fileName))
             {
-                using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
+                var readMatrix = new TMG.Loading.LoadMatrixFromCSVMatrix()
                 {
-                    module.Invoke((a, writeStream));
-                }
-                // Now that the matrix has been saved attempt to load it back in.
-                using (var readStream = Helper.CreateReadStreamFromFile(fileName))
-                {
-                    var readMatrix = new TMG.Loading.LoadMatrixFromCSVMatrix()
-                    {
-                        RowCategories = Helper.CreateParameter(categories),
-                        ColumnCategories = Helper.CreateParameter(categories)
-                    }.Invoke(readStream);
-                    string? error = null;
-                    Assert.IsTrue(MatrixHelper.Compare(a, readMatrix, ref error), error);
-                }
+                    RowCategories = Helper.CreateParameter(categories),
+                    ColumnCategories = Helper.CreateParameter(categories)
+                }.Invoke(readStream);
+                string? error = null;
+                Assert.IsTrue(MatrixHelper.Compare(a, readMatrix, ref error), error);
             }
-            finally
+        }
+        finally
+        {
+            FileInfo file = new FileInfo(fileName);
+            if (file.Exists)
             {
-                FileInfo file = new FileInfo(fileName);
-                if (file.Exists)
-                {
-                    file.Delete();
-                }
+                file.Delete();
             }
         }
+    }
 
-        [TestMethod]
-        public void SaveMatrixAsCSVAsThirdNormalized()
+    [TestMethod]
+    public void SaveMatrixAsCSVAsThirdNormalized()
+    {
+        SaveMatrixAsCSV module = new SaveMatrixAsCSV()
         {
-            SaveMatrixAsCSV module = new SaveMatrixAsCSV()
-            {
-                FirstIndexHeader = Helper.CreateParameter("First"),
-                SecondIndexHeader = Helper.CreateParameter("Second"),
-                DataIndexHeader = Helper.CreateParameter("Data"),
-                ThirdNormalized = Helper.CreateParameter(true)
-            };
-            var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
-            var a = new Matrix(categories, categories);
-            var fileName = Path.GetTempFileName();
-            try
+            FirstIndexHeader = Helper.CreateParameter("First"),
+            SecondIndexHeader = Helper.CreateParameter("Second"),
+            DataIndexHeader = Helper.CreateParameter("Data"),
+            ThirdNormalized = Helper.CreateParameter(true)
+        };
+        var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
+        var a = new Matrix(categories, categories);
+        var fileName = Path.GetTempFileName();
+        try
+        {
+            using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
             {
-                using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
-                {
-                    module.Invoke((a, writeStream));
-                }
+                module.Invoke((a, writeStream));
             }
-            finally
+        }
+        finally
+        {
+            FileInfo file = new FileInfo(fileName);
+            if (file.Exists)
             {
-                FileInfo file = new FileInfo(fileName);
-                if (file.Exists)
-                {
-                    file.Delete();
-                }
+                file.Delete();
             }
         }
+    }
 
-        [TestMethod]
-        public void SaveMatrixAsCSVAsThirdNormalizedAndLoad()
+    [TestMethod]
+    public void SaveMatrixAsCSVAsThirdNormalizedAndLoad()
+    {
+        SaveMatrixAsCSV module = new SaveMatrixAsCSV()
         {
-            SaveMatrixAsCSV module = new SaveMatrixAsCSV()
+            FirstIndexHeader = Helper.CreateParameter("First"),
+            SecondIndexHeader = Helper.CreateParameter("Second"),
+            DataIndexHeader = Helper.CreateParameter("Data"),
+            ThirdNormalized = Helper.CreateParameter(true)
+        };
+        var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
+        var a = new Matrix(categories, categories);
+        var fileName = Path.GetTempFileName();
+        try
+        {
+            using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
             {
-                FirstIndexHeader = Helper.CreateParameter("First"),
-                SecondIndexHeader = Helper.CreateParameter("Second"),
-                DataIndexHeader = Helper.CreateParameter("Data"),
-                ThirdNormalized = Helper.CreateParameter(true)
-            };
-            var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
-            var a = new Matrix(categories, categories);
-            var fileName = Path.GetTempFileName();
-            try
+                module.Invoke((a, writeStream));
+            }
+            // Now that the matrix has been saved attempt to load it back in.
+            using (var readStream = Helper.CreateReadStreamFromFile(fileName))
             {
-                using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
+                var readMatrix = new TMG.Loading.LoadMatrixFromCSVThirdNormalized()
                 {
-                    module.Invoke((a, writeStream));
-                }
-                // Now that the matrix has been saved attempt to load it back in.
-                using (var readStream = Helper.CreateReadStreamFromFile(fileName))
-                {
-                    var readMatrix = new TMG.Loading.LoadMatrixFromCSVThirdNormalized()
-                    {
-                        RowCategories = Helper.CreateParameter(categories),
-                        ColumnCategories = Helper.CreateParameter(categories),
-                        OriginColumn = Helper.CreateParameter(0),
-                        DestinationColumn = Helper.CreateParameter(1),
-                        DataColumn = Helper.CreateParameter(2),
-                    }.Invoke(readStream);
-                    string? error = null;
-                    Assert.IsTrue(MatrixHelper.Compare(a, readMatrix, ref error), error);
-                }
+                    RowCategories = Helper.CreateParameter(categories),
+                    ColumnCategories = Helper.CreateParameter(categories),
+                    OriginColumn = Helper.CreateParameter(0),
+                    DestinationColumn = Helper.CreateParameter(1),
+                    DataColumn = Helper.CreateParameter(2),
+                }.Invoke(readStream);
+                string? error = null;
+                Assert.IsTrue(MatrixHelper.Compare(a, readMatrix, ref error), error);
             }
-            finally
+        }
+        finally
+        {
+            FileInfo file = new FileInfo(fileName);
+            if (file.Exists)
             {
-                FileInfo file = new FileInfo(fileName);
-                if (file.Exists)
-                {
-                    file.Delete();
-                }
+                file.Delete();
             }
         }
     }
diff --git a/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsMTX.cs b/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsMTX.cs
index 64bebba..97db16e 100644
--- a/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsMTX.cs
+++ b/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsMTX.cs
@@ -16,74 +16,69 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
+
 using TMG.Saving;
 using TMG.Test.Utilities;
-using XTMF2.RuntimeModules;
 
-namespace TMG.Test.Saving
+
+namespace TMG.Test.Saving;
+
+[TestClass]
+public class TestSaveMatrixAsMTX
 {
-    [TestClass]
-    public class TestSaveMatrixAsMTX
+    [TestMethod]
+    public void SaveMatrixAsMTXAsMatrix()
     {
-        [TestMethod]
-        public void SaveMatrixAsMTXAsMatrix()
+        var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
+        var a = new Matrix(categories, categories);
+        var fileName = Path.GetTempFileName();
+        try
         {
-            var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
-            var a = new Matrix(categories, categories);
-            var fileName = Path.GetTempFileName();
-            try
+            using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
             {
-                using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
-                {
-                    new SaveMatrixAsMTX().Invoke((a, writeStream));
-                }
+                new SaveMatrixAsMTX().Invoke((a, writeStream));
             }
-            finally
+        }
+        finally
+        {
+            FileInfo file = new FileInfo(fileName);
+            if (file.Exists)
             {
-                FileInfo file = new FileInfo(fileName);
-                if (file.Exists)
-                {
-                    file.Delete();
-                }
+                file.Delete();
             }
         }
+    }
 
-        [TestMethod]
-        public void SaveMatrixAsMTXAsMatrixAndLoad()
+    [TestMethod]
+    public void SaveMatrixAsMTXAsMatrixAndLoad()
+    {
+        var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
+        var a = new Matrix(categories, categories);
+        var fileName = Path.GetTempFileName();
+        try
         {
-            var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
-            var a = new Matrix(categories, categories);
-            var fileName = Path.GetTempFileName();
-            try
+            using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
             {
-                using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
-                {
-                    new SaveMatrixAsMTX().Invoke((a, writeStream));
-                }
-                // Now that the matrix has been saved attempt to load it back in.
-                using (var readStream = Helper.CreateReadStreamFromFile(fileName))
-                {
-                    var readMatrix = new TMG.Loading.LoadMatrixFromMTX()
-                    {
-                        Categories = Helper.CreateParameter(categories),
-                        ConvertBetweenZoneSystems = Helper.CreateParameter(false)
-                    }.Invoke(readStream);
-                    string? error = null;
-                    Assert.IsTrue(MatrixHelper.Compare(a, readMatrix, ref error), error);
-                }
+                new SaveMatrixAsMTX().Invoke((a, writeStream));
             }
-            finally
+            // Now that the matrix has been saved attempt to load it back in.
+            using (var readStream = Helper.CreateReadStreamFromFile(fileName))
             {
-                FileInfo file = new FileInfo(fileName);
-                if (file.Exists)
+                var readMatrix = new TMG.Loading.LoadMatrixFromMTX()
                 {
-                    file.Delete();
-                }
+                    Categories = Helper.CreateParameter(categories),
+                    ConvertBetweenZoneSystems = Helper.CreateParameter(false)
+                }.Invoke(readStream);
+                string? error = null;
+                Assert.IsTrue(MatrixHelper.Compare(a, readMatrix, ref error), error);
+            }
+        }
+        finally
+        {
+            FileInfo file = new FileInfo(fileName);
+            if (file.Exists)
+            {
+                file.Delete();
             }
         }
     }
diff --git a/tests/TMG-Framework.Test/Saving/TestSaveVectorAsCSV.cs b/tests/TMG-Framework.Test/Saving/TestSaveVectorAsCSV.cs
index 48b86ea..b3765a4 100644
--- a/tests/TMG-Framework.Test/Saving/TestSaveVectorAsCSV.cs
+++ b/tests/TMG-Framework.Test/Saving/TestSaveVectorAsCSV.cs
@@ -16,107 +16,101 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Text;
+
 using TMG.Saving;
 using TMG.Test.Utilities;
-using XTMF2.RuntimeModules;
 
-namespace TMG.Test.Saving
+namespace TMG.Test.Saving;
+
+[TestClass]
+public class TestSaveVectorAsCSV
 {
-    [TestClass]
-    public class TestSaveVectorAsCSV
+    [TestMethod]
+    public void SaveVectorAsCSV()
     {
-        [TestMethod]
-        public void SaveVectorAsCSV()
+        var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
+        var a = new Vector(categories);
+        var fileName = Path.GetTempFileName();
+        try
         {
-            var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
-            var a = new Vector(categories);
-            var fileName = Path.GetTempFileName();
-            try
+            using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
             {
-                using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
+                new SaveVectorAsCSV()
                 {
-                    new SaveVectorAsCSV()
-                    {
-                        MapColumnName = Helper.CreateParameter("Zones"),
-                        DataColumnName = Helper.CreateParameter("Data")
-                    }.Invoke((a, writeStream));
-                }
+                    MapColumnName = Helper.CreateParameter("Zones"),
+                    DataColumnName = Helper.CreateParameter("Data")
+                }.Invoke((a, writeStream));
             }
-            finally
+        }
+        finally
+        {
+            FileInfo file = new FileInfo(fileName);
+            if (file.Exists)
             {
-                FileInfo file = new FileInfo(fileName);
-                if (file.Exists)
-                {
-                    file.Delete();
-                }
+                file.Delete();
             }
         }
+    }
 
-        [TestMethod]
-        public void SaveVectorAsCSVAndLoad()
+    [TestMethod]
+    public void SaveVectorAsCSVAndLoad()
+    {
+        var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
+        var a = new Vector(categories);
+        var fileName = Path.GetTempFileName();
+        try
         {
-            var categories = MapHelper.LoadMap(MapHelper.WriteCSV(2000));
-            var a = new Vector(categories);
-            var fileName = Path.GetTempFileName();
-            try
+            using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
             {
-                using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
-                {
-                    new SaveVectorAsCSV()
-                    {
-                        MapColumnName = Helper.CreateParameter("Zones"),
-                        DataColumnName = Helper.CreateParameter("Data")
-                    }.Invoke((a, writeStream));
-                }
-                // Now that the matrix has been saved attempt to load it back in.
-                using (var readStream = Helper.CreateReadStreamFromFile(fileName))
+                new SaveVectorAsCSV()
                 {
-                    var readVector = new TMG.Loading.LoadVectorFromCSV()
-                    {
-                        Categories = Helper.CreateParameter(categories),
-                        MapColumn = Helper.CreateParameter(0),
-                        DataColumn = Helper.CreateParameter(1)
-                    }.Invoke(readStream);
-                    string? error = null;
-                    Assert.IsTrue(Compare(a, readVector, ref error), error);
-                }
+                    MapColumnName = Helper.CreateParameter("Zones"),
+                    DataColumnName = Helper.CreateParameter("Data")
+                }.Invoke((a, writeStream));
             }
-            finally
+            // Now that the matrix has been saved attempt to load it back in.
+            using (var readStream = Helper.CreateReadStreamFromFile(fileName))
             {
-                FileInfo file = new FileInfo(fileName);
-                if (file.Exists)
+                var readVector = new TMG.Loading.LoadVectorFromCSV()
                 {
-                    file.Delete();
-                }
+                    Categories = Helper.CreateParameter(categories),
+                    MapColumn = Helper.CreateParameter(0),
+                    DataColumn = Helper.CreateParameter(1)
+                }.Invoke(readStream);
+                string? error = null;
+                Assert.IsTrue(Compare(a, readVector, ref error), error);
             }
         }
-
-        internal static bool Compare(Vector expected, Vector test, 
-            [NotNullWhen(false)] ref string? error)
+        finally
         {
-            if (expected.Categories != test.Categories)
+            FileInfo file = new FileInfo(fileName);
+            if (file.Exists)
             {
-                error = "The categories are not the same!";
-                return false;
+                file.Delete();
             }
-            // compare the data
-            var expectedData = expected.Data;
-            var testData = test.Data;
-            for (int i = 0; i < testData.Length; i++)
+        }
+    }
+
+    internal static bool Compare(Vector expected, Vector test,
+        [NotNullWhen(false)] ref string? error)
+    {
+        if (expected.Categories != test.Categories)
+        {
+            error = "The categories are not the same!";
+            return false;
+        }
+        // compare the data
+        var expectedData = expected.Data;
+        var testData = test.Data;
+        for (int i = 0; i < testData.Length; i++)
+        {
+            if (expectedData[i] != testData[i])
             {
-                if (expectedData[i] != testData[i])
-                {
-                    error = $"Found different elements at position {i}: {expectedData[i]} != {testData[i]}!";
-                    return false;
-                }
+                error = $"Found different elements at position {i}: {expectedData[i]} != {testData[i]}!";
+                return false;
             }
-            return true;
         }
+        return true;
     }
 }
+
diff --git a/tests/TMG-Framework.Test/Select/TestSelectGivenTime.cs b/tests/TMG-Framework.Test/Select/TestSelectGivenTime.cs
index f832c87..6c248cc 100644
--- a/tests/TMG-Framework.Test/Select/TestSelectGivenTime.cs
+++ b/tests/TMG-Framework.Test/Select/TestSelectGivenTime.cs
@@ -17,40 +17,33 @@ You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using TMG;
-using TMG.Frameworks.Data.Processing.AST;
-using TMG.Processing;
 using TMG.Select;
 using TMG.Test.Utilities;
 
-namespace TMG.Test.Select
+namespace TMG.Test.Select;
+
+[TestClass]
+public class TestSelectGivenTime
 {
-    [TestClass]
-    public class TestSelectGivenTime
+    [TestMethod]
+    public void SelectDataGivenTime()
     {
-        [TestMethod]
-        public void SelectDataGivenTime()
+        var selector = new SelectGivenTime<int>()
         {
-            var selector = new SelectGivenTime<int>()
+            Name = "Selection Module",
+            DefaultTimePeriod = Helper.CreateParameter(0, "Default Value"),
+            TimePeriodData = new[]
             {
-                Name = "Selection Module",
-                DefaultTimePeriod = Helper.CreateParameter(0, "Default Value"),
-                TimePeriodData = new []
-                {
                     Helper.CreateParameter((new TimePeriod(Time.FromMinutes(60), Time.FromMinutes(120)), 1), "First"),
                     Helper.CreateParameter((new TimePeriod(Time.FromMinutes(120), Time.FromMinutes(240)), 2), "Second"),
                     Helper.CreateParameter((new TimePeriod(Time.FromMinutes(250), Time.FromMinutes(360)), 3), "Third")
                 }
-            };
-            Assert.AreEqual(1, selector.Invoke(Time.FromMinutes(60.0f)));
-            Assert.AreEqual(2, selector.Invoke(Time.FromMinutes(120.0f)));
-            Assert.AreEqual(1, selector.Invoke(Time.FromMinutes(240.0f)));
-            Assert.AreEqual(1, selector.Invoke(Time.FromMinutes(360.0f)));
-            Assert.AreEqual(3, selector.Invoke(Time.FromMinutes(250.0f)));
-            Assert.AreEqual(3, selector.Invoke(Time.FromMinutes(270.0f)));
-        }
+        };
+        Assert.AreEqual(1, selector.Invoke(Time.FromMinutes(60.0f)));
+        Assert.AreEqual(2, selector.Invoke(Time.FromMinutes(120.0f)));
+        Assert.AreEqual(1, selector.Invoke(Time.FromMinutes(240.0f)));
+        Assert.AreEqual(1, selector.Invoke(Time.FromMinutes(360.0f)));
+        Assert.AreEqual(3, selector.Invoke(Time.FromMinutes(250.0f)));
+        Assert.AreEqual(3, selector.Invoke(Time.FromMinutes(270.0f)));
     }
 }
diff --git a/tests/TMG-Framework.Test/TMG-Framework.Test.csproj b/tests/TMG-Framework.Test/TMG-Framework.Test.csproj
index c8fe0c2..dcfd92e 100644
--- a/tests/TMG-Framework.Test/TMG-Framework.Test.csproj
+++ b/tests/TMG-Framework.Test/TMG-Framework.Test.csproj
@@ -7,6 +7,7 @@
     <ApplicationIcon />    
     <OutputTypeEx>library</OutputTypeEx>    
     <StartupObject />
+    <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
diff --git a/tests/TMG-Framework.Test/Utilities/Helper.cs b/tests/TMG-Framework.Test/Utilities/Helper.cs
index 852ee37..b2ff0ca 100644
--- a/tests/TMG-Framework.Test/Utilities/Helper.cs
+++ b/tests/TMG-Framework.Test/Utilities/Helper.cs
@@ -16,136 +16,129 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
 using XTMF2;
 using XTMF2.RuntimeModules;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Reflection;
 
 [assembly: Parallelize]
 
-namespace TMG.Test.Utilities
+namespace TMG.Test.Utilities;
+
+internal static class Helper
 {
-    internal static class Helper
+    /// <summary>
+    /// Generate a new basic parameter with the given value
+    /// </summary>
+    /// <typeparam name="T">The return type</typeparam>
+    /// <param name="value">The value to be returned</param>
+    /// <param name="moduleName">The name of the module to create.</param>
+    /// <returns></returns>
+    internal static IFunction<T> CreateParameter<T>(T value, string? moduleName = null)
     {
-        /// <summary>
-        /// Generate a new basic parameter with the given value
-        /// </summary>
-        /// <typeparam name="T">The return type</typeparam>
-        /// <param name="value">The value to be returned</param>
-        /// <param name="moduleName">The name of the module to create.</param>
-        /// <returns></returns>
-        internal static IFunction<T> CreateParameter<T>(T value, string? moduleName = null)
-        {
-            return new BasicParameter<T>()
-            {
-                Name = moduleName,
-                Value = value
-            };
-        }
-
-        private class CustomizableModule<T, K> : BaseFunction<T, K>
+        return new BasicParameter<T>()
         {
-            private Func<T, K> _inner;
+            Name = moduleName,
+            Value = value
+        };
+    }
 
-            public CustomizableModule(Func<T, K> inner)
-            {
-                _inner = inner;
-            }
+    private class CustomizableModule<T, K> : BaseFunction<T, K>
+    {
+        private Func<T, K> _inner;
 
-            public override K Invoke(T context)
-            {
-                return _inner(context);
-            }
+        public CustomizableModule(Func<T, K> inner)
+        {
+            _inner = inner;
         }
 
-        /// <summary>
-        /// Generate a simple module
-        /// </summary>
-        /// <typeparam name="T">InputType</typeparam>
-        /// <typeparam name="K">OutputType</typeparam>
-        /// <param name="innerFunction">Processing logic</param>
-        /// <returns>A module that executes the function passed in.</returns>
-        internal static IFunction<T, K> CreateModule<T, K>(Func<T, K> innerFunction, string? moduleName = null)
+        public override K Invoke(T context)
         {
-            return new CustomizableModule<T, K>(innerFunction)
-            {
-                Name = moduleName
-            };
+            return _inner(context);
         }
+    }
 
+    /// <summary>
+    /// Generate a simple module
+    /// </summary>
+    /// <typeparam name="T">InputType</typeparam>
+    /// <typeparam name="K">OutputType</typeparam>
+    /// <param name="innerFunction">Processing logic</param>
+    /// <returns>A module that executes the function passed in.</returns>
+    internal static IFunction<T, K> CreateModule<T, K>(Func<T, K> innerFunction, string? moduleName = null)
+    {
+        return new CustomizableModule<T, K>(innerFunction)
+        {
+            Name = moduleName
+        };
+    }
 
-        /// <summary>
-        /// Create a ReadStream from the given file path.
-        /// </summary>
-        /// <param name="fileName">The path to the file to read.</param>
-        /// <returns>A ReadStream for the given file.</returns>
-        internal static ReadStream CreateReadStreamFromFile(string fileName)
+
+    /// <summary>
+    /// Create a ReadStream from the given file path.
+    /// </summary>
+    /// <param name="fileName">The path to the file to read.</param>
+    /// <returns>A ReadStream for the given file.</returns>
+    internal static ReadStream CreateReadStreamFromFile(string fileName)
+    {
+        return (new OpenReadStreamFromFile()
         {
-            return (new OpenReadStreamFromFile()
-            {
-                FilePath = CreateParameter(fileName)
-            }).Invoke();
-        }
+            FilePath = CreateParameter(fileName)
+        }).Invoke();
+    }
 
-        /// <summary>
-        /// Create a WriteStream to the given file path.
-        /// </summary>
-        /// <param name="fileName">The path to the file to write.</param>
-        /// <returns>A WriteStream for the given file.</returns>
-        internal static WriteStream CreateWriteStreamFromFile(string fileName)
+    /// <summary>
+    /// Create a WriteStream to the given file path.
+    /// </summary>
+    /// <param name="fileName">The path to the file to write.</param>
+    /// <returns>A WriteStream for the given file.</returns>
+    internal static WriteStream CreateWriteStreamFromFile(string fileName)
+    {
+        return (new OpenWriteStreamFromFile()
         {
-            return (new OpenWriteStreamFromFile()
-            {
-                FilePath = CreateParameter(fileName)
-            }).Invoke();
-        }
+            FilePath = CreateParameter(fileName)
+        }).Invoke();
+    }
 
-        /// <summary>
-        /// Assert that the given action throws an exception of the given type.
-        /// Leave the exception type null to allow any exception.
-        /// </summary>
-        /// <param name="action"></param>
-        /// <param name="expectedExceptionType"></param>
-        public static void ThrowsException(Action action, Type? expectedExceptionType = null)
+    /// <summary>
+    /// Assert that the given action throws an exception of the given type.
+    /// Leave the exception type null to allow any exception.
+    /// </summary>
+    /// <param name="action"></param>
+    /// <param name="expectedExceptionType"></param>
+    public static void ThrowsException(Action action, Type? expectedExceptionType = null)
+    {
+        try
         {
-            try
-            {
-                action();
-                Assert.Fail("Expected exception of type " + (expectedExceptionType?.FullName ?? "null"));
-            }
-            catch (Exception ex)
+            action();
+            Assert.Fail("Expected exception of type " + (expectedExceptionType?.FullName ?? "null"));
+        }
+        catch (Exception ex)
+        {
+            if (expectedExceptionType is not null && ex.GetType() != expectedExceptionType)
             {
-                if (expectedExceptionType is not null && ex.GetType() != expectedExceptionType)
-                {
-                    Assert.Fail("Expected exception of type " + expectedExceptionType.FullName + " but got " + ex.GetType().FullName);
-                }
+                Assert.Fail("Expected exception of type " + expectedExceptionType.FullName + " but got " + ex.GetType().FullName);
             }
         }
+    }
 
-        /// <summary>
-        /// Assert that the given action throws an exception of the given type.
-        /// Leave the exception type null to allow any exception.
-        /// </summary>
-        /// <param name="action"></param>
-        /// <param name="expectedExceptionType"></param>
-        public static void ThrowsException<T>(Action action)
-            where T : Exception
+    /// <summary>
+    /// Assert that the given action throws an exception of the given type.
+    /// Leave the exception type null to allow any exception.
+    /// </summary>
+    /// <param name="action"></param>
+    /// <param name="expectedExceptionType"></param>
+    public static void ThrowsException<T>(Action action)
+        where T : Exception
+    {
+        try
         {
-            try
-            {
-                action();
-                Assert.Fail("Expected exception of type " + typeof(T).FullName);
-            }
-            catch (Exception ex)
+            action();
+            Assert.Fail("Expected exception of type " + typeof(T).FullName);
+        }
+        catch (Exception ex)
+        {
+            if (ex.GetType() != typeof(T))
             {
-                if (ex.GetType() != typeof(T))
-                {
-                    Assert.Fail("Expected exception of type " + typeof(T).FullName + " but got " + ex.GetType().FullName);
-                }
+                Assert.Fail("Expected exception of type " + typeof(T).FullName + " but got " + ex.GetType().FullName);
             }
         }
     }
diff --git a/tests/TMG-Framework.Test/Utilities/MapHelper.cs b/tests/TMG-Framework.Test/Utilities/MapHelper.cs
index 716d110..53a6490 100644
--- a/tests/TMG-Framework.Test/Utilities/MapHelper.cs
+++ b/tests/TMG-Framework.Test/Utilities/MapHelper.cs
@@ -16,92 +16,87 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
+
 using TMG.Loading;
 using XTMF2.RuntimeModules;
 
-namespace TMG.Test.Utilities
+namespace TMG.Test.Utilities;
+
+static class MapHelper
 {
-    static class MapHelper
+    internal static string WriteCSV(int elements)
     {
-        internal static string WriteCSV(int elements)
+        var tempName = Path.GetTempFileName();
+        try
         {
-            var tempName = Path.GetTempFileName();
-            try
+            using (StreamWriter writer = File.CreateText(tempName))
             {
-                using (StreamWriter writer = File.CreateText(tempName))
+                writer.WriteLine("Zone");
+                for (int i = 0; i < elements; i++)
                 {
-                    writer.WriteLine("Zone");
-                    for (int i = 0; i < elements; i++)
-                    {
-                        writer.WriteLine(i + 1);
-                    }
+                    writer.WriteLine(i + 1);
                 }
             }
-            catch
-            {
-                File.Delete(tempName);
-                Assert.Fail("Unable to create map file!");
-            }
-            return tempName;
         }
+        catch
+        {
+            File.Delete(tempName);
+            Assert.Fail("Unable to create map file!");
+        }
+        return tempName;
+    }
 
-        internal static string WriteBackwardsCSV(int elements)
+    internal static string WriteBackwardsCSV(int elements)
+    {
+        var tempName = Path.GetTempFileName();
+        try
         {
-            var tempName = Path.GetTempFileName();
-            try
+            using (StreamWriter writer = File.CreateText(tempName))
             {
-                using (StreamWriter writer = File.CreateText(tempName))
+                writer.WriteLine("Zone");
+                for (int i = elements - 1; i >= 0; i--)
                 {
-                    writer.WriteLine("Zone");
-                    for (int i = elements - 1; i >= 0; i--)
-                    {
-                        writer.WriteLine(i + 1);
-                    }
+                    writer.WriteLine(i + 1);
                 }
             }
-            catch
-            {
-                File.Delete(tempName);
-                Assert.Fail("Unable to create map file!");
-            }
-            return tempName;
         }
+        catch
+        {
+            File.Delete(tempName);
+            Assert.Fail("Unable to create map file!");
+        }
+        return tempName;
+    }
 
-        internal static Categories LoadMap(string fileName)
+    internal static Categories LoadMap(string fileName)
+    {
+        try
         {
-            try
-            {
-                var mapLoader = new LoadCategoriesFromCSV();
-                using (var reader = Helper.CreateReadStreamFromFile(fileName))
-                {
-                    return mapLoader.Invoke(reader);
-                }
-            }
-            finally
+            var mapLoader = new LoadCategoriesFromCSV();
+            using (var reader = Helper.CreateReadStreamFromFile(fileName))
             {
-                File.Delete(fileName);
+                return mapLoader.Invoke(reader);
             }
         }
+        finally
+        {
+            File.Delete(fileName);
+        }
+    }
 
-        /// <summary>
-        /// Generate categories that are 1 indexed.
-        /// </summary>
-        /// <param name="numberOfElements">The number of elements to have.</param>
-        /// <returns>A new Categories with sparse space in [1..numberOfElements]</returns>
-        internal static Categories LoadMap(int numberOfElements)
+    /// <summary>
+    /// Generate categories that are 1 indexed.
+    /// </summary>
+    /// <param name="numberOfElements">The number of elements to have.</param>
+    /// <returns>A new Categories with sparse space in [1..numberOfElements]</returns>
+    internal static Categories LoadMap(int numberOfElements)
+    {
+        string? error = null;
+        if (!Categories.CreateCategories(Enumerable.Range(1, numberOfElements).ToList(), out var categories, ref error))
         {
-            string? error = null;
-            if (!Categories.CreateCategories(Enumerable.Range(1, numberOfElements).ToList(), out var categories, ref error))
-            {
-                Assert.Fail(error);
-            }
-            return categories;
+            Assert.Fail(error);
         }
+        return categories;
     }
 }
+
diff --git a/tests/TMG-Framework.Test/Utilities/MatrixHelper.cs b/tests/TMG-Framework.Test/Utilities/MatrixHelper.cs
index 7bcbbda..887629f 100644
--- a/tests/TMG-Framework.Test/Utilities/MatrixHelper.cs
+++ b/tests/TMG-Framework.Test/Utilities/MatrixHelper.cs
@@ -16,133 +16,127 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Text;
+
 using TMG.Saving;
 
-namespace TMG.Test.Utilities
+namespace TMG.Test.Utilities;
+
+static class MatrixHelper
 {
-    static class MatrixHelper
+    internal static string WriteMatrixToCSVMatrix(Categories categories, float[][] data)
     {
-        internal static string WriteMatrixToCSVMatrix(Categories categories, float[][] data)
+        Assert.HasCount(categories.Count, data);
+        var fileName = Path.GetTempFileName();
+        try
         {
-            Assert.HasCount(categories.Count, data);
-            var fileName = Path.GetTempFileName();
-            try
+            var matrix = new Matrix(categories, categories);
+
+            for (int i = 0; i < data.Length; i++)
             {
-                var matrix = new Matrix(categories, categories);
-                
-                for (int i = 0; i < data.Length; i++)
-                {
-                    data[i].AsSpan().CopyTo(matrix.GetRow(i));    
-                }
-                var save = new SaveMatrixAsCSV()
-                {
-                    ThirdNormalized = Helper.CreateParameter(false),
-                    FirstIndexHeader = Helper.CreateParameter("Origin"),
-                    SecondIndexHeader = Helper.CreateParameter("Destination")
-                };
-                using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
-                {
-                    save.Invoke((matrix, writeStream));
-                }
-                return fileName;
+                data[i].AsSpan().CopyTo(matrix.GetRow(i));
             }
-            catch
+            var save = new SaveMatrixAsCSV()
+            {
+                ThirdNormalized = Helper.CreateParameter(false),
+                FirstIndexHeader = Helper.CreateParameter("Origin"),
+                SecondIndexHeader = Helper.CreateParameter("Destination")
+            };
+            using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
             {
-                File.Delete(fileName);
-                Assert.Fail("Unable to write matrix CSV file");
-                return null;
+                save.Invoke((matrix, writeStream));
             }
+            return fileName;
         }
+        catch
+        {
+            File.Delete(fileName);
+            Assert.Fail("Unable to write matrix CSV file");
+            return null;
+        }
+    }
 
-        internal static string WriteMatrixToCSVThirdNormalized(Categories categories, float[][] data)
+    internal static string WriteMatrixToCSVThirdNormalized(Categories categories, float[][] data)
+    {
+        Assert.HasCount(categories.Count, data);
+        var fileName = Path.GetTempFileName();
+        try
         {
-            Assert.HasCount(categories.Count, data);
-            var fileName = Path.GetTempFileName();
-            try
+            var matrix = new Matrix(categories, categories);
+            for (int i = 0; i < data.Length; i++)
             {
-                var matrix = new Matrix(categories, categories);
-                for (int i = 0; i < data.Length; i++)
-                {
-                    data[i].AsSpan().CopyTo(matrix.GetRow(i));
-                }
-                var save = new SaveMatrixAsCSV()
-                {
-                    ThirdNormalized = Helper.CreateParameter(true),
-                    FirstIndexHeader = Helper.CreateParameter("Origin"),
-                    SecondIndexHeader = Helper.CreateParameter("Destination"),
-                    DataIndexHeader = Helper.CreateParameter("Data")
-                };
-                using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
-                {
-                    save.Invoke((matrix, writeStream));
-                }
-                return fileName;
+                data[i].AsSpan().CopyTo(matrix.GetRow(i));
             }
-            catch
+            var save = new SaveMatrixAsCSV()
+            {
+                ThirdNormalized = Helper.CreateParameter(true),
+                FirstIndexHeader = Helper.CreateParameter("Origin"),
+                SecondIndexHeader = Helper.CreateParameter("Destination"),
+                DataIndexHeader = Helper.CreateParameter("Data")
+            };
+            using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
             {
-                File.Delete(fileName);
-                Assert.Fail("Unable to write matrix CSV file");
-                return null;
+                save.Invoke((matrix, writeStream));
             }
+            return fileName;
+        }
+        catch
+        {
+            File.Delete(fileName);
+            Assert.Fail("Unable to write matrix CSV file");
+            return null;
         }
+    }
 
-        internal static bool Compare(Matrix expected, Matrix testCase, 
-            [NotNullWhen(false)] ref string? error)
+    internal static bool Compare(Matrix expected, Matrix testCase,
+        [NotNullWhen(false)] ref string? error)
+    {
+        if (expected.ColumnCategories != testCase.ColumnCategories)
         {
-            if(expected.ColumnCategories != testCase.ColumnCategories)
-            {
-                error = "The column categories are not the same!";
-                return false;
-            }
-            if(expected.RowCategories != testCase.RowCategories)
+            error = "The column categories are not the same!";
+            return false;
+        }
+        if (expected.RowCategories != testCase.RowCategories)
+        {
+            error = "The row categories are not the same!";
+            return false;
+        }
+        // compare the data
+        var expectedData = expected.Data;
+        var testData = testCase.Data;
+        for (int i = 0; i < testData.Length; i++)
+        {
+            if (expectedData[i] != testData[i])
             {
-                error = "The row categories are not the same!";
+                error = $"Found different elements at position {i}: {expectedData[i]} != {testData[i]}!";
                 return false;
             }
-            // compare the data
-            var expectedData = expected.Data;
-            var testData = testCase.Data;
-            for (int i = 0; i < testData.Length; i++)
-            {
-                if(expectedData[i] != testData[i])
-                {
-                    error = $"Found different elements at position {i}: {expectedData[i]} != {testData[i]}!";
-                    return false;
-                }
-            }
-            return true;
         }
+        return true;
+    }
 
-        internal static string WriteMatrixToMTX(Categories categories, float[][] data)
+    internal static string WriteMatrixToMTX(Categories categories, float[][] data)
+    {
+        Assert.HasCount(categories.Count, data);
+        var fileName = Path.GetTempFileName();
+        try
         {
-            Assert.HasCount(categories.Count, data);
-            var fileName = Path.GetTempFileName();
-            try
+            var matrix = new Matrix(categories, categories);
+            for (int i = 0; i < data.Length; i++)
             {
-                var matrix = new Matrix(categories, categories);
-                for (int i = 0; i < data.Length; i++)
-                {
-                    data[i].AsSpan().CopyTo(matrix.GetRow(i));
-                }
-                var save = new SaveMatrixAsMTX();
-                using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
-                {
-                    save.Invoke((matrix, writeStream));
-                }
-                return fileName;
+                data[i].AsSpan().CopyTo(matrix.GetRow(i));
             }
-            catch
+            var save = new SaveMatrixAsMTX();
+            using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
             {
-                File.Delete(fileName);
-                Assert.Fail("Unable to write matrix CSV file");
-                return null;
+                save.Invoke((matrix, writeStream));
             }
+            return fileName;
+        }
+        catch
+        {
+            File.Delete(fileName);
+            Assert.Fail("Unable to write matrix CSV file");
+            return null;
         }
     }
 }
diff --git a/tests/TMG-Framework.Test/Utilities/TestCSVReader.cs b/tests/TMG-Framework.Test/Utilities/TestCSVReader.cs
index 6215c20..cfdd0de 100644
--- a/tests/TMG-Framework.Test/Utilities/TestCSVReader.cs
+++ b/tests/TMG-Framework.Test/Utilities/TestCSVReader.cs
@@ -17,277 +17,270 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using TMG;
-using TMG.Frameworks.Data.Processing.AST;
-using XTMF2;
 using System.IO;
 using TMG.Utilities;
 
-namespace XTMF.Testing.TMG.Data
+namespace XTMF.Testing.TMG.Data;
+
+[TestClass]
+public class TestCSVReader
 {
-    [TestClass]
-    public class TestCSVReader
-    {
-        private readonly string[] TestCSVFileNames = new[] { "CSVTest1.csv", "CSVTest2.csv", "CSVTest3.csv", "CSVTest4.csv", "CSVTest5.csv", "CSVTest6.csv", "CSVTest7.csv", "CSVTest8.csv" };
+    private readonly string[] TestCSVFileNames = new[] { "CSVTest1.csv", "CSVTest2.csv", "CSVTest3.csv", "CSVTest4.csv", "CSVTest5.csv", "CSVTest6.csv", "CSVTest7.csv", "CSVTest8.csv" };
 
-        [TestInitialize]
-        public void CreateTestEnvironment()
+    [TestInitialize]
+    public void CreateTestEnvironment()
+    {
+        if (!IsEnvironmentLoaded())
         {
-            if (!IsEnvironmentLoaded())
+            using (StreamWriter writer = new(TestCSVFileNames[0]))
             {
-                using (StreamWriter writer = new(TestCSVFileNames[0]))
-                {
-                    writer.WriteLine("A,B,C,D,E");
-                    writer.WriteLine("1,2,3,4,5");
-                    writer.WriteLine("3,1,4,5,2");
-                    writer.WriteLine("1.23,4.56,7.89,10.1112,0.1314");
-                }
-                using (StreamWriter writer = new(TestCSVFileNames[1]))
-                {
-                    writer.WriteLine("\"A\",\"B\",\"C\",\"D\",\"E\"");
-                    writer.WriteLine("\"1\",\"2\",3,\"4\",5");
-                    writer.WriteLine("3,1,\"4\",5,2");
-                    writer.WriteLine("1.23,\"4.56\",7.89,10.1112,0.1314");
-                }
-                using (StreamWriter writer = new(TestCSVFileNames[2]))
-                {
-                    writer.WriteLine("A,B,C,D,E");
-                    writer.WriteLine("1,2,3,4,5");
-                    writer.WriteLine("3,1,4,5,2");
-                    writer.WriteLine("1.23,4.56,7.89,10.1112,0.1314");
-                }
-                using (StreamWriter writer = new(TestCSVFileNames[3]))
-                {
-                    writer.WriteLine("A,B,C,D,E");
-                    writer.WriteLine("1,2,3,4,5");
-                    writer.WriteLine("3,1,4,5,2");
-                    writer.Write("1.23,4.56,7.89,10.1112,0.1314");
-                }
-                using (StreamWriter writer = new(TestCSVFileNames[4]))
-                {
-                    writer.WriteLine("A,B,C,D,E");
-                    writer.WriteLine("\"abc\"\"1\",2,3,4,5");
-                }
-
-                // The smae as TestCSVFileNames[4] but forcing the line breaks to be in the Windows format.
-                using (StreamWriter writer = new(TestCSVFileNames[5]))
-                {
-                    writer.Write("A,B,C,D,E\r\n");
-                    writer.Write("\"abc\"\"1\",2,3,4,5\r\n");
-                }
+                writer.WriteLine("A,B,C,D,E");
+                writer.WriteLine("1,2,3,4,5");
+                writer.WriteLine("3,1,4,5,2");
+                writer.WriteLine("1.23,4.56,7.89,10.1112,0.1314");
+            }
+            using (StreamWriter writer = new(TestCSVFileNames[1]))
+            {
+                writer.WriteLine("\"A\",\"B\",\"C\",\"D\",\"E\"");
+                writer.WriteLine("\"1\",\"2\",3,\"4\",5");
+                writer.WriteLine("3,1,\"4\",5,2");
+                writer.WriteLine("1.23,\"4.56\",7.89,10.1112,0.1314");
+            }
+            using (StreamWriter writer = new(TestCSVFileNames[2]))
+            {
+                writer.WriteLine("A,B,C,D,E");
+                writer.WriteLine("1,2,3,4,5");
+                writer.WriteLine("3,1,4,5,2");
+                writer.WriteLine("1.23,4.56,7.89,10.1112,0.1314");
+            }
+            using (StreamWriter writer = new(TestCSVFileNames[3]))
+            {
+                writer.WriteLine("A,B,C,D,E");
+                writer.WriteLine("1,2,3,4,5");
+                writer.WriteLine("3,1,4,5,2");
+                writer.Write("1.23,4.56,7.89,10.1112,0.1314");
+            }
+            using (StreamWriter writer = new(TestCSVFileNames[4]))
+            {
+                writer.WriteLine("A,B,C,D,E");
+                writer.WriteLine("\"abc\"\"1\",2,3,4,5");
+            }
 
-                // The smae as TestCSVFileNames[4] but forcing the line breaks to be in the Linux format.
-                using (StreamWriter writer = new(TestCSVFileNames[6]))
-                {
-                    writer.Write("A,B,C,D,E\n");
-                    writer.Write("\"abc\"\"1\",2,3,4,5\n");
-                }
+            // The smae as TestCSVFileNames[4] but forcing the line breaks to be in the Windows format.
+            using (StreamWriter writer = new(TestCSVFileNames[5]))
+            {
+                writer.Write("A,B,C,D,E\r\n");
+                writer.Write("\"abc\"\"1\",2,3,4,5\r\n");
+            }
 
-                // The smae as TestCSVFileNames[4] but forcing the line breaks to be in the Mac format.
-                using (StreamWriter writer = new(TestCSVFileNames[7]))
-                {
-                    writer.Write("A,B,C,D,E\r");
-                    writer.Write("\"abc\"\"1\",2,3,4,5\r");
-                }
+            // The smae as TestCSVFileNames[4] but forcing the line breaks to be in the Linux format.
+            using (StreamWriter writer = new(TestCSVFileNames[6]))
+            {
+                writer.Write("A,B,C,D,E\n");
+                writer.Write("\"abc\"\"1\",2,3,4,5\n");
             }
-        }
 
-        public bool IsEnvironmentLoaded()
-        {
-            for (int i = 0; i < TestCSVFileNames.Length; i++)
+            // The smae as TestCSVFileNames[4] but forcing the line breaks to be in the Mac format.
+            using (StreamWriter writer = new(TestCSVFileNames[7]))
             {
-                if (!File.Exists(TestCSVFileNames[i])) return false;
+                writer.Write("A,B,C,D,E\r");
+                writer.Write("\"abc\"\"1\",2,3,4,5\r");
             }
-            return true;
         }
+    }
 
-        [TestMethod]
-        public void TestCSVHeaders()
+    public bool IsEnvironmentLoaded()
+    {
+        for (int i = 0; i < TestCSVFileNames.Length; i++)
         {
-            using CsvReader reader = new(TestCSVFileNames[0]);
-            //"A,B,C,D,E"
-            var headers = reader.Headers;
-            for (int i = 0; i < 5; i++)
-            {
-                Assert.AreEqual(new String((char)('A' + i), 1), headers[i]);
-            }
+            if (!File.Exists(TestCSVFileNames[i])) return false;
         }
+        return true;
+    }
 
-        [TestMethod]
-        public void TestQuotes()
+    [TestMethod]
+    public void TestCSVHeaders()
+    {
+        using CsvReader reader = new(TestCSVFileNames[0]);
+        //"A,B,C,D,E"
+        var headers = reader.Headers;
+        for (int i = 0; i < 5; i++)
         {
-            using CsvReader reader = new(TestCSVFileNames[1]);
-            //"A,B,C,D,E"
-            var headers = reader.Headers;
-            for (int i = 0; i < 5; i++)
-            {
-                Assert.AreEqual(new String((char)('A' + i), 1), headers[i]);
-            }
-            //"\"1\",\"2\",3,\"4\",5"
-            reader.LoadLine();
-            for (int i = 0; i < 5; i++)
-            {
-                reader.Get(out int n, i);
-                Assert.AreEqual(i + 1, n);
-            }
+            Assert.AreEqual(new String((char)('A' + i), 1), headers[i]);
         }
+    }
 
-        [TestMethod]
-        public void TestDoubleQuotes()
+    [TestMethod]
+    public void TestQuotes()
+    {
+        using CsvReader reader = new(TestCSVFileNames[1]);
+        //"A,B,C,D,E"
+        var headers = reader.Headers;
+        for (int i = 0; i < 5; i++)
         {
-            using CsvReader reader = new(TestCSVFileNames[4]);
-            // first line
-            reader.LoadLine();
-            //"A,B,C,D,E"
-            var headers = reader.Headers;
-            for (int i = 0; i < 5; i++)
-            {
-                Assert.AreEqual(new String((char)('A' + i), 1), headers[i]);
-            }
-            //writer.WriteLine("\"abc\"\"1\",2,3,4,5");
-            reader.LoadLine();
-            reader.Get(out string firstItem, 0);
-            Assert.AreEqual("abc\"1", firstItem);
+            Assert.AreEqual(new String((char)('A' + i), 1), headers[i]);
         }
+        //"\"1\",\"2\",3,\"4\",5"
+        reader.LoadLine();
+        for (int i = 0; i < 5; i++)
+        {
+            reader.Get(out int n, i);
+            Assert.AreEqual(i + 1, n);
+        }
+    }
 
-        [TestMethod]
-        public void TestLoadLineBool()
+    [TestMethod]
+    public void TestDoubleQuotes()
+    {
+        using CsvReader reader = new(TestCSVFileNames[4]);
+        // first line
+        reader.LoadLine();
+        //"A,B,C,D,E"
+        var headers = reader.Headers;
+        for (int i = 0; i < 5; i++)
         {
-            using CsvReader reader = new(TestCSVFileNames[1]);
-            Assert.AreEqual(1, reader.LineNumber);
-            while (reader.LoadLine(out int columns))
-            {
-                if ((columns == 0) && (reader.LineNumber != 5))
-                {
-                    Assert.Fail("There was a blank line besides at the end of the file!");
-                }
-                else if (columns > 0)
-                {
-                    Assert.AreEqual(5, columns);
-                }
-            }
-            Assert.AreEqual(5, reader.LineNumber);
+            Assert.AreEqual(new String((char)('A' + i), 1), headers[i]);
         }
+        //writer.WriteLine("\"abc\"\"1\",2,3,4,5");
+        reader.LoadLine();
+        reader.Get(out string firstItem, 0);
+        Assert.AreEqual("abc\"1", firstItem);
+    }
 
-        [TestMethod]
-        public void TestNoEnterLastLine()
+    [TestMethod]
+    public void TestLoadLineBool()
+    {
+        using CsvReader reader = new(TestCSVFileNames[1]);
+        Assert.AreEqual(1, reader.LineNumber);
+        while (reader.LoadLine(out int columns))
         {
-            using CsvReader reader = new(TestCSVFileNames[3]);
-            Assert.AreEqual(1, reader.LineNumber);
-            while (reader.LoadLine(out int columns))
+            if ((columns == 0) && (reader.LineNumber != 5))
+            {
+                Assert.Fail("There was a blank line besides at the end of the file!");
+            }
+            else if (columns > 0)
             {
-                if ((columns == 0) && (reader.LineNumber != 4))
-                {
-                    Assert.Fail("There was a blank line besides at the end of the file!");
-                }
-                else if (columns > 0)
-                {
-                    Assert.AreEqual(5, columns);
-                }
+                Assert.AreEqual(5, columns);
             }
-            Assert.AreEqual(4, reader.LineNumber);
         }
+        Assert.AreEqual(5, reader.LineNumber);
+    }
 
-        [TestMethod]
-        public void TestLineReadValue()
+    [TestMethod]
+    public void TestNoEnterLastLine()
+    {
+        using CsvReader reader = new(TestCSVFileNames[3]);
+        Assert.AreEqual(1, reader.LineNumber);
+        while (reader.LoadLine(out int columns))
         {
-            using CsvReader reader = new(TestCSVFileNames[2]);
-            float lastColumnValue = float.NaN;
-            while (reader.LoadLine(out int columns))
+            if ((columns == 0) && (reader.LineNumber != 4))
+            {
+                Assert.Fail("There was a blank line besides at the end of the file!");
+            }
+            else if (columns > 0)
             {
-                if (columns > 0)
-                {
-                    reader.Get(out lastColumnValue, 4);
-                }
+                Assert.AreEqual(5, columns);
             }
-            Assert.AreEqual(0.1314f, lastColumnValue);
         }
+        Assert.AreEqual(4, reader.LineNumber);
+    }
 
-        [TestMethod]
-        public void TestNoEnterLastLineReadValue()
+    [TestMethod]
+    public void TestLineReadValue()
+    {
+        using CsvReader reader = new(TestCSVFileNames[2]);
+        float lastColumnValue = float.NaN;
+        while (reader.LoadLine(out int columns))
         {
-            using CsvReader reader = new(TestCSVFileNames[3]);
-            float lastColumnValue = float.NaN;
-            while (reader.LoadLine(out int columns))
+            if (columns > 0)
             {
-                if ((columns == 0) && (reader.LineNumber != 4))
-                {
-                    Assert.Fail("There was a blank line besides at the end of the file!");
-                }
-                else if (columns > 0)
-                {
-                    Assert.AreEqual(5, columns);
-                }
                 reader.Get(out lastColumnValue, 4);
             }
-            Assert.AreEqual(4, reader.LineNumber);
-            Assert.AreEqual(0.1314f, lastColumnValue);
         }
+        Assert.AreEqual(0.1314f, lastColumnValue);
+    }
 
-        [TestMethod]
-        public void TestReadingSpan()
+    [TestMethod]
+    public void TestNoEnterLastLineReadValue()
+    {
+        using CsvReader reader = new(TestCSVFileNames[3]);
+        float lastColumnValue = float.NaN;
+        while (reader.LoadLine(out int columns))
         {
-            using CsvReader reader = new(TestCSVFileNames[4]);
-            //"\"abc\"\"1\",2,3,4,5"
-            Assert.AreEqual(5, reader.Headers.Length);
-            reader.LoadLine(out int columns);
-            Assert.AreEqual(5, columns);
-            reader.Get(out ReadOnlySpan<char> span, 0);
-            Assert.AreEqual("abc\"1", new string(span));
+            if ((columns == 0) && (reader.LineNumber != 4))
+            {
+                Assert.Fail("There was a blank line besides at the end of the file!");
+            }
+            else if (columns > 0)
+            {
+                Assert.AreEqual(5, columns);
+            }
+            reader.Get(out lastColumnValue, 4);
         }
+        Assert.AreEqual(4, reader.LineNumber);
+        Assert.AreEqual(0.1314f, lastColumnValue);
+    }
 
-[TestMethod]
-        public void TestReadingUnixLineEndings()
-        {
-            using CsvReader reader = new(TestCSVFileNames[6]);
-            //"\"abc\"\"1\",2,3,4,5"
-            Assert.AreEqual(5, reader.Headers.Length);
-            reader.LoadLine(out int columns);
-            Assert.AreEqual(5, columns);
-            reader.Get(out ReadOnlySpan<char> span, 0);
-            Assert.AreEqual("abc\"1", new string(span));
-            Assert.IsFalse(reader.LoadLine(out columns), $"There is an extra line at the end of the file with {columns} columns.");
-        }
-        [TestMethod]
-        public void TestReadingWindowsLineEndings()
-        {
-            using CsvReader reader = new(TestCSVFileNames[5]);
-            //"\"abc\"\"1\",2,3,4,5"
-            Assert.AreEqual(5, reader.Headers.Length);
-            reader.LoadLine(out int columns);
-            Assert.AreEqual(5, columns);
-            reader.Get(out ReadOnlySpan<char> span, 0);
-            Assert.AreEqual("abc\"1", new string(span));
-            Assert.IsFalse(reader.LoadLine(out columns), $"There is an extra line at the end of the file with {columns} columns.");
-        }
+    [TestMethod]
+    public void TestReadingSpan()
+    {
+        using CsvReader reader = new(TestCSVFileNames[4]);
+        //"\"abc\"\"1\",2,3,4,5"
+        Assert.AreEqual(5, reader.Headers.Length);
+        reader.LoadLine(out int columns);
+        Assert.AreEqual(5, columns);
+        reader.Get(out ReadOnlySpan<char> span, 0);
+        Assert.AreEqual("abc\"1", new string(span));
+    }
 
-        [TestMethod]
-        public void TestReadingLinuxLineEndings()
-        {
-            using CsvReader reader = new(TestCSVFileNames[6]);
-            //"\"abc\"\"1\",2,3,4,5"
-            Assert.AreEqual(5, reader.Headers.Length);
-            reader.LoadLine(out int columns);
-            Assert.AreEqual(5, columns);
-            reader.Get(out ReadOnlySpan<char> span, 0);
-            Assert.AreEqual("abc\"1", new string(span));
-            Assert.IsFalse(reader.LoadLine(out columns), $"There is an extra line at the end of the file with {columns} columns.");
-        }
+    [TestMethod]
+    public void TestReadingUnixLineEndings()
+    {
+        using CsvReader reader = new(TestCSVFileNames[6]);
+        //"\"abc\"\"1\",2,3,4,5"
+        Assert.AreEqual(5, reader.Headers.Length);
+        reader.LoadLine(out int columns);
+        Assert.AreEqual(5, columns);
+        reader.Get(out ReadOnlySpan<char> span, 0);
+        Assert.AreEqual("abc\"1", new string(span));
+        Assert.IsFalse(reader.LoadLine(out columns), $"There is an extra line at the end of the file with {columns} columns.");
+    }
+    [TestMethod]
+    public void TestReadingWindowsLineEndings()
+    {
+        using CsvReader reader = new(TestCSVFileNames[5]);
+        //"\"abc\"\"1\",2,3,4,5"
+        Assert.AreEqual(5, reader.Headers.Length);
+        reader.LoadLine(out int columns);
+        Assert.AreEqual(5, columns);
+        reader.Get(out ReadOnlySpan<char> span, 0);
+        Assert.AreEqual("abc\"1", new string(span));
+        Assert.IsFalse(reader.LoadLine(out columns), $"There is an extra line at the end of the file with {columns} columns.");
+    }
 
-        [TestMethod]
-        public void TestReadingMacLineEndings()
-        {
-            using CsvReader reader = new(TestCSVFileNames[7]);
-            //"\"abc\"\"1\",2,3,4,5"
-            Assert.AreEqual(5, reader.Headers.Length);
-            reader.LoadLine(out int columns);
-            Assert.AreEqual(5, columns);
-            reader.Get(out ReadOnlySpan<char> span, 0);
-            Assert.AreEqual("abc\"1", new string(span));
-            Assert.IsFalse(reader.LoadLine(out columns), $"There is an extra line at the end of the file with {columns} columns.");
-        }
+    [TestMethod]
+    public void TestReadingLinuxLineEndings()
+    {
+        using CsvReader reader = new(TestCSVFileNames[6]);
+        //"\"abc\"\"1\",2,3,4,5"
+        Assert.AreEqual(5, reader.Headers.Length);
+        reader.LoadLine(out int columns);
+        Assert.AreEqual(5, columns);
+        reader.Get(out ReadOnlySpan<char> span, 0);
+        Assert.AreEqual("abc\"1", new string(span));
+        Assert.IsFalse(reader.LoadLine(out columns), $"There is an extra line at the end of the file with {columns} columns.");
+    }
+
+    [TestMethod]
+    public void TestReadingMacLineEndings()
+    {
+        using CsvReader reader = new(TestCSVFileNames[7]);
+        //"\"abc\"\"1\",2,3,4,5"
+        Assert.AreEqual(5, reader.Headers.Length);
+        reader.LoadLine(out int columns);
+        Assert.AreEqual(5, columns);
+        reader.Get(out ReadOnlySpan<char> span, 0);
+        Assert.AreEqual("abc\"1", new string(span));
+        Assert.IsFalse(reader.LoadLine(out columns), $"There is an extra line at the end of the file with {columns} columns.");
     }
 }
diff --git a/tests/TMG-Framework.Test/Utilities/TestCompiler.cs b/tests/TMG-Framework.Test/Utilities/TestCompiler.cs
index a2ac0cb..f05c5ca 100644
--- a/tests/TMG-Framework.Test/Utilities/TestCompiler.cs
+++ b/tests/TMG-Framework.Test/Utilities/TestCompiler.cs
@@ -17,1384 +17,1380 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
 using TMG;
 using TMG.Frameworks.Data.Processing.AST;
 using XTMF2;
 
-namespace XTMF.Testing.TMG.Data
+namespace XTMF.Testing.TMG.Data;
+
+[TestClass]
+public class TestCompiler
 {
-    [TestClass]
-    public class TestCompiler
-    {
-        readonly Categories matrixCategories;
-        readonly Categories vectorCategories;
-
-        public TestCompiler()
-        {
-            string? error = null;
-            if (!Categories.CreateCategories(new List<int>() { 1, 2 }, out var tempMatrixCategories, ref error))
-            {
-                Assert.Fail(error);
-            }
-            if (!Categories.CreateCategories(new List<int>() { 1, 2, 3, 4 }, out var tempVectorCategories, ref error))
-            {
-                Assert.Fail(error);
-            }
-            matrixCategories = tempMatrixCategories;
-            vectorCategories = tempVectorCategories;
+    readonly Categories matrixCategories;
+    readonly Categories vectorCategories;
+
+    public TestCompiler()
+    {
+        string? error = null;
+        if (!Categories.CreateCategories(new List<int>() { 1, 2 }, out var tempMatrixCategories, ref error))
+        {
+            Assert.Fail(error);
         }
-        /// <summary>
-        /// Create a new simple matrix for testing.
-        /// </summary>
-        /// <param name="name"></param>
-        /// <param name="m11"></param>
-        /// <param name="m12"></param>
-        /// <param name="m21"></param>
-        /// <param name="m22"></param>
-        /// <returns></returns>
-        private IFunction<Matrix> CreateMatrixData(string name, float m11, float m12, float m21, float m22)
-        {
-            var matrix = new Matrix(matrixCategories, matrixCategories);
-            matrix.Data[0] = m11;
-            matrix.Data[1] = m12;
-            matrix.Data[2] = m21;
-            matrix.Data[3] = m22;
-            return new MatrixSource(matrix) { Name = name };
+        if (!Categories.CreateCategories(new List<int>() { 1, 2, 3, 4 }, out var tempVectorCategories, ref error))
+        {
+            Assert.Fail(error);
         }
+        matrixCategories = tempMatrixCategories;
+        vectorCategories = tempVectorCategories;
+    }
+    /// <summary>
+    /// Create a new simple matrix for testing.
+    /// </summary>
+    /// <param name="name"></param>
+    /// <param name="m11"></param>
+    /// <param name="m12"></param>
+    /// <param name="m21"></param>
+    /// <param name="m22"></param>
+    /// <returns></returns>
+    private IFunction<Matrix> CreateMatrixData(string name, float m11, float m12, float m21, float m22)
+    {
+        var matrix = new Matrix(matrixCategories, matrixCategories);
+        matrix.Data[0] = m11;
+        matrix.Data[1] = m12;
+        matrix.Data[2] = m21;
+        matrix.Data[3] = m22;
+        return new MatrixSource(matrix) { Name = name };
+    }
 
-        /// <summary>
-        /// Create a new simple matrix for testing.
-        /// </summary>
-        /// <param name="name"></param>
-        /// <param name="m11"></param>
-        /// <param name="m12"></param>
-        /// <param name="m21"></param>
-        /// <param name="m22"></param>
-        /// <returns></returns>
-        private IFunction<Vector> CreateVectorData(string name, float m1, float m2, float m3, float m4)
-        {
-            var ret = new Vector(vectorCategories);
-            ret.Data[0] = m1;
-            ret.Data[1] = m2;
-            ret.Data[2] = m3;
-            ret.Data[3] = m4;
-            return new VectorSource(ret) { Name = name };
-        }
+    /// <summary>
+    /// Create a new simple matrix for testing.
+    /// </summary>
+    /// <param name="name"></param>
+    /// <param name="m11"></param>
+    /// <param name="m12"></param>
+    /// <param name="m21"></param>
+    /// <param name="m22"></param>
+    /// <returns></returns>
+    private IFunction<Vector> CreateVectorData(string name, float m1, float m2, float m3, float m4)
+    {
+        var ret = new Vector(vectorCategories);
+        ret.Data[0] = m1;
+        ret.Data[1] = m2;
+        ret.Data[2] = m3;
+        ret.Data[3] = m4;
+        return new VectorSource(ret) { Name = name };
+    }
 
-        /// <summary>
-        /// Create a new simple scalar for testing.
-        /// </summary>
-        /// <param name="name"></param>
-        /// <param name="m11"></param>
-        /// <param name="m12"></param>
-        /// <param name="m21"></param>
-        /// <param name="m22"></param>
-        /// <returns></returns>
-        private IFunction<float> CreateScalarData(string name, float m1)
-        {
-            return new ScalarSource(m1) { Name = name };
-        }
+    /// <summary>
+    /// Create a new simple scalar for testing.
+    /// </summary>
+    /// <param name="name"></param>
+    /// <param name="m11"></param>
+    /// <param name="m12"></param>
+    /// <param name="m21"></param>
+    /// <param name="m22"></param>
+    /// <returns></returns>
+    private IFunction<float> CreateScalarData(string name, float m1)
+    {
+        return new ScalarSource(m1) { Name = name };
+    }
 
-        /// <summary>
-        /// Create a new simple vector for testing.
-        /// </summary>
-        /// <param name="name"></param>
-        /// <param name="m1"></param>
-        /// <param name="m2"></param>
-        /// <returns></returns>
-        private IFunction<Vector> CreateData(string name, float m1, float m2)
-        {
-            var vector = new Vector(matrixCategories);
-            vector.Data[0] = m1;
-            vector.Data[1] = m2;
-            return new VectorSource(vector) { Name = name };
-        }
+    /// <summary>
+    /// Create a new simple vector for testing.
+    /// </summary>
+    /// <param name="name"></param>
+    /// <param name="m1"></param>
+    /// <param name="m2"></param>
+    /// <returns></returns>
+    private IFunction<Vector> CreateData(string name, float m1, float m2)
+    {
+        var vector = new Vector(matrixCategories);
+        vector.Data[0] = m1;
+        vector.Data[1] = m2;
+        return new VectorSource(vector) { Name = name };
+    }
 
-        [TestMethod]
-        public void TestMatrixAdd()
+    [TestMethod]
+    public void TestMatrixAdd()
+    {
+        CompareMatrix("A + B", new IModule[]
         {
-            CompareMatrix("A + B", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 3.0f, 6.0f, 9.0f, 12.0f);
-        }
+        }, 3.0f, 6.0f, 9.0f, 12.0f);
+    }
 
-        [TestMethod]
-        public void TestAddLHSVectorRHSMatrixHorizontal()
+    [TestMethod]
+    public void TestAddLHSVectorRHSMatrixHorizontal()
+    {
+        CompareMatrix("AsHorizontal(A) + B", new IModule[]
         {
-            CompareMatrix("AsHorizontal(A) + B", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 3.0f, 6.0f, 7.0f, 10.0f);
-        }
+        }, 3.0f, 6.0f, 7.0f, 10.0f);
+    }
 
-        [TestMethod]
-        public void TestAddLHSVectorRHSMatrixVertical()
+    [TestMethod]
+    public void TestAddLHSVectorRHSMatrixVertical()
+    {
+        CompareMatrix("AsVertical(A) + B", new IModule[]
         {
-            CompareMatrix("AsVertical(A) + B", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 3.0f, 5.0f, 8.0f, 10.0f);
-        }
+        }, 3.0f, 5.0f, 8.0f, 10.0f);
+    }
 
-        [TestMethod]
-        public void TestAddLHSMatrixRHSVectorHorizontal()
+    [TestMethod]
+    public void TestAddLHSMatrixRHSVectorHorizontal()
+    {
+        CompareMatrix("B + AsHorizontal(A)", new IModule[]
         {
-            CompareMatrix("B + AsHorizontal(A)", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 3.0f, 6.0f, 7.0f, 10.0f);
-        }
+        }, 3.0f, 6.0f, 7.0f, 10.0f);
+    }
 
-        [TestMethod]
-        public void TestAddLHSMatrixRHSVectorVertical()
+    [TestMethod]
+    public void TestAddLHSMatrixRHSVectorVertical()
+    {
+        CompareMatrix("B + AsVertical(A)", new IModule[]
         {
-            CompareMatrix("B + AsVertical(A)", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 3.0f, 5.0f, 8.0f, 10.0f);
-        }
+        }, 3.0f, 5.0f, 8.0f, 10.0f);
+    }
 
-        [TestMethod]
-        public void TestMultiplyLHSVectorRHSMatrixHorizontal()
+    [TestMethod]
+    public void TestMultiplyLHSVectorRHSMatrixHorizontal()
+    {
+        CompareMatrix("AsHorizontal(A) * B", new IModule[]
         {
-            CompareMatrix("AsHorizontal(A) * B", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 2.0f, 8.0f, 6.0f, 16.0f);
-        }
+        }, 2.0f, 8.0f, 6.0f, 16.0f);
+    }
 
-        [TestMethod]
-        public void TestMultiplyLHSVectorRHSMatrixVertical()
+    [TestMethod]
+    public void TestMultiplyLHSVectorRHSMatrixVertical()
+    {
+        CompareMatrix("AsVertical(A) * B", new IModule[]
         {
-            CompareMatrix("AsVertical(A) * B", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 2.0f, 4.0f, 12.0f, 16.0f);
-        }
+        }, 2.0f, 4.0f, 12.0f, 16.0f);
+    }
 
-        [TestMethod]
-        public void TestMultiplyLHSMatrixRHSVectorHorizontal()
+    [TestMethod]
+    public void TestMultiplyLHSMatrixRHSVectorHorizontal()
+    {
+        CompareMatrix("B * AsHorizontal(A)", new IModule[]
         {
-            CompareMatrix("B * AsHorizontal(A)", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 2.0f, 8.0f, 6.0f, 16.0f);
-        }
+        }, 2.0f, 8.0f, 6.0f, 16.0f);
+    }
 
-        [TestMethod]
-        public void TestMultiplyLHSMatrixRHSVectorVertical()
+    [TestMethod]
+    public void TestMultiplyLHSMatrixRHSVectorVertical()
+    {
+        CompareMatrix("B * AsVertical(A)", new IModule[]
         {
-            CompareMatrix("B * AsVertical(A)", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 2.0f, 4.0f, 12.0f, 16.0f);
-        }
+        }, 2.0f, 4.0f, 12.0f, 16.0f);
+    }
 
-        [TestMethod]
-        public void TestDivideLHSVectorRHSMatrixHorizontal()
+    [TestMethod]
+    public void TestDivideLHSVectorRHSMatrixHorizontal()
+    {
+        CompareMatrix("AsHorizontal(A) / B", new IModule[]
         {
-            CompareMatrix("AsHorizontal(A) / B", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 0.5f, 0.5f, 1.0f / 6.0f, 0.25f);
-        }
+        }, 0.5f, 0.5f, 1.0f / 6.0f, 0.25f);
+    }
 
-        [TestMethod]
-        public void TestDivideLHSVectorRHSMatrixVertical()
+    [TestMethod]
+    public void TestDivideLHSVectorRHSMatrixVertical()
+    {
+        CompareMatrix("AsVertical(A) / B", new IModule[]
         {
-            CompareMatrix("AsVertical(A) / B", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 0.5f, 0.25f, 2.0f / 6.0f, 0.25f);
-        }
+        }, 0.5f, 0.25f, 2.0f / 6.0f, 0.25f);
+    }
 
-        [TestMethod]
-        public void TestDivideLHSMatrixRHSVectorHorizontal()
+    [TestMethod]
+    public void TestDivideLHSMatrixRHSVectorHorizontal()
+    {
+        CompareMatrix("B / AsHorizontal(A)", new IModule[]
         {
-            CompareMatrix("B / AsHorizontal(A)", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 2.0f, 2.0f, 6.0f, 4.0f);
-        }
+        }, 2.0f, 2.0f, 6.0f, 4.0f);
+    }
 
-        [TestMethod]
-        public void TestDivideLHSMatrixRHSVectorVertical()
+    [TestMethod]
+    public void TestDivideLHSMatrixRHSVectorVertical()
+    {
+        CompareMatrix("B / AsVertical(A)", new IModule[]
         {
-            CompareMatrix("B / AsVertical(A)", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 2.0f, 4.0f, 3.0f, 4.0f);
-        }
+        }, 2.0f, 4.0f, 3.0f, 4.0f);
+    }
 
-        [TestMethod]
-        public void TestSubtractLHSVectorRHSMatrixHorizontal()
+    [TestMethod]
+    public void TestSubtractLHSVectorRHSMatrixHorizontal()
+    {
+        CompareMatrix("AsHorizontal(A) - B", new IModule[]
         {
-            CompareMatrix("AsHorizontal(A) - B", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, -1.0f, -2.0f, -5.0f, -6.0f);
-        }
+        }, -1.0f, -2.0f, -5.0f, -6.0f);
+    }
 
-        [TestMethod]
-        public void TestSubtractLHSVectorRHSMatrixVertical()
+    [TestMethod]
+    public void TestSubtractLHSVectorRHSMatrixVertical()
+    {
+        CompareMatrix("AsVertical(A) - B", new IModule[]
         {
-            CompareMatrix("AsVertical(A) - B", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, -1.0f, -3.0f, -4.0f, -6.0f);
-        }
+        }, -1.0f, -3.0f, -4.0f, -6.0f);
+    }
 
-        [TestMethod]
-        public void TestSubtractLHSMatrixRHSVectorHorizontal()
+    [TestMethod]
+    public void TestSubtractLHSMatrixRHSVectorHorizontal()
+    {
+        CompareMatrix("B - AsHorizontal(A)", new IModule[]
         {
-            CompareMatrix("B - AsHorizontal(A)", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 1.0f, 2.0f, 5.0f, 6.0f);
-        }
+        }, 1.0f, 2.0f, 5.0f, 6.0f);
+    }
 
-        [TestMethod]
-        public void TestSubtractLHSMatrixRHSVectorVertical()
+    [TestMethod]
+    public void TestSubtractLHSMatrixRHSVectorVertical()
+    {
+        CompareMatrix("B - AsVertical(A)", new IModule[]
         {
-            CompareMatrix("B - AsVertical(A)", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 1.0f, 3.0f, 4.0f, 6.0f);
-        }
+        }, 1.0f, 3.0f, 4.0f, 6.0f);
+    }
 
-        [TestMethod]
-        public void TestAndLHSVectorRHSMatrixHorizontal()
+    [TestMethod]
+    public void TestAndLHSVectorRHSMatrixHorizontal()
+    {
+        CompareMatrix("AsHorizontal(A) == 1 & B == 1", new IModule[]
         {
-            CompareMatrix("AsHorizontal(A) == 1 & B == 1", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 1, 1)
-            }, 1.0f, 0.0f, 1.0f, 0.0f);
-        }
+        }, 1.0f, 0.0f, 1.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestAndLHSVectorRHSMatrixVertical()
+    [TestMethod]
+    public void TestAndLHSVectorRHSMatrixVertical()
+    {
+        CompareMatrix("AsVertical(A) == 1 & B == 1", new IModule[]
         {
-            CompareMatrix("AsVertical(A) == 1 & B == 1", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 1, 1)
-            }, 1.0f, 0.0f, 0.0f, 0.0f);
-        }
+        }, 1.0f, 0.0f, 0.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestAndLHSMatrixRHSVectorHorizontal()
+    [TestMethod]
+    public void TestAndLHSMatrixRHSVectorHorizontal()
+    {
+        CompareMatrix("B == 1 & AsHorizontal(A) == 1", new IModule[]
         {
-            CompareMatrix("B == 1 & AsHorizontal(A) == 1", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 1, 1)
-            }, 1.0f, 0.0f, 1.0f, 0.0f);
-        }
+        }, 1.0f, 0.0f, 1.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestAndLHSMatrixRHSVectorVertical()
+    [TestMethod]
+    public void TestAndLHSMatrixRHSVectorVertical()
+    {
+        CompareMatrix("B == 1 & AsVertical(A) == 1", new IModule[]
         {
-            CompareMatrix("B == 1 & AsVertical(A) == 1", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 1, 1)
-            }, 1.0f, 0.0f, 0.0f, 0.0f);
-        }
+        }, 1.0f, 0.0f, 0.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestOrLHSVectorRHSMatrixHorizontal()
+    [TestMethod]
+    public void TestOrLHSVectorRHSMatrixHorizontal()
+    {
+        CompareMatrix("AsHorizontal(A) == 1 | B == 1", new IModule[]
         {
-            CompareMatrix("AsHorizontal(A) == 1 | B == 1", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 1.0f, 0.0f, 1.0f, 1.0f);
-        }
+        }, 1.0f, 0.0f, 1.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestOrLHSVectorRHSMatrixVertical()
+    [TestMethod]
+    public void TestOrLHSVectorRHSMatrixVertical()
+    {
+        CompareMatrix("AsVertical(A) == 1 | B == 1", new IModule[]
         {
-            CompareMatrix("AsVertical(A) == 1 | B == 1", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 1.0f, 1.0f, 0.0f, 1.0f);
-        }
+        }, 1.0f, 1.0f, 0.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestOrLHSMatrixRHSVectorHorizontal()
+    [TestMethod]
+    public void TestOrLHSMatrixRHSVectorHorizontal()
+    {
+        CompareMatrix("B == 1 | AsHorizontal(A) == 1", new IModule[]
         {
-            CompareMatrix("B == 1 | AsHorizontal(A) == 1", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 1.0f, 0.0f, 1.0f, 1.0f);
-        }
+        }, 1.0f, 0.0f, 1.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestOrLHSMatrixRHSVectorVertical()
+    [TestMethod]
+    public void TestOrLHSMatrixRHSVectorVertical()
+    {
+        CompareMatrix("B == 1 | AsVertical(A) == 1", new IModule[]
         {
-            CompareMatrix("B == 1 | AsVertical(A) == 1", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 1.0f, 1.0f, 0.0f, 1.0f);
-        }
+        }, 1.0f, 1.0f, 0.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestLessThanLHSVectorRHSMatrixHorizontal()
+    [TestMethod]
+    public void TestLessThanLHSVectorRHSMatrixHorizontal()
+    {
+        CompareMatrix("(AsHorizontal(A) == 1) < (B == 1)", new IModule[]
         {
-            CompareMatrix("(AsHorizontal(A) == 1) < (B == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 0.0f, 0.0f, 0.0f, 1.0f);
-        }
+        }, 0.0f, 0.0f, 0.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestLessThanLHSVectorRHSMatrixVertical()
+    [TestMethod]
+    public void TestLessThanLHSVectorRHSMatrixVertical()
+    {
+        CompareMatrix("(AsVertical(A) == 1) < (B == 1)", new IModule[]
         {
-            CompareMatrix("(AsVertical(A) == 1) < (B == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 0.0f, 0.0f, 0.0f, 1.0f);
-        }
+        }, 0.0f, 0.0f, 0.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestLessThanLHSMatrixRHSVectorHorizontal()
+    [TestMethod]
+    public void TestLessThanLHSMatrixRHSVectorHorizontal()
+    {
+        CompareMatrix("(B == 1) < (AsHorizontal(A) == 1)", new IModule[]
         {
-            CompareMatrix("(B == 1) < (AsHorizontal(A) == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 0.0f, 0.0f, 1.0f, 0.0f);
-        }
+        }, 0.0f, 0.0f, 1.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestLessThanLHSMatrixRHSVectorVertical()
+    [TestMethod]
+    public void TestLessThanLHSMatrixRHSVectorVertical()
+    {
+        CompareMatrix("(B == 1) < (AsVertical(A) == 1)", new IModule[]
         {
-            CompareMatrix("(B == 1) < (AsVertical(A) == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 0.0f, 1.0f, 0.0f, 0.0f);
-        }
+        }, 0.0f, 1.0f, 0.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestLessThanOrEqualLHSVectorRHSMatrixHorizontal()
+    [TestMethod]
+    public void TestLessThanOrEqualLHSVectorRHSMatrixHorizontal()
+    {
+        CompareMatrix("(AsHorizontal(A) == 1) <= (B == 1)", new IModule[]
         {
-            CompareMatrix("(AsHorizontal(A) == 1) <= (B == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 1.0f, 1.0f, 0.0f, 1.0f);
-        }
+        }, 1.0f, 1.0f, 0.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestLessThanOrEqualLHSVectorRHSMatrixVertical()
+    [TestMethod]
+    public void TestLessThanOrEqualLHSVectorRHSMatrixVertical()
+    {
+        CompareMatrix("(AsVertical(A) == 1) <= (B == 1)", new IModule[]
         {
-            CompareMatrix("(AsVertical(A) == 1) <= (B == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 1.0f, 0.0f, 1.0f, 1.0f);
-        }
+        }, 1.0f, 0.0f, 1.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestLessThanOrEqualLHSMatrixRHSVectorHorizontal()
+    [TestMethod]
+    public void TestLessThanOrEqualLHSMatrixRHSVectorHorizontal()
+    {
+        CompareMatrix("(B == 1) <= (AsHorizontal(A) == 1)", new IModule[]
         {
-            CompareMatrix("(B == 1) <= (AsHorizontal(A) == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 1.0f, 1.0f, 1.0f, 0.0f);
-        }
+        }, 1.0f, 1.0f, 1.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestLessThanOrEqualLHSMatrixRHSVectorVertical()
+    [TestMethod]
+    public void TestLessThanOrEqualLHSMatrixRHSVectorVertical()
+    {
+        CompareMatrix("(B == 1) <= (AsVertical(A) == 1)", new IModule[]
         {
-            CompareMatrix("(B == 1) <= (AsVertical(A) == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 1.0f, 1.0f, 1.0f, 0.0f);
-        }
+        }, 1.0f, 1.0f, 1.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestEqualLHSVectorRHSMatrixHorizontal()
+    [TestMethod]
+    public void TestEqualLHSVectorRHSMatrixHorizontal()
+    {
+        CompareMatrix("(AsHorizontal(A) == 1) == (B == 1)", new IModule[]
         {
-            CompareMatrix("(AsHorizontal(A) == 1) == (B == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 1.0f, 1.0f, 0.0f, 0.0f);
-        }
+        }, 1.0f, 1.0f, 0.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestEqualLHSVectorRHSMatrixVertical()
+    [TestMethod]
+    public void TestEqualLHSVectorRHSMatrixVertical()
+    {
+        CompareMatrix("(AsVertical(A) == 1) == (B == 1)", new IModule[]
         {
-            CompareMatrix("(AsVertical(A) == 1) == (B == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 1.0f, 0.0f, 1.0f, 0.0f);
-        }
+        }, 1.0f, 0.0f, 1.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestEqualLHSMatrixRHSVectorHorizontal()
+    [TestMethod]
+    public void TestEqualLHSMatrixRHSVectorHorizontal()
+    {
+        CompareMatrix("(B == 1) == (AsHorizontal(A) == 1)", new IModule[]
         {
-            CompareMatrix("(B == 1) == (AsHorizontal(A) == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 1.0f, 1.0f, 0.0f, 0.0f);
-        }
+        }, 1.0f, 1.0f, 0.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestEqualLHSMatrixRHSVectorVertical()
+    [TestMethod]
+    public void TestEqualLHSMatrixRHSVectorVertical()
+    {
+        CompareMatrix("(B == 1) == (AsVertical(A) == 1)", new IModule[]
         {
-            CompareMatrix("(B == 1) == (AsVertical(A) == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 1.0f, 0.0f, 1.0f, 0.0f);
-        }
+        }, 1.0f, 0.0f, 1.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestNotEqualLHSVectorRHSMatrixHorizontal()
+    [TestMethod]
+    public void TestNotEqualLHSVectorRHSMatrixHorizontal()
+    {
+        CompareMatrix("(AsHorizontal(A) == 1) != (B == 1)", new IModule[]
         {
-            CompareMatrix("(AsHorizontal(A) == 1) != (B == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 0.0f, 0.0f, 1.0f, 1.0f);
-        }
+        }, 0.0f, 0.0f, 1.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestNotEqualLHSVectorRHSMatrixVertical()
+    [TestMethod]
+    public void TestNotEqualLHSVectorRHSMatrixVertical()
+    {
+        CompareMatrix("(AsVertical(A) == 1) != (B == 1)", new IModule[]
         {
-            CompareMatrix("(AsVertical(A) == 1) != (B == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 0.0f, 1.0f, 0.0f, 1.0f);
-        }
+        }, 0.0f, 1.0f, 0.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestNotEqualLHSMatrixRHSVectorHorizontal()
+    [TestMethod]
+    public void TestNotEqualLHSMatrixRHSVectorHorizontal()
+    {
+        CompareMatrix("(B == 1) != (AsHorizontal(A) == 1)", new IModule[]
         {
-            CompareMatrix("(B == 1) != (AsHorizontal(A) == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 0.0f, 0.0f, 1.0f, 1.0f);
-        }
+        }, 0.0f, 0.0f, 1.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestNotEqualLHSMatrixRHSVectorVertical()
+    [TestMethod]
+    public void TestNotEqualLHSMatrixRHSVectorVertical()
+    {
+        CompareMatrix("(B == 1) != (AsVertical(A) == 1)", new IModule[]
         {
-            CompareMatrix("(B == 1) != (AsVertical(A) == 1)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 0, 1)
-            }, 0.0f, 1.0f, 0.0f, 1.0f);
-        }
+        }, 0.0f, 1.0f, 0.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestPowLHSVectorRHSMatrixHorizontal()
+    [TestMethod]
+    public void TestPowLHSVectorRHSMatrixHorizontal()
+    {
+        CompareMatrix("AsHorizontal(A) ^ B", new IModule[]
         {
-            CompareMatrix("AsHorizontal(A) ^ B", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 1.0f, 16.0f, 1.0f, 256.0f);
-        }
+        }, 1.0f, 16.0f, 1.0f, 256.0f);
+    }
 
-        [TestMethod]
-        public void TestPowLHSVectorRHSMatrixVertical()
+    [TestMethod]
+    public void TestPowLHSVectorRHSMatrixVertical()
+    {
+        CompareMatrix("AsVertical(A) ^ B", new IModule[]
         {
-            CompareMatrix("AsVertical(A) ^ B", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 1.0f, 1.0f, 64.0f, 256.0f);
-        }
+        }, 1.0f, 1.0f, 64.0f, 256.0f);
+    }
 
-        [TestMethod]
-        public void TestPowLHSMatrixRHSVectorHorizontal()
+    [TestMethod]
+    public void TestPowLHSMatrixRHSVectorHorizontal()
+    {
+        CompareMatrix("B ^ AsHorizontal(A)", new IModule[]
         {
-            CompareMatrix("B ^ AsHorizontal(A)", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 2.0f, 16.0f, 6.0f, 64.0f);
-        }
+        }, 2.0f, 16.0f, 6.0f, 64.0f);
+    }
 
-        [TestMethod]
-        public void TestPowLHSMatrixRHSVectorVertical()
+    [TestMethod]
+    public void TestPowLHSMatrixRHSVectorVertical()
+    {
+        CompareMatrix("B ^ AsVertical(A)", new IModule[]
         {
-            CompareMatrix("B ^ AsVertical(A)", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 2.0f, 4.0f, 36.0f, 64.0f);
-        }
+        }, 2.0f, 4.0f, 36.0f, 64.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixSubtract()
+    [TestMethod]
+    public void TestMatrixSubtract()
+    {
+        CompareMatrix("A - B", new IModule[]
         {
-            CompareMatrix("A - B", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, -1.0f, -2.0f, -3.0f, -4.0f);
-        }
-        [TestMethod]
-        public void TestMatrixVectorSubtract()
+        }, -1.0f, -2.0f, -3.0f, -4.0f);
+    }
+    [TestMethod]
+    public void TestMatrixVectorSubtract()
+    {
+        CompareMatrix("A - SumColumns(B)", new IModule[]
         {
-            CompareMatrix("A - SumColumns(B)", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, -7.0f, -10.0f, -5.0f, -8.0f);
-        }
+        }, -7.0f, -10.0f, -5.0f, -8.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixVectorSubtract2()
+    [TestMethod]
+    public void TestMatrixVectorSubtract2()
+    {
+        CompareMatrix("A - SumRows(B)", new IModule[]
         {
-            CompareMatrix("A - SumRows(B)", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, -5.0f, -4.0f, -11.0f, -10.0f);
-        }
+        }, -5.0f, -4.0f, -11.0f, -10.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixAddWithBrackets()
+    [TestMethod]
+    public void TestMatrixAddWithBrackets()
+    {
+        CompareMatrix("(A) + (B)", new IModule[]
         {
-            CompareMatrix("(A) + (B)", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 3.0f, 6.0f, 9.0f, 12.0f);
-        }
+        }, 3.0f, 6.0f, 9.0f, 12.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixAddWithDoubleBrackets()
+    [TestMethod]
+    public void TestMatrixAddWithDoubleBrackets()
+    {
+        CompareMatrix("((A)) + ((B))", new IModule[]
         {
-            CompareMatrix("((A)) + ((B))", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 3.0f, 6.0f, 9.0f, 12.0f);
-        }
+        }, 3.0f, 6.0f, 9.0f, 12.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixAddWithTripleBrackets()
+    [TestMethod]
+    public void TestMatrixAddWithTripleBrackets()
+    {
+        CompareMatrix("(((A)) + ((B)))", new IModule[]
         {
-            CompareMatrix("(((A)) + ((B)))", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 3.0f, 6.0f, 9.0f, 12.0f);
-        }
+        }, 3.0f, 6.0f, 9.0f, 12.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixSumRows()
+    [TestMethod]
+    public void TestMatrixSumRows()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("SumRows(A + B)", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("SumRows(A + B)", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            });
-            Assert.IsTrue(result.IsVectorResult);
-            Assert.AreEqual(ComputationResult.VectorDirection.Vertical, result.Direction);
-            var flat = result.VectorData.Data;
-            Assert.AreEqual(9.0f, flat[0], 0.00001f);
-            Assert.AreEqual(21.0f, flat[1], 0.00001f);
-        }
+        });
+        Assert.IsTrue(result.IsVectorResult);
+        Assert.AreEqual(ComputationResult.VectorDirection.Vertical, result.Direction);
+        var flat = result.VectorData.Data;
+        Assert.AreEqual(9.0f, flat[0], 0.00001f);
+        Assert.AreEqual(21.0f, flat[1], 0.00001f);
+    }
 
-        [TestMethod]
-        public void TestMatrixSumColumns()
+    [TestMethod]
+    public void TestMatrixSumColumns()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("SumColumns(A + B)", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("SumColumns(A + B)", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            });
-            Assert.IsTrue(result.IsVectorResult);
-            Assert.AreEqual(ComputationResult.VectorDirection.Horizontal, result.Direction);
-            var flat = result.VectorData.Data;
-            Assert.AreEqual(12.0f, flat[0], 0.00001f);
-            Assert.AreEqual(18.0f, flat[1], 0.00001f);
-        }
+        });
+        Assert.IsTrue(result.IsVectorResult);
+        Assert.AreEqual(ComputationResult.VectorDirection.Horizontal, result.Direction);
+        var flat = result.VectorData.Data;
+        Assert.AreEqual(12.0f, flat[0], 0.00001f);
+        Assert.AreEqual(18.0f, flat[1], 0.00001f);
+    }
 
-        [TestMethod]
-        public void TestMatrixAsHorizontal()
+    [TestMethod]
+    public void TestMatrixAsHorizontal()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("AsHorizontal(SumRows(A + B))", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("AsHorizontal(SumRows(A + B))", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            });
-            Assert.IsTrue(result.IsVectorResult);
-            Assert.AreEqual(ComputationResult.VectorDirection.Horizontal, result.Direction);
-            var flat = result.VectorData.Data;
-            Assert.AreEqual(9.0f, flat[0], 0.00001f);
-            Assert.AreEqual(21.0f, flat[1], 0.00001f);
-        }
+        });
+        Assert.IsTrue(result.IsVectorResult);
+        Assert.AreEqual(ComputationResult.VectorDirection.Horizontal, result.Direction);
+        var flat = result.VectorData.Data;
+        Assert.AreEqual(9.0f, flat[0], 0.00001f);
+        Assert.AreEqual(21.0f, flat[1], 0.00001f);
+    }
 
-        [TestMethod]
-        public void TestMatrixSum()
+    [TestMethod]
+    public void TestMatrixSum()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("Sum(A + B)", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("Sum(A + B)", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            });
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual(30.0f, result.LiteralValue, 0.00001f);
-        }
+        });
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual(30.0f, result.LiteralValue, 0.00001f);
+    }
 
-        [TestMethod]
-        public void TestVectorSum()
+    [TestMethod]
+    public void TestVectorSum()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("Sum(SumRows(A + B))", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("Sum(SumRows(A + B))", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            });
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual(30.0f, result.LiteralValue, 0.00001f);
-        }
+        });
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual(30.0f, result.LiteralValue, 0.00001f);
+    }
 
-        [TestMethod]
-        public void TestMatrixTranspose()
+    [TestMethod]
+    public void TestMatrixTranspose()
+    {
+        CompareMatrix("Transpose(A + B)", new IModule[]
         {
-            CompareMatrix("Transpose(A + B)", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 3.0f, 9.0f, 6.0f, 12.0f);
-        }
+        }, 3.0f, 9.0f, 6.0f, 12.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixAbs()
+    [TestMethod]
+    public void TestMatrixAbs()
+    {
+        CompareMatrix("Abs(A - B)", new IModule[]
         {
-            CompareMatrix("Abs(A - B)", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 1.0f, 2.0f, 3.0f, 4.0f);
-        }
+        }, 1.0f, 2.0f, 3.0f, 4.0f);
+    }
 
-        [TestMethod]
-        public void TestVectorAbs()
+    [TestMethod]
+    public void TestVectorAbs()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("Abs(SumRows(A) - SumRows(B))", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("Abs(SumRows(A) - SumRows(B))", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            });
-            Assert.IsTrue(result.IsVectorResult);
-            var flat = result.VectorData.Data;
-            Assert.AreEqual(3.0f, flat[0], 0.00001f);
-            Assert.AreEqual(7.0f, flat[1], 0.00001f);
-        }
+        });
+        Assert.IsTrue(result.IsVectorResult);
+        var flat = result.VectorData.Data;
+        Assert.AreEqual(3.0f, flat[0], 0.00001f);
+        Assert.AreEqual(7.0f, flat[1], 0.00001f);
+    }
 
-        [TestMethod]
-        public void TestScalarAbs()
+    [TestMethod]
+    public void TestScalarAbs()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("Abs(Sum(A) - Sum(B))", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("Abs(Sum(A) - Sum(B))", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            });
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual(10.0f, result.LiteralValue, 0.00001f);
-        }
+        });
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual(10.0f, result.LiteralValue, 0.00001f);
+    }
 
-        [TestMethod]
-        public void TestMatrixAvg()
+    [TestMethod]
+    public void TestMatrixAvg()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("Avg(A - B)", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("Avg(A - B)", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            });
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual(-2.5f, result.LiteralValue, 0.00001f);
-        }
+        });
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual(-2.5f, result.LiteralValue, 0.00001f);
+    }
 
-        [TestMethod]
-        public void TestVectorAvg()
+    [TestMethod]
+    public void TestVectorAvg()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("Avg(SumRows(A) - SumRows(B))", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("Avg(SumRows(A) - SumRows(B))", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            });
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual(-5.0f, result.LiteralValue, 0.00001f);
-        }
+        });
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual(-5.0f, result.LiteralValue, 0.00001f);
+    }
 
-        [TestMethod]
-        public void TestMatrixAvgRows()
+    [TestMethod]
+    public void TestMatrixAvgRows()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("AvgRows(A)", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("AvgRows(A)", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            });
-            Assert.IsTrue(result.IsVectorResult);
-            Assert.AreEqual(ComputationResult.VectorDirection.Vertical, result.Direction);
-            var flat = result.VectorData.Data;
-            Assert.AreEqual(1.5f, flat[0], 0.00001f);
-            Assert.AreEqual(3.5f, flat[1], 0.00001f);
-        }
+        });
+        Assert.IsTrue(result.IsVectorResult);
+        Assert.AreEqual(ComputationResult.VectorDirection.Vertical, result.Direction);
+        var flat = result.VectorData.Data;
+        Assert.AreEqual(1.5f, flat[0], 0.00001f);
+        Assert.AreEqual(3.5f, flat[1], 0.00001f);
+    }
 
-        [TestMethod]
-        public void TestMatrixAvgColumns()
+    [TestMethod]
+    public void TestMatrixAvgColumns()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("AvgColumns(A)", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("AvgColumns(A)", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            });
-            Assert.IsTrue(result.IsVectorResult);
-            Assert.AreEqual(ComputationResult.VectorDirection.Horizontal, result.Direction);
-            var flat = result.VectorData.Data;
-            Assert.AreEqual(2.0f, flat[0], 0.00001f);
-            Assert.AreEqual(3.0f, flat[1], 0.00001f);
-        }
+        });
+        Assert.IsTrue(result.IsVectorResult);
+        Assert.AreEqual(ComputationResult.VectorDirection.Horizontal, result.Direction);
+        var flat = result.VectorData.Data;
+        Assert.AreEqual(2.0f, flat[0], 0.00001f);
+        Assert.AreEqual(3.0f, flat[1], 0.00001f);
+    }
 
-        [TestMethod]
-        public void TestPI()
-        {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("PI( )", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[0]);
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual((float)Math.PI, result.LiteralValue, 0.000001f);
-        }
+    [TestMethod]
+    public void TestPI()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("PI( )", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[0]);
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual((float)Math.PI, result.LiteralValue, 0.000001f);
+    }
 
-        [TestMethod]
-        public void TestE()
-        {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("E( )", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[0]);
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual((float)Math.E, result.LiteralValue, 0.000001f);
-        }
+    [TestMethod]
+    public void TestE()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("E( )", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[0]);
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual((float)Math.E, result.LiteralValue, 0.000001f);
+    }
 
-        [TestMethod]
-        public void TestMatrixExponent()
+    [TestMethod]
+    public void TestMatrixExponent()
+    {
+        CompareMatrix("A ^ B", new IModule[]
         {
-            CompareMatrix("A ^ B", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 1.0f, 16.0f, 729.0f, 65536.0f);
-        }
+        }, 1.0f, 16.0f, 729.0f, 65536.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixExponent2()
+    [TestMethod]
+    public void TestMatrixExponent2()
+    {
+        CompareMatrix("(A + 1) ^ (B - 1)", new IModule[]
         {
-            CompareMatrix("(A + 1) ^ (B - 1)", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 2.0f, 27.0f, 1024.0f, 78125.0f);
-        }
+        }, 2.0f, 27.0f, 1024.0f, 78125.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixEqual()
+    [TestMethod]
+    public void TestMatrixEqual()
+    {
+        CompareMatrix("A == B", new IModule[]
         {
-            CompareMatrix("A == B", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            }, 1.0f, 1.0f, 0.0f, 0.0f);
-        }
+        }, 1.0f, 1.0f, 0.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixNotEqual()
+    [TestMethod]
+    public void TestMatrixNotEqual()
+    {
+        CompareMatrix("A != B", new IModule[]
         {
-            CompareMatrix("A != B", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            }, 0.0f, 0.0f, 1.0f, 1.0f);
-        }
+        }, 0.0f, 0.0f, 1.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixLessThan()
+    [TestMethod]
+    public void TestMatrixLessThan()
+    {
+        CompareMatrix("A < B", new IModule[]
         {
-            CompareMatrix("A < B", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            }, 0.0f, 0.0f, 1.0f, 0.0f);
-        }
+        }, 0.0f, 0.0f, 1.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixGreaterThan()
+    [TestMethod]
+    public void TestMatrixGreaterThan()
+    {
+        CompareMatrix("A > B", new IModule[]
         {
-            CompareMatrix("A > B", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            }, 0.0f, 0.0f, 0.0f, 1.0f);
-        }
+        }, 0.0f, 0.0f, 0.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixLessThanOrEqual()
+    [TestMethod]
+    public void TestMatrixLessThanOrEqual()
+    {
+        CompareMatrix("A <= B", new IModule[]
         {
-            CompareMatrix("A <= B", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            }, 1.0f, 1.0f, 1.0f, 0.0f);
-        }
+        }, 1.0f, 1.0f, 1.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixGreaterThanOrEqual()
+    [TestMethod]
+    public void TestMatrixGreaterThanOrEqual()
+    {
+        CompareMatrix("A >= B", new IModule[]
         {
-            CompareMatrix("A >= B", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            }, 1.0f, 1.0f, 0.0f, 1.0f);
-        }
+        }, 1.0f, 1.0f, 0.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixCompareAdvanced()
+    [TestMethod]
+    public void TestMatrixCompareAdvanced()
+    {
+        CompareMatrix("(A == B) + (A != B)", new IModule[]
         {
-            CompareMatrix("(A == B) + (A != B)", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            }, 1.0f, 1.0f, 1.0f, 1.0f);
-        }
+        }, 1.0f, 1.0f, 1.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestAnd()
+    [TestMethod]
+    public void TestAnd()
+    {
+        CompareMatrix("(A == B) & (A != B)", new IModule[]
         {
-            CompareMatrix("(A == B) & (A != B)", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            }, 0.0f, 0.0f, 0.0f, 0.0f);
-        }
+        }, 0.0f, 0.0f, 0.0f, 0.0f);
+    }
 
-        [TestMethod]
-        public void TestOr()
+    [TestMethod]
+    public void TestOr()
+    {
+        CompareMatrix("(A == B) | (A != B)", new IModule[]
         {
-            CompareMatrix("(A == B) | (A != B)", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            }, 1.0f, 1.0f, 1.0f, 1.0f);
-        }
+        }, 1.0f, 1.0f, 1.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestMatrixLength()
+    [TestMethod]
+    public void TestMatrixLength()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("Length(A + 1) + Length(B - 1)", out Expression? ex, ref error));
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("Length(A + 1) + Length(B - 1)", out Expression? ex, ref error));
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 2, 4, 6, 8)
-            });
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual(8.0f, result.LiteralValue, 0.00001f);
-        }
+        });
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual(8.0f, result.LiteralValue, 0.00001f);
+    }
 
-        [TestMethod]
-        public void TestMatrix()
+    [TestMethod]
+    public void TestMatrix()
+    {
+        CompareMatrix("Matrix(asHorizontal(E)) + Matrix(asVertical(E))", new IModule[]
         {
-            CompareMatrix("Matrix(asHorizontal(E)) + Matrix(asVertical(E))", new IModule[]
-            {
                 CreateData("E", 9, 10)
-            }, 18.0f, 19.0f, 19.0f, 20.0f);
-        }
+        }, 18.0f, 19.0f, 19.0f, 20.0f);
+    }
 
-        [TestMethod]
-        public void TestIdentity()
+    [TestMethod]
+    public void TestIdentity()
+    {
+        var data = new IModule[]
         {
-            var data = new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateData("E", 9, 10)
-            };
-            CompareMatrix("identityMatrix(E)", data, 1.0f, 0.0f, 0.0f, 1.0f);
-            CompareMatrix("identityMatrix(A)", data, 1.0f, 0.0f, 0.0f, 1.0f);
-        }
+        };
+        CompareMatrix("identityMatrix(E)", data, 1.0f, 0.0f, 0.0f, 1.0f);
+        CompareMatrix("identityMatrix(A)", data, 1.0f, 0.0f, 0.0f, 1.0f);
+    }
 
-        [TestMethod]
-        public void TestOptimizeFusedMultiplyAddIsOptimizedIn()
-        {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("A * B + A", out Expression? ex, ref error), $"Unable to compile 'A * B + A'\r\n{error}");
-            Assert.IsInstanceOfType(ex, typeof(FusedMultiplyAdd));
-            Assert.IsTrue(Compiler.Compile("A + B * A", out ex, ref error), $"Unable to compile 'A * B + A'\r\n{error}");
-            Assert.IsInstanceOfType(ex, typeof(FusedMultiplyAdd));
-            Assert.IsTrue(Compiler.Compile("A * B + 4.0 * A + B * 1.2", out ex, ref error), $"Unable to compile 'A * B + A'\r\n{error}");
-            Assert.IsInstanceOfType(ex, typeof(FusedMultiplyAdd));
-            Assert.IsTrue(Compiler.Compile("A * B + (C * 2 + 3)", out ex, ref error), $"Unable to compile 'A * B + (C * 2 + 3)'\r\n{error}");
-            Assert.IsInstanceOfType(ex, typeof(FusedMultiplyAdd));
-            Assert.IsInstanceOfType(((FusedMultiplyAdd)ex).Add, typeof(FusedMultiplyAdd));
-        }
+    [TestMethod]
+    public void TestOptimizeFusedMultiplyAddIsOptimizedIn()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("A * B + A", out Expression? ex, ref error), $"Unable to compile 'A * B + A'\r\n{error}");
+        Assert.IsInstanceOfType(ex, typeof(FusedMultiplyAdd));
+        Assert.IsTrue(Compiler.Compile("A + B * A", out ex, ref error), $"Unable to compile 'A * B + A'\r\n{error}");
+        Assert.IsInstanceOfType(ex, typeof(FusedMultiplyAdd));
+        Assert.IsTrue(Compiler.Compile("A * B + 4.0 * A + B * 1.2", out ex, ref error), $"Unable to compile 'A * B + A'\r\n{error}");
+        Assert.IsInstanceOfType(ex, typeof(FusedMultiplyAdd));
+        Assert.IsTrue(Compiler.Compile("A * B + (C * 2 + 3)", out ex, ref error), $"Unable to compile 'A * B + (C * 2 + 3)'\r\n{error}");
+        Assert.IsInstanceOfType(ex, typeof(FusedMultiplyAdd));
+        Assert.IsInstanceOfType(((FusedMultiplyAdd)ex).Add, typeof(FusedMultiplyAdd));
+    }
 
-        [TestMethod]
-        public void TestOptimizeFusedMultiplyAdd()
+    [TestMethod]
+    public void TestOptimizeFusedMultiplyAdd()
+    {
+        CompareMatrix("A * B + A", new IModule[]
         {
-            CompareMatrix("A * B + A", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            }, 2.0f, 6.0f, 15.0f, 16.0f);
-        }
+        }, 2.0f, 6.0f, 15.0f, 16.0f);
+    }
 
-        [TestMethod]
-        public void TestOptimizeAddLiterals()
+    [TestMethod]
+    public void TestOptimizeAddLiterals()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("1 + 2", out Expression? ex, ref error), $"Unable to compile '1 + 2'\r\n{error}");
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("1 + 2", out Expression? ex, ref error), $"Unable to compile '1 + 2'\r\n{error}");
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            });
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual(3.0f, result.LiteralValue);
-            Assert.IsInstanceOfType(ex, typeof(Literal));
-            Assert.AreEqual(3.0f, ((Literal)ex).Value);
-        }
+        });
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual(3.0f, result.LiteralValue);
+        Assert.IsInstanceOfType(ex, typeof(Literal));
+        Assert.AreEqual(3.0f, ((Literal)ex).Value);
+    }
 
-        [TestMethod]
-        public void TestOptimizeSubtractLiterals()
+    [TestMethod]
+    public void TestOptimizeSubtractLiterals()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("1 - 2", out Expression? ex, ref error), $"Unable to compile '1 - 2'\r\n{error}");
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("1 - 2", out Expression? ex, ref error), $"Unable to compile '1 - 2'\r\n{error}");
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            });
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual(-1.0f, result.LiteralValue);
-            Assert.IsInstanceOfType(ex, typeof(Literal));
-            Assert.AreEqual(-1.0f, ((Literal)ex).Value);
-        }
+        });
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual(-1.0f, result.LiteralValue);
+        Assert.IsInstanceOfType(ex, typeof(Literal));
+        Assert.AreEqual(-1.0f, ((Literal)ex).Value);
+    }
 
-        [TestMethod]
-        public void TestOptimizeMultiplyLiterals()
+    [TestMethod]
+    public void TestOptimizeMultiplyLiterals()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("1 * 2", out Expression? ex, ref error), $"Unable to compile '1 * 2'\r\n{error}");
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("1 * 2", out Expression? ex, ref error), $"Unable to compile '1 * 2'\r\n{error}");
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            });
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual(2.0f, result.LiteralValue);
-            Assert.IsInstanceOfType(ex, typeof(Literal));
-            Assert.AreEqual(2.0f, ((Literal)ex).Value);
-        }
+        });
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual(2.0f, result.LiteralValue);
+        Assert.IsInstanceOfType(ex, typeof(Literal));
+        Assert.AreEqual(2.0f, ((Literal)ex).Value);
+    }
 
-        [TestMethod]
-        public void TestOptimizeDivideLiterals()
+    [TestMethod]
+    public void TestOptimizeDivideLiterals()
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile("1 / 2", out Expression? ex, ref error), $"Unable to compile '1 / 2'\r\n{error}");
+        var result = ex.Evaluate(new IModule[]
         {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile("1 / 2", out Expression? ex, ref error), $"Unable to compile '1 / 2'\r\n{error}");
-            var result = ex.Evaluate(new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            });
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual(0.5f, result.LiteralValue);
-            Assert.IsInstanceOfType(ex, typeof(Literal));
-            Assert.AreEqual(0.5f, ((Literal)ex).Value);
-        }
+        });
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual(0.5f, result.LiteralValue);
+        Assert.IsInstanceOfType(ex, typeof(Literal));
+        Assert.AreEqual(0.5f, ((Literal)ex).Value);
+    }
 
-        [TestMethod]
-        public void TestOptimizeDivideToMultiply()
+    [TestMethod]
+    public void TestOptimizeDivideToMultiply()
+    {
+        var data = new IModule[]
         {
-            var data = new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("B", 1, 2, 4, 3)
-            };
-            Assert.IsInstanceOfType(CompareMatrix("A / 2", data, 0.5f, 1.0f, 1.5f, 2.0f), typeof(Multiply));
-        }
+        };
+        Assert.IsInstanceOfType(CompareMatrix("A / 2", data, 0.5f, 1.0f, 1.5f, 2.0f), typeof(Multiply));
+    }
 
-        [TestMethod]
-        public void TestIfValueValue()
+    [TestMethod]
+    public void TestIfValueValue()
+    {
+        CompareMatrix("ZeroMatrix(B) + if(1, 2, 3)", new[]
         {
-            CompareMatrix("ZeroMatrix(B) + if(1, 2, 3)", new[]
-            {
                 CreateMatrixData("B", 1, 0, 1, 1)
             }, 2.0f, 2.0f, 2.0f, 2.0f);
-            CompareMatrix("ZeroMatrix(B) + if(0, 2, 3)", new[]
-            {
+        CompareMatrix("ZeroMatrix(B) + if(0, 2, 3)", new[]
+        {
                 CreateMatrixData("B", 1, 0, 1, 1)
             }, 3.0f, 3.0f, 3.0f, 3.0f);
-        }
+    }
 
-        [TestMethod]
-        public void TestIfValueVector()
+    [TestMethod]
+    public void TestIfValueVector()
+    {
+        CompareMatrix("ZeroMatrix(B) + asHorizontal(if(1, A, C))", new IModule[]
         {
-            CompareMatrix("ZeroMatrix(B) + asHorizontal(if(1, A, C))", new IModule[]
-            {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 1, 0, 1, 1),
                 CreateData("C", -1, -2)
-            }, 1.0f, 2.0f, 1.0f, 2.0f);
-            CompareMatrix("ZeroMatrix(B) + AsHorizontal(if(0, A, C))", new IModule[]
-            {
+        }, 1.0f, 2.0f, 1.0f, 2.0f);
+        CompareMatrix("ZeroMatrix(B) + AsHorizontal(if(0, A, C))", new IModule[]
+        {
                 CreateData("A", 1, 2),
                 CreateMatrixData("B", 1, 0, 1, 1),
                 CreateData("C", -1, -2)
-            }, -1.0f, -2.0f, -1.0f, -2.0f);
-        }
+        }, -1.0f, -2.0f, -1.0f, -2.0f);
+    }
 
-        [TestMethod]
-        public void TestIfValueMatrix()
+    [TestMethod]
+    public void TestIfValueMatrix()
+    {
+        CompareMatrix("if(1, A, C)", new IModule[]
         {
-            CompareMatrix("if(1, A, C)", new IModule[]
-            {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("C", -1, -2, -3, -4)
-            }, 1.0f, 2.0f, 3.0f, 4.0f);
-            CompareMatrix("if(0, A, C)", new IModule[]
-            {
+        }, 1.0f, 2.0f, 3.0f, 4.0f);
+        CompareMatrix("if(0, A, C)", new IModule[]
+        {
                 CreateMatrixData("A", 1, 2, 3, 4),
                 CreateMatrixData("C", -1, -2, -3, -4)
-            }, -1.0f, -2.0f, -3.0f, -4.0f);
-        }
+        }, -1.0f, -2.0f, -3.0f, -4.0f);
+    }
 
-        [TestMethod]
-        public void TestIfVectorValue()
+    [TestMethod]
+    public void TestIfVectorValue()
+    {
+        CompareMatrix("ZeroMatrix(B) + asHorizontal(if(A, 4, 5))", new IModule[]
         {
-            CompareMatrix("ZeroMatrix(B) + asHorizontal(if(A, 4, 5))", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 1, 1),
-            }, 4.0f, 5.0f, 4.0f, 5.0f);
-        }
+        }, 4.0f, 5.0f, 4.0f, 5.0f);
+    }
 
-        [TestMethod]
-        public void TestIfVectorVector()
+    [TestMethod]
+    public void TestIfVectorVector()
+    {
+        CompareMatrix("ZeroMatrix(B) + asHorizontal(if(A, C, D))", new IModule[]
         {
-            CompareMatrix("ZeroMatrix(B) + asHorizontal(if(A, C, D))", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("B", 1, 0, 1, 1),
                 CreateData("C", 4, 5),
                 CreateData("D", -4, -5),
-            }, 4.0f, -5.0f, 4.0f, -5.0f);
-        }
+        }, 4.0f, -5.0f, 4.0f, -5.0f);
+    }
 
-        [TestMethod]
-        public void TestIfVectorMatrixHorizontal()
+    [TestMethod]
+    public void TestIfVectorMatrixHorizontal()
+    {
+        CompareMatrix("if(asHorizontal(A), C, D)", new IModule[]
         {
-            CompareMatrix("if(asHorizontal(A), C, D)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("C", 4, 5, 6, 7),
                 CreateMatrixData("D", -4, -5, -6, -7),
-            }, 4.0f, -5.0f, 6.0f, -7.0f);
-        }
+        }, 4.0f, -5.0f, 6.0f, -7.0f);
+    }
 
-        [TestMethod]
-        public void TestIfVectorMatrixVertical()
+    [TestMethod]
+    public void TestIfVectorMatrixVertical()
+    {
+        CompareMatrix("if(asVertical(A), C, D)", new IModule[]
         {
-            CompareMatrix("if(asVertical(A), C, D)", new IModule[]
-            {
                 CreateData("A", 1, 0),
                 CreateMatrixData("C", 4, 5, 6, 7),
                 CreateMatrixData("D", -4, -5, -6, -7),
-            }, 4.0f, 5.0f, -6.0f, -7.0f);
-        }
+        }, 4.0f, 5.0f, -6.0f, -7.0f);
+    }
 
-        [TestMethod]
-        public void TestIfMatrixMatrix()
+    [TestMethod]
+    public void TestIfMatrixMatrix()
+    {
+        CompareMatrix("if(B, ZeroMatrix(B)+2, ZeroMatrix(B) + (0-2))", new IModule[]
         {
-            CompareMatrix("if(B, ZeroMatrix(B)+2, ZeroMatrix(B) + (0-2))", new IModule[]
-            {
                 CreateMatrixData("B", 1, 0, 1, 1)
-            }, 2.0f, -2.0f, 2.0f, 2.0f);
-        }
+        }, 2.0f, -2.0f, 2.0f, 2.0f);
+    }
 
-        [TestMethod]
-        public void TestLog()
+    [TestMethod]
+    public void TestLog()
+    {
+        CompareMatrix("Log(B)", new IModule[]
         {
-            CompareMatrix("Log(B)", new IModule[]
-            {
                 CreateMatrixData("B", 1, 0.5f, 0.25f, 0.125f)
-            }, (float)Math.Log(1), (float)Math.Log(0.5f), (float)Math.Log(0.25f), (float)Math.Log(0.125f));
-        }
+        }, (float)Math.Log(1), (float)Math.Log(0.5f), (float)Math.Log(0.25f), (float)Math.Log(0.125f));
+    }
 
-        [TestMethod]
-        public void TestSqrtMatrix()
+    [TestMethod]
+    public void TestSqrtMatrix()
+    {
+        CompareMatrix("sqrt(B)", new IModule[]
         {
-            CompareMatrix("sqrt(B)", new IModule[]
-            {
                 CreateMatrixData("B", 1, 0.5f, 0.25f, 0.125f)
-            }, (float)Math.Sqrt(1), (float)Math.Sqrt(0.5f), (float)Math.Sqrt(0.25f), (float)Math.Sqrt(0.125f));
-        }
+        }, (float)Math.Sqrt(1), (float)Math.Sqrt(0.5f), (float)Math.Sqrt(0.25f), (float)Math.Sqrt(0.125f));
+    }
 
-        [TestMethod]
-        public void TestSqrtVector()
+    [TestMethod]
+    public void TestSqrtVector()
+    {
+        CompareVector("sqrt(B)", new IModule[]
         {
-            CompareVector("sqrt(B)", new IModule[]
-            {
                 CreateVectorData("B", 1, 0.5f, 0.25f, 0.125f)
-            }, (float)Math.Sqrt(1), (float)Math.Sqrt(0.5f), (float)Math.Sqrt(0.25f), (float)Math.Sqrt(0.125f));
-        }
+        }, (float)Math.Sqrt(1), (float)Math.Sqrt(0.5f), (float)Math.Sqrt(0.25f), (float)Math.Sqrt(0.125f));
+    }
 
-        [TestMethod]
-        public void TestSqrtScalar()
+    [TestMethod]
+    public void TestSqrtScalar()
+    {
+        CompareScalar("sqrt(B)", new IModule[]
         {
-            CompareScalar("sqrt(B)", new IModule[]
-            {
                 CreateScalarData("B", 0.5f)
-            }, (float)Math.Sqrt(0.5f));
-        }
+        }, (float)Math.Sqrt(0.5f));
+    }
 
-        [TestMethod]
-        public void TestIfNaN()
+    [TestMethod]
+    public void TestIfNaN()
+    {
+        CompareMatrix("IfNaN(B, C)", new IModule[]
         {
-            CompareMatrix("IfNaN(B, C)", new IModule[]
-            {
                 CreateMatrixData("B", 1, float.NaN, float.NaN, 0.125f),
                 CreateMatrixData("C", 1, 2, 3, 4)
-            }, 1, 2, 3, 0.125f);
-        }
+        }, 1, 2, 3, 0.125f);
+    }
 
-        [TestMethod]
-        public void TestNegate()
+    [TestMethod]
+    public void TestNegate()
+    {
+        CompareMatrix("-B", new IModule[]
         {
-            CompareMatrix("-B", new IModule[]
-            {
                 CreateMatrixData("B", 1, 0.5f, 0.25f, 0.125f)
-            }, -1, -0.5f, -0.25f, -0.125f);
-        }
+        }, -1, -0.5f, -0.25f, -0.125f);
+    }
 
-        [TestMethod]
-        public void TestNegateWithAdd()
+    [TestMethod]
+    public void TestNegateWithAdd()
+    {
+        CompareMatrix("-10 + B", new IModule[]
         {
-            CompareMatrix("-10 + B", new IModule[]
-            {
                 CreateMatrixData("B", 1, 2, 3, 4)
-            }, -9, -8, -7, -6);
-        }
+        }, -9, -8, -7, -6);
+    }
 
-        [TestMethod]
-        public void TestNegateWithExp()
+    [TestMethod]
+    public void TestNegateWithExp()
+    {
+        CompareMatrix("-B^-1", new IModule[]
         {
-            CompareMatrix("-B^-1", new IModule[]
-            {
                 CreateMatrixData("B", 1, 2, 4, 8)
-            }, -1, -0.5f, -0.25f, -0.125f);
-        }
+        }, -1, -0.5f, -0.25f, -0.125f);
+    }
 
-        [TestMethod]
-        public void TestNegateWithMul()
+    [TestMethod]
+    public void TestNegateWithMul()
+    {
+        CompareMatrix("B*-1", new IModule[]
         {
-            CompareMatrix("B*-1", new IModule[]
-            {
                 CreateMatrixData("B", 1, 2, 4, 8)
-            }, -1, -2, -4, -8);
-        }
+        }, -1, -2, -4, -8);
+    }
 
-        [TestMethod]
-        public void TestNormalize()
+    [TestMethod]
+    public void TestNormalize()
+    {
+        CompareMatrix("normalize(B)", new IModule[]
         {
-            CompareMatrix("normalize(B)", new IModule[]
-            {
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 0.1f, 0.2f, 0.3f, 0.4f);
-        }
+        }, 0.1f, 0.2f, 0.3f, 0.4f);
+    }
 
-        [TestMethod]
-        public void TestNormalizeColumns()
+    [TestMethod]
+    public void TestNormalizeColumns()
+    {
+        CompareMatrix("normalizeColumns(B)", new IModule[]
         {
-            CompareMatrix("normalizeColumns(B)", new IModule[]
-            {
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 2f / 8f, 4f / 12f, 6f / 8f, 8f / 12f);
-        }
+        }, 2f / 8f, 4f / 12f, 6f / 8f, 8f / 12f);
+    }
 
-        [TestMethod]
-        public void TestNormalizeRows()
+    [TestMethod]
+    public void TestNormalizeRows()
+    {
+        CompareMatrix("normalizeRows(B)", new IModule[]
         {
-            CompareMatrix("normalizeRows(B)", new IModule[]
-            {
                 CreateMatrixData("B", 2, 4, 6, 8)
-            }, 2f / 6f, 4f / 6f, 6f / 14f, 8f / 14f);
-        }
-
-        [TestMethod]
-        public void TestSubtractionOrder()
-        {
-            string? error = null;
-            var equation = "2 + 3 - 1 + 2";
-            Assert.IsTrue(Compiler.Compile(equation, out Expression? ex, ref error), $"Unable to compile '{equation}'\r\n{error}");
-            var result = ex.Evaluate(new IModule[0]);
-            Assert.IsTrue(result.IsValue, "The result was not a scalar!");
-            Assert.AreEqual(6.0f, result.LiteralValue, 0.000001f);
-        }
+        }, 2f / 6f, 4f / 6f, 6f / 14f, 8f / 14f);
+    }
 
-        /// <summary>
-        /// Assert results
-        /// </summary>
-        private static Expression CompareMatrix(string equation, IModule[] data, float m11, float m12, float m21, float m22)
-        {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile(equation, out Expression? ex, ref error), $"Unable to compile '{equation}'\r\n{error}");
-            var result = ex.Evaluate(data);
-            Assert.IsTrue(result.IsOdResult, result.ErrorMessage);
-            var flat = result.OdData.Data;
-            Assert.AreEqual(m11, flat[0], 0.00001f);
-            Assert.AreEqual(m12, flat[1], 0.00001f);
-            Assert.AreEqual(m21, flat[2], 0.00001f);
-            Assert.AreEqual(m22, flat[3], 0.00001f);
-            return ex;
-        }
+    [TestMethod]
+    public void TestSubtractionOrder()
+    {
+        string? error = null;
+        var equation = "2 + 3 - 1 + 2";
+        Assert.IsTrue(Compiler.Compile(equation, out Expression? ex, ref error), $"Unable to compile '{equation}'\r\n{error}");
+        var result = ex.Evaluate(new IModule[0]);
+        Assert.IsTrue(result.IsValue, "The result was not a scalar!");
+        Assert.AreEqual(6.0f, result.LiteralValue, 0.000001f);
+    }
 
-        /// <summary>
-        /// Assert results
-        /// </summary>
-        private static Expression CompareVector(string equation, IModule[] data, float m11, float m12, float m21, float m22)
-        {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile(equation, out Expression? ex, ref error), $"Unable to compile '{equation}'\r\n{error}");
-            var result = ex.Evaluate(data);
-            if (result.Error)
-            {
-                Assert.Fail(result.ErrorMessage ?? "Unknown error");
-            }
-            Assert.IsTrue(result.IsVectorResult);
-            var flat = result.VectorData.Data;
-            Assert.AreEqual(m11, flat[0], 0.00001f);
-            Assert.AreEqual(m12, flat[1], 0.00001f);
-            Assert.AreEqual(m21, flat[2], 0.00001f);
-            Assert.AreEqual(m22, flat[3], 0.00001f);
-            return ex;
-        }
+    /// <summary>
+    /// Assert results
+    /// </summary>
+    private static Expression CompareMatrix(string equation, IModule[] data, float m11, float m12, float m21, float m22)
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile(equation, out Expression? ex, ref error), $"Unable to compile '{equation}'\r\n{error}");
+        var result = ex.Evaluate(data);
+        Assert.IsTrue(result.IsOdResult, result.ErrorMessage);
+        var flat = result.OdData.Data;
+        Assert.AreEqual(m11, flat[0], 0.00001f);
+        Assert.AreEqual(m12, flat[1], 0.00001f);
+        Assert.AreEqual(m21, flat[2], 0.00001f);
+        Assert.AreEqual(m22, flat[3], 0.00001f);
+        return ex;
+    }
 
-        /// <summary>
-        /// Assert results
-        /// </summary>
-        private static Expression CompareScalar(string equation, IModule[] data, float m11)
-        {
-            string? error = null;
-            Assert.IsTrue(Compiler.Compile(equation, out Expression? ex, ref error), $"Unable to compile '{equation}'\r\n{error}");
-            var result = ex.Evaluate(data);
-            if (result.Error)
-            {
-                Assert.Fail(result.ErrorMessage ?? "Unknown error");
-            }
-            Assert.IsTrue(result.IsValue);
-            Assert.AreEqual(m11, result.LiteralValue, 0.00001f);
-            return ex;
-        }
+    /// <summary>
+    /// Assert results
+    /// </summary>
+    private static Expression CompareVector(string equation, IModule[] data, float m11, float m12, float m21, float m22)
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile(equation, out Expression? ex, ref error), $"Unable to compile '{equation}'\r\n{error}");
+        var result = ex.Evaluate(data);
+        if (result.Error)
+        {
+            Assert.Fail(result.ErrorMessage ?? "Unknown error");
+        }
+        Assert.IsTrue(result.IsVectorResult);
+        var flat = result.VectorData.Data;
+        Assert.AreEqual(m11, flat[0], 0.00001f);
+        Assert.AreEqual(m12, flat[1], 0.00001f);
+        Assert.AreEqual(m21, flat[2], 0.00001f);
+        Assert.AreEqual(m22, flat[3], 0.00001f);
+        return ex;
+    }
 
-        class ScalarSource : BaseFunction<float>
+    /// <summary>
+    /// Assert results
+    /// </summary>
+    private static Expression CompareScalar(string equation, IModule[] data, float m11)
+    {
+        string? error = null;
+        Assert.IsTrue(Compiler.Compile(equation, out Expression? ex, ref error), $"Unable to compile '{equation}'\r\n{error}");
+        var result = ex.Evaluate(data);
+        if (result.Error)
         {
-            readonly float _data;
+            Assert.Fail(result.ErrorMessage ?? "Unknown error");
+        }
+        Assert.IsTrue(result.IsValue);
+        Assert.AreEqual(m11, result.LiteralValue, 0.00001f);
+        return ex;
+    }
 
-            public ScalarSource(float data)
-            {
-                _data = data;
-            }
+    class ScalarSource : BaseFunction<float>
+    {
+        readonly float _data;
 
-            public override float Invoke()
-            {
-                return _data;
-            }
+        public ScalarSource(float data)
+        {
+            _data = data;
         }
 
-        class VectorSource : BaseFunction<Vector>
+        public override float Invoke()
         {
-            readonly Vector Data;
+            return _data;
+        }
+    }
 
-            public VectorSource(Vector vector)
-            {
-                Data = vector;
-            }
+    class VectorSource : BaseFunction<Vector>
+    {
+        readonly Vector Data;
 
-            public override Vector Invoke()
-            {
-                return Data;
-            }
+        public VectorSource(Vector vector)
+        {
+            Data = vector;
         }
 
-        class MatrixSource : BaseFunction<Matrix>
+        public override Vector Invoke()
         {
+            return Data;
+        }
+    }
 
-            readonly Matrix Data;
+    class MatrixSource : BaseFunction<Matrix>
+    {
 
-            public MatrixSource(Matrix matrix)
-            {
-                Data = matrix;
-            }
+        readonly Matrix Data;
 
-            public override Matrix Invoke()
-            {
-                return Data;
-            }
+        public MatrixSource(Matrix matrix)
+        {
+            Data = matrix;
+        }
+
+        public override Matrix Invoke()
+        {
+            return Data;
         }
     }
 }
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagAnd.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagAnd.cs
index b6935ea..312e539 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagAnd.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagAnd.cs
@@ -16,8 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfEquals.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfEquals.cs
index bf2284d..22a9c9d 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfEquals.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfEquals.cs
@@ -16,8 +16,6 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfGreaterThan.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfGreaterThan.cs
index d188c05..4e2d7a3 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfGreaterThan.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfGreaterThan.cs
@@ -16,8 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfGreaterThanOrEqual.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfGreaterThanOrEqual.cs
index 9a93a3f..7e7ddc3 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfGreaterThanOrEqual.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfGreaterThanOrEqual.cs
@@ -16,8 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfLessThan.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfLessThan.cs
index 201f7a8..8892d96 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfLessThan.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfLessThan.cs
@@ -16,8 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfLessThanOrEqual.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfLessThanOrEqual.cs
index a319a68..48903f0 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfLessThanOrEqual.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfLessThanOrEqual.cs
@@ -16,8 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfNotEquals.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfNotEquals.cs
index 959bdb1..d1f3de5 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfNotEquals.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagIfNotEquals.cs
@@ -16,8 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagOr.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagOr.cs
index e0acda4..e370d49 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagOr.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/Conditions/TestFlagOr.cs
@@ -16,8 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestAdd.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestAdd.cs
index ebb9f5a..af669fa 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestAdd.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestAdd.cs
@@ -16,8 +16,6 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestDivide.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestDivide.cs
index 56d297d..536dc27 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestDivide.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestDivide.cs
@@ -16,8 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestExp.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestExp.cs
index 7b7f93e..a451b97 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestExp.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestExp.cs
@@ -16,9 +16,6 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
 
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestFusedMultiplyAdd.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestFusedMultiplyAdd.cs
index e398f7e..b3e2203 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestFusedMultiplyAdd.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestFusedMultiplyAdd.cs
@@ -16,8 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestIf.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestIf.cs
index 430df64..e42071b 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestIf.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestIf.cs
@@ -16,8 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestLog.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestLog.cs
index 5d007e1..11128ad 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestLog.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestLog.cs
@@ -16,9 +16,6 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
 
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestMultiply.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestMultiply.cs
index dd51821..2e4d904 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestMultiply.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestMultiply.cs
@@ -16,8 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestPow.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestPow.cs
index aa6d00a..02192d7 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestPow.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestPow.cs
@@ -16,8 +16,6 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace TMG.Test.VectorHelper;
 
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestSubtract.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestSubtract.cs
index a9c23ef..8cef6de 100644
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/TestSubtract.cs
+++ b/tests/TMG-Framework.Test/Utilities/VectorHelper/TestSubtract.cs
@@ -16,8 +16,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+
 using TMG.Test.Utilities;
 
 namespace TMG.Test.VectorHelper;
diff --git a/tests/TMG-Framework.Test/Utilities/VectorHelper/VectorHelper.cs b/tests/TMG-Framework.Test/Utilities/VectorHelper/VectorHelper.cs
deleted file mode 100644
index 3d0ca2a..0000000
--- a/tests/TMG-Framework.Test/Utilities/VectorHelper/VectorHelper.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
-    Copyright 2017 University of Toronto
-
-    This file is part of TMG-Framework for XTMF2.
-
-    TMG-Framework for XTMF2 is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    TMG-Framework for XTMF2 is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
-*/
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-using TMG.Saving;
-
-namespace TMG.Test.Utilities.VectorHelper;
-
-[TestClass]
-public class TestVectorHelper
-{
-    
-}

From 032a98eb499978b107d372c8cc2bc80288fc2327 Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Sat, 22 Aug 2026 17:33:24 -0400
Subject: [PATCH 3/3] Modernized TMG-Framework

---
 .../Construct/ConstructTimePeriodFromTimes.cs |   29 +-
 .../Convert/ConvertTimesToTimePeriod.cs       |    9 +-
 src/TMG-Framework/Data/Categories.cs          |  188 +-
 src/TMG-Framework/Data/CategoryIndex.cs       |  154 +-
 src/TMG-Framework/Data/CategoryMap.cs         |  284 ++-
 src/TMG-Framework/Data/Matrix.cs              |  395 ++--
 src/TMG-Framework/Data/Range.cs               |  175 +-
 src/TMG-Framework/Data/RangeSet.cs            |  543 +++---
 src/TMG-Framework/Data/RangeSetSet.cs         |  313 ++--
 src/TMG-Framework/Data/Time.cs                |  822 ++++-----
 src/TMG-Framework/Data/TimePeriod.cs          |   62 +-
 src/TMG-Framework/Data/Vector.cs              |  177 +-
 src/TMG-Framework/FileOperations/CopyFile.cs  |  134 +-
 .../FileOperations/DeleteFile.cs              |   46 +-
 src/TMG-Framework/GlobalUsings.cs             |    9 +
 .../Loading/LoadCategoriesFromCSV.cs          |    5 +-
 .../LoadCategoryMapFromThirdNormalizedCSV.cs  |  274 ++-
 .../Loading/LoadMatrixFromCSVMatrix.cs        |   81 +-
 .../LoadMatrixFromCSVThirdNormalized.cs       |  104 +-
 .../Loading/LoadMatrixFromMTX.cs              |  236 ++-
 .../Loading/LoadVectorFromCSV.cs              |   82 +-
 src/TMG-Framework/Processing/AST/ASTNode.cs   |  133 +-
 src/TMG-Framework/Processing/AST/Add.cs       |  282 ++-
 .../Processing/AST/CompareAnd.cs              |  187 +-
 .../Processing/AST/CompareEqual.cs            |  187 +-
 .../Processing/AST/CompareGreaterThan.cs      |  185 +-
 .../AST/CompareGreaterThanOrEqual.cs          |  185 +-
 .../Processing/AST/CompareNotEquals.cs        |  187 +-
 src/TMG-Framework/Processing/AST/CompareOr.cs |  187 +-
 src/TMG-Framework/Processing/AST/Compiler.cs  |   17 +-
 src/TMG-Framework/Processing/AST/Divide.cs    |  238 ++-
 src/TMG-Framework/Processing/AST/Exponent.cs  |  194 +-
 .../Processing/AST/Expression.cs              | 1200 ++++++------
 .../Processing/AST/FunctionCall.cs            | 1644 ++++++++---------
 .../Processing/AST/FusedMultiplyAdd.cs        |  745 ++++----
 src/TMG-Framework/Processing/AST/Multiply.cs  |  212 ++-
 src/TMG-Framework/Processing/AST/Negate.cs    |   99 +-
 src/TMG-Framework/Processing/AST/Subtract.cs  |  213 ++-
 src/TMG-Framework/Processing/AST/Variable.cs  |   59 +-
 .../Processing/AppendMatrixValueToCSV.cs      |  109 +-
 .../Processing/Evaluate2DGravityModel.cs      |  175 +-
 .../Processing/EvaluateMatrix.cs              |   98 +-
 .../Processing/EvaluateScalar.cs              |   84 +-
 .../Processing/EvaluateVector.cs              |   84 +-
 .../ExecutePipelineInOrderParallel.cs         |   38 +-
 .../Processing/IntegerizeMatrix.cs            |  244 ++-
 src/TMG-Framework/Saving/SaveMatrixAsCSV.cs   |  166 +-
 src/TMG-Framework/Saving/SaveMatrixAsMTX.cs   |   72 +-
 src/TMG-Framework/Saving/SaveVectorAsCSV.cs   |   66 +-
 src/TMG-Framework/Select/SelectGivenTime.cs   |   97 +-
 src/TMG-Framework/TMG-Framework.csproj        |    1 +
 src/TMG-Framework/Utilities/CSVReader.cs      |  762 ++++----
 .../Utilities/ExceptionHelper.cs              |   69 +-
 src/TMG-Framework/Utilities/ObjectStream.cs   |   37 +-
 src/TMG-Framework/Utilities/SpanHelper.cs     |   22 +-
 .../Utilities/VectorHelper/Add.cs             |    4 -
 .../VectorHelper/Conditions/FlagAnd.cs        |    6 +-
 .../VectorHelper/Conditions/FlagIfEquals.cs   |    6 +-
 .../Conditions/FlagIfGreaterThan.cs           |    5 +-
 .../Conditions/FlagIfGreaterThanOrEqual.cs    |    5 +-
 .../VectorHelper/Conditions/FlagIfLessThan.cs |    5 +-
 .../Conditions/FlagIfLessThanOrEqual.cs       |    4 -
 .../Conditions/FlagIfNotEquals.cs             |    4 +-
 .../VectorHelper/Conditions/FlagOr.cs         |    7 +-
 .../Utilities/VectorHelper/Divide.cs          |    3 -
 .../Utilities/VectorHelper/Exp.cs             |    3 -
 .../VectorHelper/FusedMultiplyAdd.cs          |    3 -
 .../Utilities/VectorHelper/If.cs              |    3 -
 .../Utilities/VectorHelper/Log.cs             |    3 -
 .../Utilities/VectorHelper/Multiply.cs        |    3 -
 .../Utilities/VectorHelper/Pow.cs             |    5 +-
 .../Utilities/VectorHelper/Subtract.cs        |    4 -
 .../Utilities/VectorHelper/VectorHelper.cs    |    5 +-
 73 files changed, 6091 insertions(+), 6387 deletions(-)
 create mode 100644 src/TMG-Framework/GlobalUsings.cs

diff --git a/src/TMG-Framework/Construct/ConstructTimePeriodFromTimes.cs b/src/TMG-Framework/Construct/ConstructTimePeriodFromTimes.cs
index ec91489..82f9103 100644
--- a/src/TMG-Framework/Construct/ConstructTimePeriodFromTimes.cs
+++ b/src/TMG-Framework/Construct/ConstructTimePeriodFromTimes.cs
@@ -16,26 +16,23 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
+
 using XTMF2;
 
-namespace TMG.Construct
+namespace TMG.Construct;
+
+[Module(Name = "Construct Time Period from Times", Description = "Given the start and end times construct a time period.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public sealed class ConstructTimePeriodFromTimes : BaseFunction<TimePeriod>
 {
-    [Module(Name = "Construct Time Period from Times", Description = "Given the start and end times construct a time period.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public sealed class ConstructTimePeriodFromTimes : BaseFunction<TimePeriod>
-    {
-        [Parameter(Index = 0, Name = "Start Time", Required = true, Description = "The time to use as the starting point of the time period (Inclusive).")]
-        public IFunction<Time> StartTime = null!;
+    [Parameter(Index = 0, Name = "Start Time", Required = true, Description = "The time to use as the starting point of the time period (Inclusive).")]
+    public IFunction<Time> StartTime = null!;
 
-        [Parameter(Index = 1, Name = "End Time", Required = true, Description = "The time to use as the ending point of the time period (Exclusive).")]
-        public IFunction<Time> EndTime = null!;
+    [Parameter(Index = 1, Name = "End Time", Required = true, Description = "The time to use as the ending point of the time period (Exclusive).")]
+    public IFunction<Time> EndTime = null!;
 
-        public override TimePeriod Invoke()
-        {
-            return new TimePeriod(StartTime.Invoke(), EndTime.Invoke());
-        }
+    public override TimePeriod Invoke()
+    {
+        return new TimePeriod(StartTime.Invoke(), EndTime.Invoke());
     }
 }
diff --git a/src/TMG-Framework/Convert/ConvertTimesToTimePeriod.cs b/src/TMG-Framework/Convert/ConvertTimesToTimePeriod.cs
index 2ba463b..4eb93a1 100644
--- a/src/TMG-Framework/Convert/ConvertTimesToTimePeriod.cs
+++ b/src/TMG-Framework/Convert/ConvertTimesToTimePeriod.cs
@@ -16,13 +16,11 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
+
 using XTMF2;
 
-namespace TMG.Convert
-{
+namespace TMG.Convert;
+
     [Module(Name = "Convert Times to Time Period", Description = "Takes in a start and end time to generate a time period.",
         DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
     public sealed class ConvertTimesToTimePeriod : BaseFunction<(Time start, Time end), TimePeriod>
@@ -32,4 +30,3 @@ public override TimePeriod Invoke((Time start, Time end) context)
             return new TimePeriod(context.start, context.end);
         }
     }
-}
diff --git a/src/TMG-Framework/Data/Categories.cs b/src/TMG-Framework/Data/Categories.cs
index a5bf743..f1a6236 100644
--- a/src/TMG-Framework/Data/Categories.cs
+++ b/src/TMG-Framework/Data/Categories.cs
@@ -16,128 +16,122 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
 using static TMG.Utilities.ExceptionHelper;
 using System.Collections;
-using System.Diagnostics.CodeAnalysis;
 
-namespace TMG
+namespace TMG;
+
+/// <summary>
+/// 
+/// </summary>
+public sealed class Categories : IEnumerable<int>
 {
     /// <summary>
-    /// 
+    /// Get the number of elements in the categories.
     /// </summary>
-    public sealed class Categories : IEnumerable<int>
-    {
-        /// <summary>
-        /// Get the number of elements in the categories.
-        /// </summary>
-        public int Count => _elements.Count;
+    public int Count => _elements.Count;
 
-        /// <summary>
-        /// TODO: Update the representation later on to something more efficient
-        /// </summary>
-        private readonly List<int> _elements;
+    /// <summary>
+    /// TODO: Update the representation later on to something more efficient
+    /// </summary>
+    private readonly List<int> _elements;
 
-        /// <summary>
-        /// Create a Categories instance from a list of elements
-        /// </summary>
-        /// <param name="elements">The list of elements to use, values will be sorted, any duplicates will return in failure.</param>
-        /// <param name="error">The error message if creation fails</param>
-        /// <returns>True if creation succeeds, false otherwise</returns>
-        public static bool CreateCategories(List<int> elements, 
-            [NotNullWhen(true)] out Categories? categories,
-            [NotNullWhen(false)] ref string? error)
+    /// <summary>
+    /// Create a Categories instance from a list of elements
+    /// </summary>
+    /// <param name="elements">The list of elements to use, values will be sorted, any duplicates will return in failure.</param>
+    /// <param name="error">The error message if creation fails</param>
+    /// <returns>True if creation succeeds, false otherwise</returns>
+    public static bool CreateCategories(List<int> elements,
+        [NotNullWhen(true)] out Categories? categories,
+        [NotNullWhen(false)] ref string? error)
+    {
+        elements = elements?.ToList() ?? throw new ArgumentNullException(nameof(elements));
+        elements.Sort();
+        for (int i = 1; i < elements.Count; i++)
         {
-            elements = elements?.ToList() ?? throw new ArgumentNullException(nameof(elements));
-            elements.Sort();
-            for (int i = 1; i < elements.Count; i++)
+            if (elements[i - 1] == elements[i])
             {
-                if(elements[i - 1] == elements[i])
-                {
-                    error = $"Found a duplicate category {elements[i]}!";
-                    categories = null;
-                    return false;
-                }
+                error = $"Found a duplicate category {elements[i]}!";
+                categories = null;
+                return false;
             }
-            categories = new Categories(elements);
-            return true;
         }
+        categories = new Categories(elements);
+        return true;
+    }
 
-        /// <summary>
-        /// Create a Categories instance from a list of elements
-        /// </summary>
-        /// <param name="elements">The list of elements to use, values will be sorted, any duplicates will return in failure.</param>
-        /// <param name="error">The error message if creation fails</param>
-        /// <returns>True if creation succeeds, false otherwise</returns>
-        public static bool CreateCategories(Span<int> elements, 
-            [NotNullWhen(true)] out Categories? categories,
-            [NotNullWhen(false)] ref string? error)
+    /// <summary>
+    /// Create a Categories instance from a list of elements
+    /// </summary>
+    /// <param name="elements">The list of elements to use, values will be sorted, any duplicates will return in failure.</param>
+    /// <param name="error">The error message if creation fails</param>
+    /// <returns>True if creation succeeds, false otherwise</returns>
+    public static bool CreateCategories(Span<int> elements,
+        [NotNullWhen(true)] out Categories? categories,
+        [NotNullWhen(false)] ref string? error)
+    {
+        var list = new List<int>(elements.ToArray());
+        list.Sort();
+        for (int i = 1; i < list.Count; i++)
         {
-            var list = new List<int>(elements.ToArray());
-            list.Sort();
-            for (int i = 1; i < list.Count; i++)
+            if (list[i - 1] == list[i])
             {
-                if(list[i - 1] == list[i])
-                {
-                    error = $"Found a duplicate category {list[i]}!";
-                    categories = null;
-                    return false;
-                }
+                error = $"Found a duplicate category {list[i]}!";
+                categories = null;
+                return false;
             }
-            categories = new Categories(list);
-            return true;
         }
+        categories = new Categories(list);
+        return true;
+    }
 
-        /// <summary>
-        /// Create a Categories instance from a list of elements
-        /// </summary>
-        /// <param name="elements">The sorted list of elements to use</param>
-        private Categories(List<int> elements)
+    /// <summary>
+    /// Create a Categories instance from a list of elements
+    /// </summary>
+    /// <param name="elements">The sorted list of elements to use</param>
+    private Categories(List<int> elements)
+    {
+        if (elements == null)
         {
-            if(elements == null)
-            {
-                ThrowParameterNull(nameof(elements));
-            }
-            _elements = elements;
+            ThrowParameterNull(nameof(elements));
         }
+        _elements = elements;
+    }
 
-        /// <summary>
-        /// Gives the flat index of the specified sparse index, or less than 0 if the sparse index is not in the map.
-        /// </summary>
-        /// <param name="sparseIndex">The sparse index to look up</param>
-        /// <returns>Gives the flat index of the specified sparse index, or less than 0 if the sparse index is not in the map.</returns>
-        public int GetFlatIndex(CategoryIndex sparseIndex)
-        {
-            return _elements.BinarySearch(sparseIndex);
-        }
+    /// <summary>
+    /// Gives the flat index of the specified sparse index, or less than 0 if the sparse index is not in the map.
+    /// </summary>
+    /// <param name="sparseIndex">The sparse index to look up</param>
+    /// <returns>Gives the flat index of the specified sparse index, or less than 0 if the sparse index is not in the map.</returns>
+    public int GetFlatIndex(CategoryIndex sparseIndex)
+    {
+        return _elements.BinarySearch(sparseIndex);
+    }
 
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="flatIndex"></param>
-        /// <returns></returns>
-        public CategoryIndex GetSparseIndex(int flatIndex)
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="flatIndex"></param>
+    /// <returns></returns>
+    public CategoryIndex GetSparseIndex(int flatIndex)
+    {
+        if (flatIndex < 0 || flatIndex >= _elements.Count)
         {
-            if(flatIndex < 0 || flatIndex >= _elements.Count)
-            {
-                ThrowOutOfRangeException(nameof(flatIndex));
-            }
-            return _elements[flatIndex];
+            ThrowOutOfRangeException(nameof(flatIndex));
         }
+        return _elements[flatIndex];
+    }
 
-        /// <inheritdoc/>
-        public IEnumerator<int> GetEnumerator()
-        {
-            return _elements.GetEnumerator();
-        }
+    /// <inheritdoc/>
+    public IEnumerator<int> GetEnumerator()
+    {
+        return _elements.GetEnumerator();
+    }
 
-        /// <inheritdoc/>
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return ((IEnumerable)_elements).GetEnumerator();
-        }
+    /// <inheritdoc/>
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return ((IEnumerable)_elements).GetEnumerator();
     }
 }
diff --git a/src/TMG-Framework/Data/CategoryIndex.cs b/src/TMG-Framework/Data/CategoryIndex.cs
index f500047..517c495 100644
--- a/src/TMG-Framework/Data/CategoryIndex.cs
+++ b/src/TMG-Framework/Data/CategoryIndex.cs
@@ -16,107 +16,103 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Text;
 
-namespace TMG
+namespace TMG;
+
+/// <summary>
+/// Represents an index into an object of Categories.
+/// </summary>
+public readonly struct CategoryIndex : IEquatable<CategoryIndex>, IComparable<CategoryIndex>, IEqualityComparer<CategoryIndex>
 {
-    /// <summary>
-    /// Represents an index into an object of Categories.
-    /// </summary>
-    public readonly struct CategoryIndex : IEquatable<CategoryIndex>, IComparable<CategoryIndex>, IEqualityComparer<CategoryIndex>
-    {
-        private readonly int _Value;
+    private readonly int _Value;
 
-        public CategoryIndex(int value)
-        {
-            _Value = value;
-        }
+    public CategoryIndex(int value)
+    {
+        _Value = value;
+    }
 
-        /// <summary>
-        /// Test if the value is a valid reference to the category
-        /// </summary>
-        public bool Exists => _Value >= 0;
+    /// <summary>
+    /// Test if the value is a valid reference to the category
+    /// </summary>
+    public bool Exists => _Value >= 0;
 
-        public static implicit operator int(CategoryIndex index) => index._Value;
+    public static implicit operator int(CategoryIndex index) => index._Value;
 
-        public static implicit operator CategoryIndex(int index) => new(index);
+    public static implicit operator CategoryIndex(int index) => new(index);
 
-        public static bool TryParse(string s, out CategoryIndex result)
+    public static bool TryParse(string s, out CategoryIndex result)
+    {
+        if (!int.TryParse(s, out int temp))
         {
-            if (!int.TryParse(s, out int temp))
-            {
-                result = temp;
-                return true;
-            }
-            result = -1;
-            return false;
+            result = temp;
+            return true;
         }
+        result = -1;
+        return false;
+    }
 
-        public bool Equals(CategoryIndex x, CategoryIndex y)
-        {
-            return x._Value == y._Value;
-        }
+    public bool Equals(CategoryIndex x, CategoryIndex y)
+    {
+        return x._Value == y._Value;
+    }
 
-        public int GetHashCode([DisallowNull] CategoryIndex obj)
-        {
-            return obj._Value.GetHashCode();
-        }
+    public int GetHashCode([DisallowNull] CategoryIndex obj)
+    {
+        return obj._Value.GetHashCode();
+    }
 
-        public int CompareTo(CategoryIndex other)
-        {
-            return _Value.CompareTo(other._Value);
-        }
+    public int CompareTo(CategoryIndex other)
+    {
+        return _Value.CompareTo(other._Value);
+    }
 
-        public bool Equals(CategoryIndex other)
-        {
-            return _Value == other._Value;
-        }
+    public bool Equals(CategoryIndex other)
+    {
+        return _Value == other._Value;
+    }
 
-        public override bool Equals(object? obj)
+    public override bool Equals(object? obj)
+    {
+        if (obj is CategoryIndex other)
         {
-            if (obj is CategoryIndex other)
-            {
-                return Equals(other);
-            }
-            return false;
+            return Equals(other);
         }
+        return false;
+    }
 
-        public override int GetHashCode()
-        {
-            return _Value.GetHashCode();
-        }
+    public override int GetHashCode()
+    {
+        return _Value.GetHashCode();
+    }
 
-        public static bool operator ==(CategoryIndex left, CategoryIndex right)
-        {
-            return left._Value == right._Value;
-        }
+    public static bool operator ==(CategoryIndex left, CategoryIndex right)
+    {
+        return left._Value == right._Value;
+    }
 
-        public static bool operator !=(CategoryIndex left, CategoryIndex right)
-        {
-            return left._Value != right._Value;
-        }
+    public static bool operator !=(CategoryIndex left, CategoryIndex right)
+    {
+        return left._Value != right._Value;
+    }
 
-        public static bool operator <(CategoryIndex left, CategoryIndex right)
-        {
-            return left._Value < right._Value;
-        }
+    public static bool operator <(CategoryIndex left, CategoryIndex right)
+    {
+        return left._Value < right._Value;
+    }
 
-        public static bool operator <=(CategoryIndex left, CategoryIndex right)
-        {
-            return left._Value <= right._Value;
-        }
+    public static bool operator <=(CategoryIndex left, CategoryIndex right)
+    {
+        return left._Value <= right._Value;
+    }
 
-        public static bool operator >(CategoryIndex left, CategoryIndex right)
-        {
-            return left._Value > right._Value;
-        }
+    public static bool operator >(CategoryIndex left, CategoryIndex right)
+    {
+        return left._Value > right._Value;
+    }
 
-        public static bool operator >=(CategoryIndex left, CategoryIndex right)
-        {
-            return left._Value >= right._Value;
-        }
+    public static bool operator >=(CategoryIndex left, CategoryIndex right)
+    {
+        return left._Value >= right._Value;
     }
 }
+
diff --git a/src/TMG-Framework/Data/CategoryMap.cs b/src/TMG-Framework/Data/CategoryMap.cs
index cd96643..b725a54 100644
--- a/src/TMG-Framework/Data/CategoryMap.cs
+++ b/src/TMG-Framework/Data/CategoryMap.cs
@@ -16,174 +16,168 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
 using static TMG.Utilities.ExceptionHelper;
 
-namespace TMG
+namespace TMG;
+
+/// <summary>
+/// Provides a mapping between categories and provides a method for aggregating
+/// data from the base categories to the destination categories.
+/// </summary>
+public sealed class CategoryMap
 {
     /// <summary>
-    /// Provides a mapping between categories and provides a method for aggregating
-    /// data from the base categories to the destination categories.
+    /// The categories to start with.
+    /// </summary>
+    public Categories Base { get; }
+
+    /// <summary>
+    /// The categories to converge the base into.
+    /// </summary>
+    public Categories Destination { get; }
+
+    /// <summary>
+    /// The mapping between the two category types.
     /// </summary>
-    public sealed class CategoryMap
+    private readonly List<(int originFlatIndex, int destinationFlatIndex)> _baseToDestination;
+
+    public static bool CreateCategoryMap(Categories baseCategories, Categories destinationCategories,
+        List<(int originFlatIndex, int destinationFlatIndex)> baseToDestination,
+        [NotNullWhen(true)] out CategoryMap? map,
+        [NotNullWhen(false)] ref string? error)
     {
-        /// <summary>
-        /// The categories to start with.
-        /// </summary>
-        public Categories Base { get; }
-
-        /// <summary>
-        /// The categories to converge the base into.
-        /// </summary>
-        public Categories Destination { get; }
-
-        /// <summary>
-        /// The mapping between the two category types.
-        /// </summary>
-        private readonly List<(int originFlatIndex, int destinationFlatIndex)> _baseToDestination;
-
-        public static bool CreateCategoryMap(Categories baseCategories, Categories destinationCategories,
-            List<(int originFlatIndex, int destinationFlatIndex)> baseToDestination, 
-            [NotNullWhen(true) ] out CategoryMap? map,
-            [NotNullWhen(false)] ref string? error)
+        if (baseCategories == null)
         {
-            if (baseCategories == null)
-            {
-                ThrowParameterNull(nameof(baseCategories));
-            }
-            if (destinationCategories == null)
-            {
-                ThrowParameterNull(nameof(destinationCategories));
-            }
-            if (baseToDestination == null)
-            {
-                ThrowParameterNull(nameof(baseToDestination));
-            }
-            if (ValidateMapping(baseCategories, destinationCategories, baseToDestination, ref error))
-            {
-                map = new CategoryMap(baseCategories, destinationCategories, baseToDestination);
-                return true;
-            }
-            map = null;
-            return false;
+            ThrowParameterNull(nameof(baseCategories));
         }
-
-        /// <summary>
-        /// Given two categories create the mapping between the two.
-        /// </summary>
-        /// <param name="baseCategories">The larger set of categories.</param>
-        /// <param name="destinationCategories">The different set of categories the base will be mapped to.</param>
-        /// <param name="baseToDestination">The individual linking records from base to destination categories.</param>
-        private CategoryMap(Categories baseCategories, Categories destinationCategories,
-            List<(int originFlatIndex, int destinationFlatIndex)> baseToDestination)
+        if (destinationCategories == null)
         {
-            if (baseCategories == null)
-            {
-                ThrowParameterNull(nameof(baseCategories));
-            }
-            if (destinationCategories == null)
-            {
-                ThrowParameterNull(nameof(destinationCategories));
-            }
-            if (baseToDestination == null)
-            {
-                ThrowParameterNull(nameof(baseToDestination));
-            }
-            Base = baseCategories;
-            Destination = destinationCategories;
-            _baseToDestination = baseToDestination;
+            ThrowParameterNull(nameof(destinationCategories));
         }
-
-        private static bool FailWith([NotNullWhen(false)] ref string? error, string message)
+        if (baseToDestination == null)
         {
-            error = message;
-            return false;
+            ThrowParameterNull(nameof(baseToDestination));
         }
-
-        /// <summary>
-        /// Ensure that all of the indexes exist in the base and destination categories.
-        /// </summary>
-        /// <param name="baseToDestination"></param>
-        private static bool ValidateMapping(Categories baseCategories, Categories destinationCategories,
-            List<(int originFlatIndex, int destinationFlatIndex)> baseToDestination, 
-            [NotNullWhen(false)] ref string? error)
+        if (ValidateMapping(baseCategories, destinationCategories, baseToDestination, ref error))
         {
-            if (baseCategories == null)
-            {
-                return FailWith(ref error, "baseCategories was null!");
-            }
-            if (destinationCategories == null)
-            {
-                return FailWith(ref error, "destinationCategories was null!");
-            }
-            if (baseToDestination == null)
-            {
-                return FailWith(ref error, "baseToDestination was null!");
-            }
-            foreach (var (originFlatIndex, destinationFlatIndex) in baseToDestination)
-            {
-                if (originFlatIndex < 0 || originFlatIndex >= baseCategories.Count)
-                    return FailWith(ref error, $"The base categories does not contain a flat index of {originFlatIndex}!");
-                if (destinationFlatIndex < 0 || destinationFlatIndex >= destinationCategories.Count)
-                    return FailWith(ref error, $"The destination categories does not contain a flat index of {destinationFlatIndex}!");
-            }
+            map = new CategoryMap(baseCategories, destinationCategories, baseToDestination);
             return true;
         }
+        map = null;
+        return false;
+    }
 
-
-        /// <summary>
-        /// Aggregate the baseVector data into the destination category system.
-        /// </summary>
-        /// <param name="baseVector">The vector to aggregate</param>
-        /// <param name="ret"></param>
-        /// <param name="error"></param>
-        /// <returns></returns>
-        public bool AggregateToDestination(Vector baseVector, 
-            [NotNullWhen(true)] out Vector? ret,
-            [NotNullWhen(false)] ref string? error)
+    /// <summary>
+    /// Given two categories create the mapping between the two.
+    /// </summary>
+    /// <param name="baseCategories">The larger set of categories.</param>
+    /// <param name="destinationCategories">The different set of categories the base will be mapped to.</param>
+    /// <param name="baseToDestination">The individual linking records from base to destination categories.</param>
+    private CategoryMap(Categories baseCategories, Categories destinationCategories,
+        List<(int originFlatIndex, int destinationFlatIndex)> baseToDestination)
+    {
+        if (baseCategories == null)
         {
-            ret = null;
-            if (baseVector is null)
-            {
-                return FailWith(ref error, "baseVector was null!");
-            }
-            if (baseVector.Categories != Base)
-            {
-                return FailWith(ref error, "Invalid Base Categories");
-            }
-            ret = new Vector(Destination);
-            var b = baseVector.Data;
-            var r = ret.Data;
-            foreach (var (originFlatIndex, destinationFlatIndex) in _baseToDestination)
-            {
-                r[destinationFlatIndex] += b[originFlatIndex];
-            }
-            return true;
+            ThrowParameterNull(nameof(baseCategories));
+        }
+        if (destinationCategories == null)
+        {
+            ThrowParameterNull(nameof(destinationCategories));
+        }
+        if (baseToDestination == null)
+        {
+            ThrowParameterNull(nameof(baseToDestination));
         }
+        Base = baseCategories;
+        Destination = destinationCategories;
+        _baseToDestination = baseToDestination;
+    }
+
+    private static bool FailWith([NotNullWhen(false)] ref string? error, string message)
+    {
+        error = message;
+        return false;
+    }
 
-        /// <summary>
-        /// Creates a reverse index of destination category indexes relating them to the list of Base category indexes that they map.
-        /// </summary>
-        /// <returns>A reverse index dictionary mapping Destination elements to a list of base category indexes that represent them.</returns>
-        public Dictionary<CategoryIndex, List<CategoryIndex>> CreateReverseIndex()
+    /// <summary>
+    /// Ensure that all of the indexes exist in the base and destination categories.
+    /// </summary>
+    /// <param name="baseToDestination"></param>
+    private static bool ValidateMapping(Categories baseCategories, Categories destinationCategories,
+        List<(int originFlatIndex, int destinationFlatIndex)> baseToDestination,
+        [NotNullWhen(false)] ref string? error)
+    {
+        if (baseCategories == null)
+        {
+            return FailWith(ref error, "baseCategories was null!");
+        }
+        if (destinationCategories == null)
+        {
+            return FailWith(ref error, "destinationCategories was null!");
+        }
+        if (baseToDestination == null)
+        {
+            return FailWith(ref error, "baseToDestination was null!");
+        }
+        foreach (var (originFlatIndex, destinationFlatIndex) in baseToDestination)
         {
-            return _baseToDestination
-                .GroupBy(record => record.destinationFlatIndex)
-                .ToDictionary(group => (CategoryIndex)group.Key, group => group.Select(record => (CategoryIndex)record.originFlatIndex).ToList());
+            if (originFlatIndex < 0 || originFlatIndex >= baseCategories.Count)
+                return FailWith(ref error, $"The base categories does not contain a flat index of {originFlatIndex}!");
+            if (destinationFlatIndex < 0 || destinationFlatIndex >= destinationCategories.Count)
+                return FailWith(ref error, $"The destination categories does not contain a flat index of {destinationFlatIndex}!");
         }
+        return true;
+    }
+
 
-        /// <summary>
-        /// Creates an index of base category to destination category indexes.
-        /// </summary>
-        /// <returns>A dictionary containing the mapping between base CategoryIndex to destination CategoryIndex.</returns>
-        public Dictionary<CategoryIndex, CategoryIndex> CreateIndex()
+    /// <summary>
+    /// Aggregate the baseVector data into the destination category system.
+    /// </summary>
+    /// <param name="baseVector">The vector to aggregate</param>
+    /// <param name="ret"></param>
+    /// <param name="error"></param>
+    /// <returns></returns>
+    public bool AggregateToDestination(Vector baseVector,
+        [NotNullWhen(true)] out Vector? ret,
+        [NotNullWhen(false)] ref string? error)
+    {
+        ret = null;
+        if (baseVector is null)
+        {
+            return FailWith(ref error, "baseVector was null!");
+        }
+        if (baseVector.Categories != Base)
+        {
+            return FailWith(ref error, "Invalid Base Categories");
+        }
+        ret = new Vector(Destination);
+        var b = baseVector.Data;
+        var r = ret.Data;
+        foreach (var (originFlatIndex, destinationFlatIndex) in _baseToDestination)
         {
-            return _baseToDestination
-                .ToDictionary(record => (CategoryIndex)record.originFlatIndex, record => (CategoryIndex)record.destinationFlatIndex);
+            r[destinationFlatIndex] += b[originFlatIndex];
         }
+        return true;
+    }
+
+    /// <summary>
+    /// Creates a reverse index of destination category indexes relating them to the list of Base category indexes that they map.
+    /// </summary>
+    /// <returns>A reverse index dictionary mapping Destination elements to a list of base category indexes that represent them.</returns>
+    public Dictionary<CategoryIndex, List<CategoryIndex>> CreateReverseIndex()
+    {
+        return _baseToDestination
+            .GroupBy(record => record.destinationFlatIndex)
+            .ToDictionary(group => (CategoryIndex)group.Key, group => group.Select(record => (CategoryIndex)record.originFlatIndex).ToList());
+    }
+
+    /// <summary>
+    /// Creates an index of base category to destination category indexes.
+    /// </summary>
+    /// <returns>A dictionary containing the mapping between base CategoryIndex to destination CategoryIndex.</returns>
+    public Dictionary<CategoryIndex, CategoryIndex> CreateIndex()
+    {
+        return _baseToDestination
+            .ToDictionary(record => (CategoryIndex)record.originFlatIndex, record => (CategoryIndex)record.destinationFlatIndex);
     }
 }
diff --git a/src/TMG-Framework/Data/Matrix.cs b/src/TMG-Framework/Data/Matrix.cs
index bbe6923..a421160 100644
--- a/src/TMG-Framework/Data/Matrix.cs
+++ b/src/TMG-Framework/Data/Matrix.cs
@@ -16,245 +16,238 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
 using System.Buffers;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading;
 using static TMG.Utilities.ExceptionHelper;
 
-namespace TMG
+namespace TMG;
+
+/// <summary>
+/// A 2D representation with categories for rows and columns
+/// </summary>
+public sealed class Matrix : IDisposable
 {
     /// <summary>
-    /// A 2D representation with categories for rows and columns
+    /// The categories for the rows.
     /// </summary>
-    public sealed class Matrix : IDisposable
-    {
-        /// <summary>
-        /// The categories for the rows.
-        /// </summary>
-        public Categories RowCategories { get; }
+    public Categories RowCategories { get; }
 
-        /// <summary>
-        /// The categories for the columns.
-        /// </summary>
-        public Categories ColumnCategories { get; }
+    /// <summary>
+    /// The categories for the columns.
+    /// </summary>
+    public Categories ColumnCategories { get; }
 
-        /// <summary>
-        /// The backend storage for the matrix
-        /// </summary>
-        public Span<float> Data => _backingMemory is null ? ThrowAlreadyDisposed() : _backingMemory.Value.Span;
+    /// <summary>
+    /// The backend storage for the matrix
+    /// </summary>
+    public Span<float> Data => _backingMemory is null ? ThrowAlreadyDisposed() : _backingMemory.Value.Span;
 
-        [DoesNotReturn]
-        private Span<float> ThrowAlreadyDisposed()
-        {
-            throw new ObjectDisposedException(nameof(Matrix));
-        }
+    [DoesNotReturn]
+    private Span<float> ThrowAlreadyDisposed()
+    {
+        throw new ObjectDisposedException(nameof(Matrix));
+    }
 
-        private Memory<float>? _backingMemory;
+    private Memory<float>? _backingMemory;
 
-        /// <summary>
-        /// Used as a quick lookup for the number of columns per row.
-        /// </summary>
-        private readonly int _rowSpan;
+    /// <summary>
+    /// Used as a quick lookup for the number of columns per row.
+    /// </summary>
+    private readonly int _rowSpan;
 
-        private IMemoryOwner<float>? _allocator;
+    private IMemoryOwner<float>? _allocator;
 
-        /// <summary>
-        /// Create a new matrix with the given row and column categories.
-        /// </summary>
-        /// <param name="rowCategories">The categories for the rows.</param>
-        /// <param name="columnCategories">The categories for the columns.</param>
-        public Matrix(Categories rowCategories, Categories columnCategories) : this(rowCategories, columnCategories, null) { }
+    /// <summary>
+    /// Create a new matrix with the given row and column categories.
+    /// </summary>
+    /// <param name="rowCategories">The categories for the rows.</param>
+    /// <param name="columnCategories">The categories for the columns.</param>
+    public Matrix(Categories rowCategories, Categories columnCategories) : this(rowCategories, columnCategories, null) { }
 
-        /// <summary>
-        /// Get the number of columns in this matrix.
-        /// </summary>
-        public int NumberOfColumns => ColumnCategories.Count;
+    /// <summary>
+    /// Get the number of columns in this matrix.
+    /// </summary>
+    public int NumberOfColumns => ColumnCategories.Count;
 
-        /// <summary>
-        /// Get the number of rows in this matrix.
-        /// </summary>
-        public int NumberOfRows => RowCategories.Count;
+    /// <summary>
+    /// Get the number of rows in this matrix.
+    /// </summary>
+    public int NumberOfRows => RowCategories.Count;
 
-        /// <summary>
-        /// Create a new matrix with the given row and column categories.
-        /// </summary>
-        /// <param name="rowCategories">The categories for the rows.</param>
-        /// <param name="columnCategories">The categories for the columns.</param>
-        /// <param name="allocator">The memory pool to use for the matrix data.</param>
-        public Matrix(Categories rowCategories, Categories columnCategories, MemoryPool<float>? allocator)
-        {
-            RowCategories = rowCategories ?? ThrowParameterNull<Categories>(nameof(rowCategories));
-            ColumnCategories = columnCategories ?? ThrowParameterNull<Categories>(nameof(columnCategories));
-            _rowSpan = ColumnCategories.Count;
-            var size = RowCategories.Count * ColumnCategories.Count;
-            _backingMemory = allocator is null ? 
-                new float[size].AsMemory()
-                : (_allocator = allocator.Rent(size)).Memory[..size];
-        }
+    /// <summary>
+    /// Create a new matrix with the given row and column categories.
+    /// </summary>
+    /// <param name="rowCategories">The categories for the rows.</param>
+    /// <param name="columnCategories">The categories for the columns.</param>
+    /// <param name="allocator">The memory pool to use for the matrix data.</param>
+    public Matrix(Categories rowCategories, Categories columnCategories, MemoryPool<float>? allocator)
+    {
+        RowCategories = rowCategories ?? ThrowParameterNull<Categories>(nameof(rowCategories));
+        ColumnCategories = columnCategories ?? ThrowParameterNull<Categories>(nameof(columnCategories));
+        _rowSpan = ColumnCategories.Count;
+        var size = RowCategories.Count * ColumnCategories.Count;
+        _backingMemory = allocator is null ?
+            new float[size].AsMemory()
+            : (_allocator = allocator.Rent(size)).Memory[..size];
+    }
 
-        /// <summary>
-        /// Create a new matrix using the dimensions from the given vector.
-        /// </summary>
-        /// <param name="vector">The vector to get the dimensions from.</param>
-        public Matrix(Vector vector) : this(vector, null) { }
+    /// <summary>
+    /// Create a new matrix using the dimensions from the given vector.
+    /// </summary>
+    /// <param name="vector">The vector to get the dimensions from.</param>
+    public Matrix(Vector vector) : this(vector, null) { }
 
-        public Matrix(Vector vector, MemoryPool<float>? allocator)
+    public Matrix(Vector vector, MemoryPool<float>? allocator)
+    {
+        if (vector is null)
         {
-            if (vector is null)
-            {
-                ThrowParameterNull(nameof(vector));
-            }
-            ColumnCategories = RowCategories = vector.Categories;
-            _rowSpan = ColumnCategories.Count;
-            var size = RowCategories.Count * ColumnCategories.Count;
-            _backingMemory = allocator is null ?
-                new float[size].AsMemory() :
-                (_allocator = allocator.Rent(size)).Memory[..size];
+            ThrowParameterNull(nameof(vector));
         }
+        ColumnCategories = RowCategories = vector.Categories;
+        _rowSpan = ColumnCategories.Count;
+        var size = RowCategories.Count * ColumnCategories.Count;
+        _backingMemory = allocator is null ?
+            new float[size].AsMemory() :
+            (_allocator = allocator.Rent(size)).Memory[..size];
+    }
 
-        /// <summary>
-        /// Create a new matrix with the dimensions from the provided
-        /// matrix.
-        /// </summary>
-        /// <param name="matrix">The matrix to copy the dimensions from.</param>
-        public Matrix(Matrix matrix) : this(matrix, null) {}
-        
-        /// <summary>
-        /// Create a new matrix with the dimensions from the provided
-        /// </summary>
-        /// <param name="matrix">The matrix to copy the dimensions from.</param>
-        /// <param name="allocator">The memory pool to use for the matrix data.</param>
-        public Matrix(Matrix matrix, MemoryPool<float>? allocator)
-        {
-            if (matrix is null)
-            {
-                ThrowParameterNull(nameof(matrix));
-            }
-            RowCategories = matrix.RowCategories;
-            ColumnCategories = matrix.ColumnCategories;
-            _rowSpan = matrix._rowSpan;
-            var size = RowCategories.Count * ColumnCategories.Count;
-            _backingMemory = allocator is null ?
-                new float[size].AsMemory() :
-                (_allocator = allocator.Rent(size)).Memory[..size];
-        }
+    /// <summary>
+    /// Create a new matrix with the dimensions from the provided
+    /// matrix.
+    /// </summary>
+    /// <param name="matrix">The matrix to copy the dimensions from.</param>
+    public Matrix(Matrix matrix) : this(matrix, null) { }
 
-        /// <summary>
-        /// Get the row and column for a given flat index into the backend data
-        /// </summary>
-        /// <param name="flatIndex">The flat index in the data to get the sparse row and column for.</param>
-        /// <returns>The row and column in sparse space for this flat index.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-        public (CategoryIndex Row, CategoryIndex Column) GetSparseIndex(int flatIndex)
+    /// <summary>
+    /// Create a new matrix with the dimensions from the provided
+    /// </summary>
+    /// <param name="matrix">The matrix to copy the dimensions from.</param>
+    /// <param name="allocator">The memory pool to use for the matrix data.</param>
+    public Matrix(Matrix matrix, MemoryPool<float>? allocator)
+    {
+        if (matrix is null)
         {
-            return (RowCategories.GetSparseIndex(flatIndex / _rowSpan), RowCategories.GetSparseIndex(flatIndex % _rowSpan));
+            ThrowParameterNull(nameof(matrix));
         }
+        RowCategories = matrix.RowCategories;
+        ColumnCategories = matrix.ColumnCategories;
+        _rowSpan = matrix._rowSpan;
+        var size = RowCategories.Count * ColumnCategories.Count;
+        _backingMemory = allocator is null ?
+            new float[size].AsMemory() :
+            (_allocator = allocator.Rent(size)).Memory[..size];
+    }
 
-        /// <summary>
-        /// Get the index in data given the flat row and columns
-        /// </summary>
-        /// <param name="flatRow">The row to lookup</param>
-        /// <param name="flatColumn">The column to lookup</param>
-        /// <returns>The index in data for this data.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-        public int GetFlatIndex(int flatRow, int flatColumn)
-        {
-            return _rowSpan * flatRow + flatColumn;
-        }
+    /// <summary>
+    /// Get the row and column for a given flat index into the backend data
+    /// </summary>
+    /// <param name="flatIndex">The flat index in the data to get the sparse row and column for.</param>
+    /// <returns>The row and column in sparse space for this flat index.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public (CategoryIndex Row, CategoryIndex Column) GetSparseIndex(int flatIndex)
+    {
+        return (RowCategories.GetSparseIndex(flatIndex / _rowSpan), RowCategories.GetSparseIndex(flatIndex % _rowSpan));
+    }
 
-        /// <summary>
-        /// Get the index in the data for the starting point of a given row
-        /// </summary>
-        /// <param name="flatRow">The flat index of the row to get</param>
-        /// <returns></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-        public int GetFlatRowIndex(int flatRow)
-        {
-            return _rowSpan * flatRow;
-        }
+    /// <summary>
+    /// Get the index in data given the flat row and columns
+    /// </summary>
+    /// <param name="flatRow">The row to lookup</param>
+    /// <param name="flatColumn">The column to lookup</param>
+    /// <returns>The index in data for this data.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public int GetFlatIndex(int flatRow, int flatColumn)
+    {
+        return _rowSpan * flatRow + flatColumn;
+    }
 
-        /// <summary>
-        /// Get the index int he data for the starting point given a sparse row
-        /// </summary>
-        /// <param name="sparseRow">The sparse row index to lookup</param>
-        /// <returns>The index in data for the start of this row</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-        public int GetSparseRowIndex(CategoryIndex sparseRow)
-        {
-            var index = RowCategories.GetFlatIndex(sparseRow);
-            return index >= 0 ? index * _rowSpan : -1;
-        }
+    /// <summary>
+    /// Get the index in the data for the starting point of a given row
+    /// </summary>
+    /// <param name="flatRow">The flat index of the row to get</param>
+    /// <returns></returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public int GetFlatRowIndex(int flatRow)
+    {
+        return _rowSpan * flatRow;
+    }
 
-        /// <summary>
-        /// Get a reference to a row in the matrix.
-        /// </summary>
-        /// <param name="flatRowIndex">The 0 indexed row number to get access to.</param>
-        /// <returns>A reference to the row.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-        public Span<float> GetRow(int flatRowIndex)
-        {
-            if ((flatRowIndex < 0) | (flatRowIndex > RowCategories.Count))
-            {
-                ThrowOutOfRangeException(nameof(flatRowIndex));
-            }
-            flatRowIndex = GetFlatRowIndex(flatRowIndex);
-            return Data.Slice(flatRowIndex, _rowSpan);
-        }
+    /// <summary>
+    /// Get the index int he data for the starting point given a sparse row
+    /// </summary>
+    /// <param name="sparseRow">The sparse row index to lookup</param>
+    /// <returns>The index in data for the start of this row</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public int GetSparseRowIndex(CategoryIndex sparseRow)
+    {
+        var index = RowCategories.GetFlatIndex(sparseRow);
+        return index >= 0 ? index * _rowSpan : -1;
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-        public ref float GetFromSparseIndexes(int rowIndex, int columnIndex)
+    /// <summary>
+    /// Get a reference to a row in the matrix.
+    /// </summary>
+    /// <param name="flatRowIndex">The 0 indexed row number to get access to.</param>
+    /// <returns>A reference to the row.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public Span<float> GetRow(int flatRowIndex)
+    {
+        if ((flatRowIndex < 0) | (flatRowIndex > RowCategories.Count))
         {
-            var o = RowCategories.GetFlatIndex(rowIndex);
-            var d = ColumnCategories.GetFlatIndex(columnIndex);
-            if(o < 0)
-            {
-                InvalidRow(rowIndex);
-            }
-            if(d < 0)
-            {
-                InvalidColumns(columnIndex);
-            }
-            return ref Data[GetFlatIndex(o,d)];
+            ThrowOutOfRangeException(nameof(flatRowIndex));
         }
+        flatRowIndex = GetFlatRowIndex(flatRowIndex);
+        return Data.Slice(flatRowIndex, _rowSpan);
+    }
 
-        /// <summary>
-        /// Create a copy of this matrix.
-        /// </summary>
-        /// <returns>Creates a deep copy of the matrix.</returns>
-        public Matrix Clone()
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public ref float GetFromSparseIndexes(int rowIndex, int columnIndex)
+    {
+        var o = RowCategories.GetFlatIndex(rowIndex);
+        var d = ColumnCategories.GetFlatIndex(columnIndex);
+        if (o < 0)
         {
-            var ret = new Matrix(this);
-            Data.CopyTo(ret.Data);
-            return ret;
+            InvalidRow(rowIndex);
         }
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private void InvalidColumns(int columnIndex)
+        if (d < 0)
         {
-            throw new ArgumentOutOfRangeException($"Invalid column index {columnIndex}!");
+            InvalidColumns(columnIndex);
         }
+        return ref Data[GetFlatIndex(o, d)];
+    }
 
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private void InvalidRow(int rowIndex)
-        {
-            throw new ArgumentOutOfRangeException($"Invalid row index {rowIndex}!");
-        }
+    /// <summary>
+    /// Create a copy of this matrix.
+    /// </summary>
+    /// <returns>Creates a deep copy of the matrix.</returns>
+    public Matrix Clone()
+    {
+        var ret = new Matrix(this);
+        Data.CopyTo(ret.Data);
+        return ret;
+    }
 
-        ~Matrix()
-        {
-            Dispose();
-        }
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void InvalidColumns(int columnIndex)
+    {
+        throw new ArgumentOutOfRangeException($"Invalid column index {columnIndex}!");
+    }
 
-        public void Dispose()
-        {
-            _backingMemory = null;
-            Thread.MemoryBarrier();
-            _allocator?.Dispose();
-            _allocator = null;
-        }
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void InvalidRow(int rowIndex)
+    {
+        throw new ArgumentOutOfRangeException($"Invalid row index {rowIndex}!");
+    }
+
+    ~Matrix()
+    {
+        Dispose();
+    }
+
+    public void Dispose()
+    {
+        _backingMemory = null;
+        Thread.MemoryBarrier();
+        _allocator?.Dispose();
+        _allocator = null;
     }
 }
diff --git a/src/TMG-Framework/Data/Range.cs b/src/TMG-Framework/Data/Range.cs
index a24e783..269180f 100644
--- a/src/TMG-Framework/Data/Range.cs
+++ b/src/TMG-Framework/Data/Range.cs
@@ -16,109 +16,106 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
 
-namespace TMG
+namespace TMG;
+
+public readonly struct Range
 {
-    public readonly struct Range
-    {
-        public readonly int Start;
-        public readonly int Stop;
+    public readonly int Start;
+    public readonly int Stop;
 
-        public Range(int start, int stop)
-        {
-            Start = start;
-            Stop = stop;
-        }
+    public Range(int start, int stop)
+    {
+        Start = start;
+        Stop = stop;
+    }
 
-        public static bool operator !=(Range first, Range other)
-        {
-            return (first.Start != other.Start) | (first.Stop != other.Stop);
-        }
+    public static bool operator !=(Range first, Range other)
+    {
+        return (first.Start != other.Start) | (first.Stop != other.Stop);
+    }
 
-        public static bool operator ==(Range first, Range other)
-        {
-            return (first.Start == other.Start) & (first.Stop == other.Stop);
-        }
+    public static bool operator ==(Range first, Range other)
+    {
+        return (first.Start == other.Start) & (first.Stop == other.Stop);
+    }
 
-        public override bool Equals(object? obj)
+    public override bool Equals(object? obj)
+    {
+        if (obj is Range other)
         {
-            if (obj is Range other)
-            {
-                return this == other;
-            }
-            return false;
+            return this == other;
         }
+        return false;
+    }
 
-        public override int GetHashCode()
-        {
-            return Start.GetHashCode() * Stop.GetHashCode();
-        }
+    public override int GetHashCode()
+    {
+        return Start.GetHashCode() * Stop.GetHashCode();
+    }
 
-        /// <summary>
-        /// Checks if a given value is inside the range defined by [Start, Stop)
-        /// </summary>
-        /// <param name="i"> The int value to check.</param>
-        /// <returns>True IFF i is greater than or equal to Start and i is less than Stop.</returns>
-        public bool Contains(int i)
-        {
-            return (i >= Start) & (i < Stop);
-        }
+    /// <summary>
+    /// Checks if a given value is inside the range defined by [Start, Stop)
+    /// </summary>
+    /// <param name="i"> The int value to check.</param>
+    /// <returns>True IFF i is greater than or equal to Start and i is less than Stop.</returns>
+    public bool Contains(int i)
+    {
+        return (i >= Start) & (i < Stop);
+    }
 
-        /// <summary>
-        /// Checks if a given value is inside the range defined by (Start, Stop)
-        /// </summary>
-        /// <param name="i">The int value to check</param>
-        /// <returns>True IFF i is less than Start and i is less than Stop.</returns>
-        public bool ContainsExcusive(int i)
-        {
-            return (i > Start) & (i < Stop);
-        }
+    /// <summary>
+    /// Checks if a given value is inside the range defined by (Start, Stop)
+    /// </summary>
+    /// <param name="i">The int value to check</param>
+    /// <returns>True IFF i is less than Start and i is less than Stop.</returns>
+    public bool ContainsExcusive(int i)
+    {
+        return (i > Start) & (i < Stop);
+    }
 
-        /// <summary>
-        /// Checks if a given value is inside the range defined by (Start, Stop)
-        /// </summary>
-        /// <param name="valueToFind">The value to check for</param>
-        /// <returns>True if the value is contained within the range</returns>
-        public bool ContainsExcusive(float valueToFind)
-        {
-            return (valueToFind > Start) & (valueToFind < Stop);
-        }
+    /// <summary>
+    /// Checks if a given value is inside the range defined by (Start, Stop)
+    /// </summary>
+    /// <param name="valueToFind">The value to check for</param>
+    /// <returns>True if the value is contained within the range</returns>
+    public bool ContainsExcusive(float valueToFind)
+    {
+        return (valueToFind > Start) & (valueToFind < Stop);
+    }
 
-        /// <summary>
-        /// Checks if a given value is inside the range defined by [Start, Stop]
-        /// </summary>
-        /// <param name="i">The int value to check</param>
-        /// <returns>True IFF i is greater than or equal to Start and i is less than or equal to Stop.</returns>
-        public bool ContainsInclusive(int i)
-        {
-            return (i >= Start) & (i <= Stop);
-        }
+    /// <summary>
+    /// Checks if a given value is inside the range defined by [Start, Stop]
+    /// </summary>
+    /// <param name="i">The int value to check</param>
+    /// <returns>True IFF i is greater than or equal to Start and i is less than or equal to Stop.</returns>
+    public bool ContainsInclusive(int i)
+    {
+        return (i >= Start) & (i <= Stop);
+    }
 
-        /// <summary>
-        /// Checks if a given value is inside the range defined by [Start, Stop]
-        /// </summary>
-        /// <param name="valueToFind">The value to check for</param>
-        /// <returns>True if the value is contained within the range</returns>
-        public bool ContainsInclusive(float valueToFind)
-        {
-            return (valueToFind >= Start) & (valueToFind <= Stop);
-        }
+    /// <summary>
+    /// Checks if a given value is inside the range defined by [Start, Stop]
+    /// </summary>
+    /// <param name="valueToFind">The value to check for</param>
+    /// <returns>True if the value is contained within the range</returns>
+    public bool ContainsInclusive(float valueToFind)
+    {
+        return (valueToFind >= Start) & (valueToFind <= Stop);
+    }
 
-        /// <summary>
-        /// Checks if another Range overlaps this one.
-        /// </summary>
-        /// <param name="other">The other range to check against.</param>
-        /// <returns></returns>
-        public bool Overlaps(Range other)
-        {
-            return ContainsInclusive(other.Start) || ContainsInclusive(other.Stop);
-        }
+    /// <summary>
+    /// Checks if another Range overlaps this one.
+    /// </summary>
+    /// <param name="other">The other range to check against.</param>
+    /// <returns></returns>
+    public bool Overlaps(Range other)
+    {
+        return ContainsInclusive(other.Start) || ContainsInclusive(other.Stop);
+    }
 
-        public override string ToString()
-        {
-            return String.Format("{0}-{1}", Start, Stop);
-        }
+    public override string ToString()
+    {
+        return String.Format("{0}-{1}", Start, Stop);
     }
-}
\ No newline at end of file
+}
diff --git a/src/TMG-Framework/Data/RangeSet.cs b/src/TMG-Framework/Data/RangeSet.cs
index 1d5aaee..c2f98c0 100644
--- a/src/TMG-Framework/Data/RangeSet.cs
+++ b/src/TMG-Framework/Data/RangeSet.cs
@@ -16,365 +16,360 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Text;
 using static System.Char;
 using static System.String;
 using static TMG.Utilities.ExceptionHelper;
 
-namespace TMG
+namespace TMG;
+
+public sealed class RangeSet : IList<Range>
 {
-    public sealed class RangeSet : IList<Range>
+    private readonly Range[] SetRanges;
+
+    public RangeSet(List<Range> tempRange)
     {
-        private readonly Range[] SetRanges;
+        SetRanges = tempRange.ToArray();
+    }
 
-        public RangeSet(List<Range> tempRange)
+    /// <summary>
+    /// Creates a new RangeSet with inclusive values from the given integer set
+    /// </summary>
+    /// <param name="numbers">The numbers to use to generate the ranges</param>
+    public RangeSet(IList<int> numbers)
+    {
+        if (numbers == null)
         {
-            SetRanges = tempRange.ToArray();
+            ThrowParameterNull(nameof(numbers));
         }
-
-        /// <summary>
-        /// Creates a new RangeSet with inclusive values from the given integer set
-        /// </summary>
-        /// <param name="numbers">The numbers to use to generate the ranges</param>
-        public RangeSet(IList<int> numbers)
+        var array = new int[numbers.Count];
+        numbers.CopyTo(array, 0);
+        Array.Sort(array);
+        var tempRange = new List<Range>();
+        var start = 0;
+        for (var i = 1; i < array.Length; i++)
         {
-            if (numbers == null)
-            {
-                ThrowParameterNull(nameof(numbers));
-            }
-            var array = new int[numbers.Count];
-            numbers.CopyTo(array, 0);
-            Array.Sort(array);
-            var tempRange = new List<Range>();
-            var start = 0;
-            for (var i = 1; i < array.Length; i++)
+            if (array[i] > array[i - 1] + 1)
             {
-                if (array[i] > array[i - 1] + 1)
-                {
-                    tempRange.Add(new Range(array[start], array[i - 1]));
-                    start = i;
-                }
+                tempRange.Add(new Range(array[start], array[i - 1]));
+                start = i;
             }
-            // and in the end
-            tempRange.Add(new Range(array[start], array[array.Length - 1]));
-            SetRanges = tempRange.ToArray();
         }
+        // and in the end
+        tempRange.Add(new Range(array[start], array[array.Length - 1]));
+        SetRanges = tempRange.ToArray();
+    }
 
-        public int Count => SetRanges.Length;
+    public int Count => SetRanges.Length;
 
-        public bool IsReadOnly => false;
+    public bool IsReadOnly => false;
 
-        public Range this[int index]
-        {
-            get => SetRanges[index];
-            set => SetRanges[index] = value;
-        }
+    public Range this[int index]
+    {
+        get => SetRanges[index];
+        set => SetRanges[index] = value;
+    }
 
-        public static bool TryParse(string rangeString, [NotNullWhen(true)] out RangeSet? output)
+    public static bool TryParse(string rangeString, [NotNullWhen(true)] out RangeSet? output)
+    {
+        string? error = null;
+        return TryParse(ref error, rangeString, out output);
+    }
+
+    public static bool TryParse([NotNullWhen(false)] ref string? error,
+        string rangeString,
+        [NotNullWhen(true)] out RangeSet? output)
+    {
+        var tempRange = new List<Range>();
+        var length = rangeString.Length;
+        var str = rangeString.ToCharArray();
+        var index = 0;
+        var start = 0;
+        var end = 0;
+        output = null;
+        //Phase == 0 -> index
+        //Phase == 1 -> start
+        //Phase == 2 -> end
+        var phase = 0;
+        var lastPlus = false;
+        var tallyingInZero = false;
+        if (IsNullOrWhiteSpace(rangeString))
         {
-            string? error = null;
-            return TryParse(ref error, rangeString, out output);
+            output = new RangeSet(tempRange);
+            return true;
         }
-
-        public static bool TryParse([NotNullWhen(false)] ref string? error,
-            string rangeString,
-            [NotNullWhen(true)] out RangeSet? output)
+        for (var i = 0; i < length; i++)
         {
-            var tempRange = new List<Range>();
-            var length = rangeString.Length;
-            var str = rangeString.ToCharArray();
-            var index = 0;
-            var start = 0;
-            var end = 0;
-            output = null;
-            //Phase == 0 -> index
-            //Phase == 1 -> start
-            //Phase == 2 -> end
-            var phase = 0;
-            var lastPlus = false;
-            var tallyingInZero = false;
-            if (IsNullOrWhiteSpace(rangeString))
-            {
-                output = new RangeSet(tempRange);
-                return true;
-            }
-            for (var i = 0; i < length; i++)
+            var c = str[i];
+            if (IsWhiteSpace(c) || IsLetter(c)) continue;
+            lastPlus = false;
+            switch (phase)
             {
-                var c = str[i];
-                if (IsWhiteSpace(c) || IsLetter(c)) continue;
-                lastPlus = false;
-                switch (phase)
-                {
-                    case 0:
-                        if (IsNumber(c))
+                case 0:
+                    if (IsNumber(c))
+                    {
+                        index = ((index << 3) + (index << 1)) + (c - '0');
+                        tallyingInZero = true;
+                    }
+                    else switch (c)
                         {
-                            index = ((index << 3) + (index << 1)) + (c - '0');
-                            tallyingInZero = true;
-                        }
-                        else switch (c)
-                            {
-                                case ',':
-                                    tempRange.Add(new Range(index, index));
-                                    index = 0;
-                                    start = 0;
-                                    end = 0;
-                                    break;
-                                case '-':
-                                    if (!tallyingInZero)
-                                    {
-                                        error = "No number was inserted before a range!";
-                                        return false;
-                                    }
-                                    start = index;
-                                    end = 0;
-                                    phase = 2;
-                                    break;
-                                case '+':
-                                    if (!tallyingInZero)
-                                    {
-                                        error = "No number was inserted before a range!";
-                                        return false;
-                                    }
-                                    end = int.MaxValue;
-                                    tempRange.Add(new Range(start, end));
-                                    index = 0;
-                                    start = 0;
-                                    phase = 0;
-                                    tallyingInZero = false;
-                                    lastPlus = true;
-                                    break;
-                                default:
-                                    error = "Unrecognized symbol " + c;
+                            case ',':
+                                tempRange.Add(new Range(index, index));
+                                index = 0;
+                                start = 0;
+                                end = 0;
+                                break;
+                            case '-':
+                                if (!tallyingInZero)
+                                {
+                                    error = "No number was inserted before a range!";
                                     return false;
-                            }
-                        break;
-                    case 1:
-                        if (IsNumber(c))
-                        {
-                            start = ((start << 3) + (start << 1)) + (c - '0');
-                        }
-                        else switch (c)
-                            {
-                                case '+':
-                                    end = int.MaxValue;
-                                    tempRange.Add(new Range(start, end));
-                                    index = 0;
-                                    start = 0;
-                                    phase = 0;
-                                    tallyingInZero = false;
-                                    lastPlus = true;
-                                    break;
-                                case '-':
-                                    end = 0;
-                                    phase = 2;
-                                    break;
-                            }
-                        break;
-                    case 2:
-                        if (IsNumber(c))
-                        {
-                            end = ((end << 3) + (end << 1)) + (c - '0');
+                                }
+                                start = index;
+                                end = 0;
+                                phase = 2;
+                                break;
+                            case '+':
+                                if (!tallyingInZero)
+                                {
+                                    error = "No number was inserted before a range!";
+                                    return false;
+                                }
+                                end = int.MaxValue;
+                                tempRange.Add(new Range(start, end));
+                                index = 0;
+                                start = 0;
+                                phase = 0;
+                                tallyingInZero = false;
+                                lastPlus = true;
+                                break;
+                            default:
+                                error = "Unrecognized symbol " + c;
+                                return false;
                         }
-                        else if (c == ',')
+                    break;
+                case 1:
+                    if (IsNumber(c))
+                    {
+                        start = ((start << 3) + (start << 1)) + (c - '0');
+                    }
+                    else switch (c)
                         {
-                            tempRange.Add(new Range(start, end));
-                            index = 0;
-                            phase = 0;
-                            start = 0;
-                            end = 0;
-                            tallyingInZero = false;
+                            case '+':
+                                end = int.MaxValue;
+                                tempRange.Add(new Range(start, end));
+                                index = 0;
+                                start = 0;
+                                phase = 0;
+                                tallyingInZero = false;
+                                lastPlus = true;
+                                break;
+                            case '-':
+                                end = 0;
+                                phase = 2;
+                                break;
                         }
-                        break;
-                }
-            }
-            if (phase == 2)
-            {
-                tempRange.Add(new Range(start, end));
-            }
-            else if (phase == 0 && tallyingInZero)
-            {
-                tempRange.Add(new Range(index, index));
-            }
-            else if (!lastPlus)
-            {
-                error = "Ended while reading a " + (phase == 0 ? "range's index!" : "range's start value!");
-                return false;
+                    break;
+                case 2:
+                    if (IsNumber(c))
+                    {
+                        end = ((end << 3) + (end << 1)) + (c - '0');
+                    }
+                    else if (c == ',')
+                    {
+                        tempRange.Add(new Range(start, end));
+                        index = 0;
+                        phase = 0;
+                        start = 0;
+                        end = 0;
+                        tallyingInZero = false;
+                    }
+                    break;
             }
-            output = new RangeSet(tempRange);
-            return true;
         }
+        if (phase == 2)
+        {
+            tempRange.Add(new Range(start, end));
+        }
+        else if (phase == 0 && tallyingInZero)
+        {
+            tempRange.Add(new Range(index, index));
+        }
+        else if (!lastPlus)
+        {
+            error = "Ended while reading a " + (phase == 0 ? "range's index!" : "range's start value!");
+            return false;
+        }
+        output = new RangeSet(tempRange);
+        return true;
+    }
 
-        public void Add(Range item) => throw new InvalidOperationException("Unable to add items");
+    public void Add(Range item) => throw new InvalidOperationException("Unable to add items");
 
-        public void Clear() => throw new InvalidOperationException("Unable to remove items");
+    public void Clear() => throw new InvalidOperationException("Unable to remove items");
 
-        public bool Contains(Range item) => IndexOf(item) != -1;
+    public bool Contains(Range item) => IndexOf(item) != -1;
 
-        public bool Contains(float value) => IndexOf(value) != -1;
+    public bool Contains(float value) => IndexOf(value) != -1;
 
-        public bool Contains(int number)
+    public bool Contains(int number)
+    {
+        for (var i = 0; i < SetRanges.Length; i++)
         {
-            for (var i = 0; i < SetRanges.Length; i++)
+            if ((number >= SetRanges[i].Start) && (number <= SetRanges[i].Stop))
             {
-                if ((number >= SetRanges[i].Start) && (number <= SetRanges[i].Stop))
-                {
-                    return true;
-                }
+                return true;
             }
-            return false;
         }
+        return false;
+    }
 
-        public void CopyTo(Range[] array, int arrayIndex)
+    public void CopyTo(Range[] array, int arrayIndex)
+    {
+        for (var i = 0; i < SetRanges.Length; i++)
         {
-            for (var i = 0; i < SetRanges.Length; i++)
-            {
-                array[arrayIndex + i] = SetRanges[i];
-            }
+            array[arrayIndex + i] = SetRanges[i];
         }
+    }
 
-        public override bool Equals(object? obj)
+    public override bool Equals(object? obj)
+    {
+        var other = obj as RangeSet;
+        if (other?.Count != Count) return false;
+        for (var i = 0; i < SetRanges.Length; i++)
         {
-            var other = obj as RangeSet;
-            if (other?.Count != Count) return false;
-            for (var i = 0; i < SetRanges.Length; i++)
+            if (!(SetRanges[i] == other[i]))
             {
-                if (!(SetRanges[i] == other[i]))
-                {
-                    return false;
-                }
+                return false;
             }
-            return true;
         }
+        return true;
+    }
 
-        public IEnumerator<Range> GetEnumerator() => ((ICollection<Range>)SetRanges).GetEnumerator();
+    public IEnumerator<Range> GetEnumerator() => ((ICollection<Range>)SetRanges).GetEnumerator();
 
-        public override int GetHashCode()
+    public override int GetHashCode()
+    {
+        var hash = 0;
+        for (var i = 0; i < SetRanges.Length; i++)
         {
-            var hash = 0;
-            for (var i = 0; i < SetRanges.Length; i++)
-            {
-                hash += SetRanges.GetHashCode();
-            }
-            return hash;
+            hash += SetRanges.GetHashCode();
         }
+        return hash;
+    }
 
-        public int IndexOf(Range item)
+    public int IndexOf(Range item)
+    {
+        for (var i = 0; i < SetRanges.Length; i++)
         {
-            for (var i = 0; i < SetRanges.Length; i++)
+            if (SetRanges[i] == item)
             {
-                if (SetRanges[i] == item)
-                {
-                    return i;
-                }
+                return i;
             }
-            return -1;
         }
+        return -1;
+    }
 
-        /// <summary>
-        /// Gives the index in the range set where this integer is first contained.
-        /// </summary>
-        /// <param name="integerToFind">The integer to find</param>
-        /// <returns>-1 if not found, otherwise the index of the Range in the rangeset that first contains this integer</returns>
-        public int IndexOf(int integerToFind)
+    /// <summary>
+    /// Gives the index in the range set where this integer is first contained.
+    /// </summary>
+    /// <param name="integerToFind">The integer to find</param>
+    /// <returns>-1 if not found, otherwise the index of the Range in the rangeset that first contains this integer</returns>
+    public int IndexOf(int integerToFind)
+    {
+        for (var i = 0; i < SetRanges.Length; i++)
         {
-            for (var i = 0; i < SetRanges.Length; i++)
+            if (SetRanges[i].ContainsInclusive(integerToFind))
             {
-                if (SetRanges[i].ContainsInclusive(integerToFind))
-                {
-                    return i;
-                }
+                return i;
             }
-            return -1;
         }
+        return -1;
+    }
 
-        /// <summary>
-        /// Gives the index in the range set where this integer is first contained.
-        /// </summary>
-        /// <param name="valueToFind">The floating point value to find.</param>
-        /// <returns>The index of the range that contains the value, -1 otherwise.</returns>
-        public int IndexOf(float valueToFind)
+    /// <summary>
+    /// Gives the index in the range set where this integer is first contained.
+    /// </summary>
+    /// <param name="valueToFind">The floating point value to find.</param>
+    /// <returns>The index of the range that contains the value, -1 otherwise.</returns>
+    public int IndexOf(float valueToFind)
+    {
+        for (var i = 0; i < SetRanges.Length; i++)
         {
-            for (var i = 0; i < SetRanges.Length; i++)
+            if (SetRanges[i].ContainsInclusive(valueToFind))
             {
-                if (SetRanges[i].ContainsInclusive(valueToFind))
-                {
-                    return i;
-                }
+                return i;
             }
-            return -1;
         }
+        return -1;
+    }
 
-        public void Insert(int index, Range item)
-        {
-            this[index] = item;
-        }
+    public void Insert(int index, Range item)
+    {
+        this[index] = item;
+    }
 
-        public bool Overlaps(Range other)
+    public bool Overlaps(Range other)
+    {
+        for (var i = 0; i < SetRanges.Length; i++)
         {
-            for (var i = 0; i < SetRanges.Length; i++)
+            if (SetRanges[i].Contains(other.Start) || SetRanges[i].Contains(other.Stop))
             {
-                if (SetRanges[i].Contains(other.Start) || SetRanges[i].Contains(other.Stop))
-                {
-                    return true;
-                }
+                return true;
             }
-            return false;
         }
+        return false;
+    }
 
-        public bool Overlaps(RangeSet other)
+    public bool Overlaps(RangeSet other)
+    {
+        for (var i = 0; i < SetRanges.Length; i++)
         {
-            for (var i = 0; i < SetRanges.Length; i++)
+            for (var j = 0; j < other.SetRanges.Length; j++)
             {
-                for (var j = 0; j < other.SetRanges.Length; j++)
+                if (SetRanges[i].Contains(other.SetRanges[j].Start) || SetRanges[i].Contains(other.SetRanges[j].Stop))
                 {
-                    if (SetRanges[i].Contains(other.SetRanges[j].Start) || SetRanges[i].Contains(other.SetRanges[j].Stop))
-                    {
-                        return true;
-                    }
+                    return true;
                 }
             }
-            return false;
         }
+        return false;
+    }
 
-        public bool Remove(Range item) => throw new InvalidOperationException("Unable to remove items");
+    public bool Remove(Range item) => throw new InvalidOperationException("Unable to remove items");
 
-        public void RemoveAt(int index) => throw new InvalidOperationException("Unable to remove items");
+    public void RemoveAt(int index) => throw new InvalidOperationException("Unable to remove items");
 
-        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => SetRanges.GetEnumerator();
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => SetRanges.GetEnumerator();
 
-        public override string ToString()
+    public override string ToString()
+    {
+        var builder = new StringBuilder();
+        var first = true;
+        if (SetRanges.Length == 0)
         {
-            var builder = new StringBuilder();
-            var first = true;
-            if (SetRanges.Length == 0)
-            {
-                // do nothing we already have a blank builder
-            }
-            else
+            // do nothing we already have a blank builder
+        }
+        else
+        {
+            foreach (var res in SetRanges)
             {
-                foreach (var res in SetRanges)
+                if (!first)
                 {
-                    if (!first)
-                    {
-                        builder.Append(',');
-                    }
-                    if (res.Start != res.Stop)
-                    {
-                        builder.Append(res.Start);
-                        builder.Append('-');
-                        builder.Append(res.Stop);
-                    }
-                    else
-                    {
-                        builder.Append(res.Start);
-                    }
-                    first = false;
+                    builder.Append(',');
+                }
+                if (res.Start != res.Stop)
+                {
+                    builder.Append(res.Start);
+                    builder.Append('-');
+                    builder.Append(res.Stop);
+                }
+                else
+                {
+                    builder.Append(res.Start);
                 }
+                first = false;
             }
-            return builder.ToString();
         }
+        return builder.ToString();
     }
-}
\ No newline at end of file
+}
diff --git a/src/TMG-Framework/Data/RangeSetSet.cs b/src/TMG-Framework/Data/RangeSetSet.cs
index c99094a..336b556 100644
--- a/src/TMG-Framework/Data/RangeSetSet.cs
+++ b/src/TMG-Framework/Data/RangeSetSet.cs
@@ -16,227 +16,222 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Text;
 using static TMG.Utilities.ExceptionHelper;
 
-namespace TMG
+namespace TMG;
+
+public sealed class RangeSetSet : IList<RangeSet>
 {
-    public sealed class RangeSetSet : IList<RangeSet>
+    private readonly RangeSet[] RangeSets;
+
+    public RangeSetSet(List<RangeSet> tempRange)
     {
-        private readonly RangeSet[] RangeSets;
+        RangeSets = tempRange.ToArray();
+    }
 
-        public RangeSetSet(List<RangeSet> tempRange)
-        {
-            RangeSets = tempRange.ToArray();
-        }
+    public int Count => RangeSets.Length;
 
-        public int Count => RangeSets.Length;
+    public bool IsReadOnly => false;
 
-        public bool IsReadOnly => false;
+    public RangeSet this[int index]
+    {
+        get => RangeSets[index];
+        set => RangeSets[index] = value;
+    }
 
-        public RangeSet this[int index]
-        {
-            get => RangeSets[index];
-            set => RangeSets[index] = value;
-        }
+    public static bool TryParse(string rangeString, [NotNullWhen(true)] out RangeSetSet? output)
+    {
+        string? error = null;
+        return TryParse(ref error, rangeString, out output);
+    }
 
-        public static bool TryParse(string rangeString, [NotNullWhen(true)] out RangeSetSet? output)
+    public static bool TryParse([NotNullWhen(false)] ref string? error,
+        string rangeString,
+        [NotNullWhen(true)] out RangeSetSet? output)
+    {
+        if (rangeString == null)
         {
-            string? error = null;
-            return TryParse(ref error, rangeString, out output);
+            ThrowParameterNull(nameof(rangeString));
         }
 
-        public static bool TryParse([NotNullWhen(false)] ref string? error,
-            string rangeString,
-            [NotNullWhen(true)] out RangeSetSet? output)
+        var rangeSets = new List<RangeSet>();
+        output = null;
+        var strLength = rangeString.Length;
+        int startPos;
+        for (startPos = 0; startPos < strLength; startPos++)
         {
-            if (rangeString == null)
-            {
-                ThrowParameterNull(nameof(rangeString));
-            }
-
-            var rangeSets = new List<RangeSet>();
-            output = null;
-            var strLength = rangeString.Length;
-            int startPos;
-            for (startPos = 0; startPos < strLength; startPos++)
+            if (rangeString[startPos] == '{')
             {
-                if (rangeString[startPos] == '{')
+                var success = false;
+                for (var endPos = startPos + 1; endPos < strLength; endPos++)
                 {
-                    var success = false;
-                    for (var endPos = startPos + 1; endPos < strLength; endPos++)
+                    if (rangeString[endPos] == '}')
                     {
-                        if (rangeString[endPos] == '}')
+                        if (!RangeSet.TryParse(ref error, rangeString.Substring(startPos + 1, endPos - startPos - 1), out RangeSet? temp))
                         {
-                            if (!RangeSet.TryParse(ref error, rangeString.Substring(startPos + 1, endPos - startPos - 1), out RangeSet? temp))
-                            {
-                                return false;
-                            }
-                            rangeSets.Add(temp);
-                            startPos = endPos; // the increment will make sure we don't re explore this
-                            success = true;
-                            break;
+                            return false;
                         }
-                    }
-                    if (!success)
-                    {
-                        error = "There was an unmatched '{' at position " + startPos;
-                        return false;
+                        rangeSets.Add(temp);
+                        startPos = endPos; // the increment will make sure we don't re explore this
+                        success = true;
+                        break;
                     }
                 }
-            }
-            // in case it is a set of 1 element
-            if (rangeSets.Count == 0)
-            {
-                if (!RangeSet.TryParse(ref error, rangeString, out RangeSet? temp))
+                if (!success)
                 {
+                    error = "There was an unmatched '{' at position " + startPos;
                     return false;
                 }
-                rangeSets.Add(temp);
             }
-            output = new RangeSetSet(rangeSets);
-            return true;
         }
+        // in case it is a set of 1 element
+        if (rangeSets.Count == 0)
+        {
+            if (!RangeSet.TryParse(ref error, rangeString, out RangeSet? temp))
+            {
+                return false;
+            }
+            rangeSets.Add(temp);
+        }
+        output = new RangeSetSet(rangeSets);
+        return true;
+    }
 
-        /// <summary>
-        /// Not Supported
-        /// </summary>
-        /// <param name="item"></param>
-        public void Add(RangeSet item) => throw new NotSupportedException();
+    /// <summary>
+    /// Not Supported
+    /// </summary>
+    /// <param name="item"></param>
+    public void Add(RangeSet item) => throw new NotSupportedException();
 
-        /// <summary>
-        /// Not Supported
-        /// </summary>
-        public void Clear() => throw new NotSupportedException();
+    /// <summary>
+    /// Not Supported
+    /// </summary>
+    public void Clear() => throw new NotSupportedException();
 
-        public bool Contains(RangeSet item) => IndexOf(item) != -1;
+    public bool Contains(RangeSet item) => IndexOf(item) != -1;
 
-        public void CopyTo(RangeSet[] array, int arrayIndex)
+    public void CopyTo(RangeSet[] array, int arrayIndex)
+    {
+        var localRangeSets = RangeSets;
+        if (localRangeSets.Length + arrayIndex >= array.Length)
         {
-            var localRangeSets = RangeSets;
-            if (localRangeSets.Length + arrayIndex >= array.Length)
-            {
-                throw new ArgumentException("The given array is not long enough to support copying starting at index " + arrayIndex);
-            }
-            if (arrayIndex < 0)
-            {
-                throw new ArgumentOutOfRangeException("arrayIndex", "This argument must be greater than or equal to zero!");
-            }
-            for (var i = 0; i < localRangeSets.Length; i++)
-            {
-                array[i + arrayIndex] = localRangeSets[i];
-            }
+            throw new ArgumentException("The given array is not long enough to support copying starting at index " + arrayIndex);
+        }
+        if (arrayIndex < 0)
+        {
+            throw new ArgumentOutOfRangeException("arrayIndex", "This argument must be greater than or equal to zero!");
+        }
+        for (var i = 0; i < localRangeSets.Length; i++)
+        {
+            array[i + arrayIndex] = localRangeSets[i];
         }
+    }
 
-        public override bool Equals(object? obj)
+    public override bool Equals(object? obj)
+    {
+        var other = obj as RangeSetSet;
+        if (Count != other?.Count) return false;
+        for (var i = 0; i < RangeSets.Length; i++)
         {
-            var other = obj as RangeSetSet;
-            if (Count != other?.Count) return false;
-            for (var i = 0; i < RangeSets.Length; i++)
+            if (!RangeSets[i].Equals(other.RangeSets[i]))
             {
-                if (!RangeSets[i].Equals(other.RangeSets[i]))
-                {
-                    return false;
-                }
+                return false;
             }
-            return true;
         }
+        return true;
+    }
 
-        public IEnumerator<RangeSet> GetEnumerator() => ((ICollection<RangeSet>)RangeSets).GetEnumerator();
+    public IEnumerator<RangeSet> GetEnumerator() => ((ICollection<RangeSet>)RangeSets).GetEnumerator();
 
-        public override int GetHashCode()
+    public override int GetHashCode()
+    {
+        var hash = 0;
+        for (var i = 0; i < RangeSets.Length; i++)
         {
-            var hash = 0;
-            for (var i = 0; i < RangeSets.Length; i++)
-            {
-                hash += RangeSets[i].GetHashCode();
-            }
-            return hash;
+            hash += RangeSets[i].GetHashCode();
         }
+        return hash;
+    }
 
-        public int IndexOf(RangeSet item)
+    public int IndexOf(RangeSet item)
+    {
+        if (item == null)
         {
-            if (item == null)
-            {
-                ThrowParameterNull(nameof(item));
-            }
-            for (var i = 0; i < RangeSets.Length; i++)
+            ThrowParameterNull(nameof(item));
+        }
+        for (var i = 0; i < RangeSets.Length; i++)
+        {
+            if (item.Equals(RangeSets[i]))
             {
-                if (item.Equals(RangeSets[i]))
-                {
-                    return i;
-                }
+                return i;
             }
-            return -1;
         }
+        return -1;
+    }
 
-        public int IndexOf(int numberToFind)
+    public int IndexOf(int numberToFind)
+    {
+        for (var i = 0; i < RangeSets.Length; i++)
         {
-            for (var i = 0; i < RangeSets.Length; i++)
+            if (RangeSets[i].Contains(numberToFind))
             {
-                if (RangeSets[i].Contains(numberToFind))
-                {
-                    return i;
-                }
+                return i;
             }
-            return -1;
         }
+        return -1;
+    }
 
-        /// <summary>
-        /// Returns the first set that contains a range that contains the value.
-        /// </summary>
-        /// <param name="value">The value to seek</param>
-        /// <returns>The index of the set that first contains the value, -1 otherwise.</returns>
-        public int IndexOf(float value)
+    /// <summary>
+    /// Returns the first set that contains a range that contains the value.
+    /// </summary>
+    /// <param name="value">The value to seek</param>
+    /// <returns>The index of the set that first contains the value, -1 otherwise.</returns>
+    public int IndexOf(float value)
+    {
+        for (var i = 0; i < RangeSets.Length; i++)
         {
-            for (var i = 0; i < RangeSets.Length; i++)
+            if (RangeSets[i].Contains(value))
             {
-                if (RangeSets[i].Contains(value))
-                {
-                    return i;
-                }
+                return i;
             }
-            return -1;
         }
+        return -1;
+    }
 
-        /// <summary>
-        /// Not Supported
-        /// </summary>
-        /// <param name="index"></param>
-        /// <param name="item"></param>
-        public void Insert(int index, RangeSet item) => throw new NotSupportedException();
+    /// <summary>
+    /// Not Supported
+    /// </summary>
+    /// <param name="index"></param>
+    /// <param name="item"></param>
+    public void Insert(int index, RangeSet item) => throw new NotSupportedException();
 
-        public bool Remove(RangeSet item) => throw new NotSupportedException();
+    public bool Remove(RangeSet item) => throw new NotSupportedException();
 
-        /// <summary>
-        /// Not Supported
-        /// </summary>
-        public void RemoveAt(int index) => throw new NotSupportedException();
+    /// <summary>
+    /// Not Supported
+    /// </summary>
+    public void RemoveAt(int index) => throw new NotSupportedException();
 
-        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
-        {
-            return RangeSets.GetEnumerator();
-        }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+    {
+        return RangeSets.GetEnumerator();
+    }
 
-        public override string ToString()
+    public override string ToString()
+    {
+        var builder = new StringBuilder();
+        var first = true;
+        for (var i = 0; i < RangeSets.Length; i++)
         {
-            var builder = new StringBuilder();
-            var first = true;
-            for (var i = 0; i < RangeSets.Length; i++)
+            if (!first)
             {
-                if (!first)
-                {
-                    builder.Append(',');
-                }
-                first = false;
-                builder.Append('{');
-                builder.Append(RangeSets[i]);
-                builder.Append('}');
+                builder.Append(',');
             }
-            return builder.ToString();
+            first = false;
+            builder.Append('{');
+            builder.Append(RangeSets[i]);
+            builder.Append('}');
         }
+        return builder.ToString();
     }
-}
\ No newline at end of file
+}
diff --git a/src/TMG-Framework/Data/Time.cs b/src/TMG-Framework/Data/Time.cs
index 2ca007e..ef7a94f 100644
--- a/src/TMG-Framework/Data/Time.cs
+++ b/src/TMG-Framework/Data/Time.cs
@@ -16,498 +16,494 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using XTMF2;
-namespace TMG
+
+namespace TMG;
+
+/// <summary>
+/// Simple Time Struct for holding simple time data.
+/// </summary>
+public struct Time : IComparable<Time>
 {
     /// <summary>
-    /// Simple Time Struct for holding simple time data.
+    /// Our internal representation, to the millisecond
+    /// </summary>
+    private long _internalTime;
+
+    /// <summary>
+    /// Converts the given float time in format HH.MM to
+    /// this class representation
     /// </summary>
-    public struct Time : IComparable<Time>
+    /// <param name="time"></param>
+    public Time(float time)
     {
-        /// <summary>
-        /// Our internal representation, to the millisecond
-        /// </summary>
-        private long _internalTime;
-
-        /// <summary>
-        /// Converts the given float time in format HH.MM to
-        /// this class representation
-        /// </summary>
-        /// <param name="time"></param>
-        public Time(float time)
-        {
-            var hours = (long)time;
-            var minutes = (long)(Math.Round((time - (long)time) * 100));
-            _internalTime = (hours * 3600000L + minutes * 60000L);
-        }
+        var hours = (long)time;
+        var minutes = (long)(Math.Round((time - (long)time) * 100));
+        _internalTime = (hours * 3600000L + minutes * 60000L);
+    }
 
-        public Time(DateTime time)
-        {
-            var hours = time.Hour;
-            var minutes = time.Minute;
-            var seconds = time.Second;
-            var milliseconds = time.Millisecond;
-            var hourToMilliseconds = hours * 3600000L;
-            var minuteToMilliseconds = minutes * 60000L;
-            var secondToMilliseconds = seconds * 1000L;
-            _internalTime = (hourToMilliseconds + minuteToMilliseconds) + (secondToMilliseconds + milliseconds);
-        }
+    public Time(DateTime time)
+    {
+        var hours = time.Hour;
+        var minutes = time.Minute;
+        var seconds = time.Second;
+        var milliseconds = time.Millisecond;
+        var hourToMilliseconds = hours * 3600000L;
+        var minuteToMilliseconds = minutes * 60000L;
+        var secondToMilliseconds = seconds * 1000L;
+        _internalTime = (hourToMilliseconds + minuteToMilliseconds) + (secondToMilliseconds + milliseconds);
+    }
 
-        /// <summary>
-        /// Creates a TashaTime given the string representation
-        /// Example 4:25:00 4 hours 25 minutes and 0 seconds
-        /// </summary>
-        /// <param name="time"></param>
-        public Time(string time)
+    /// <summary>
+    /// Creates a TashaTime given the string representation
+    /// Example 4:25:00 4 hours 25 minutes and 0 seconds
+    /// </summary>
+    /// <param name="time"></param>
+    public Time(string time)
+    {
+        if (!TryParse(time, out this))
         {
-            if (!TryParse(time, out this))
-            {
-                throw new XTMFRuntimeException(null, "Unable to create a XTMF.Time from " + time);
-            }
+            throw new XTMFRuntimeException(null, "Unable to create a XTMF.Time from " + time);
         }
+    }
 
-        public static Time OneHour { get; } = new Time() { Hours = 1 };
+    public static Time OneHour { get; } = new Time() { Hours = 1 };
 
-        public static Time Zero { get; } = new Time();
+    public static Time Zero { get; } = new Time();
 
-        /// <summary>
-        /// The number of Hours this Time Object represents
-        /// </summary>
-        public int Hours
-        {
-            get => (int)(_internalTime / 3600000L);
-            set => _internalTime = (_internalTime % 3600000L + (value * 3600000L));
-        }
+    /// <summary>
+    /// The number of Hours this Time Object represents
+    /// </summary>
+    public int Hours
+    {
+        get => (int)(_internalTime / 3600000L);
+        set => _internalTime = (_internalTime % 3600000L + (value * 3600000L));
+    }
 
-        /// <summary>
-        ///
-        /// </summary>
-        public int Minutes
-        {
-            get => (int)((_internalTime / 60000L) % 60L);
-            set => _internalTime = _internalTime - ((_internalTime / 60000L) % 60L) + (value * 60000L);
-        }
+    /// <summary>
+    ///
+    /// </summary>
+    public int Minutes
+    {
+        get => (int)((_internalTime / 60000L) % 60L);
+        set => _internalTime = _internalTime - ((_internalTime / 60000L) % 60L) + (value * 60000L);
+    }
 
-        /// <summary>
-        /// The number of seconds this Time Object Represents
-        /// </summary>
-        public int Seconds
+    /// <summary>
+    /// The number of seconds this Time Object Represents
+    /// </summary>
+    public int Seconds
+    {
+        get => (int)((_internalTime / 1000L) % 60L);
+        set
         {
-            get => (int)((_internalTime / 1000L) % 60L);
-            set
-            {
-                var temp = _internalTime / 1000L;
-                _internalTime = ((temp - temp % 60L) + value) * 1000L;
-            }
+            var temp = _internalTime / 1000L;
+            _internalTime = ((temp - temp % 60L) + value) * 1000L;
         }
+    }
 
-        public static Time FromMinutes(float result) => new Time() { _internalTime = (long)(result * 60000.0f) };
+    public static Time FromMinutes(float result) => new Time() { _internalTime = (long)(result * 60000.0f) };
 
-        public static implicit operator DateTime(Time t) => new DateTime(0, 0, 0, t.Hours, t.Minutes, t.Seconds, 0);
+    public static implicit operator DateTime(Time t) => new DateTime(0, 0, 0, t.Hours, t.Minutes, t.Seconds, 0);
 
-        public static implicit operator Time(DateTime t) => new Time(t);
+    public static implicit operator Time(DateTime t) => new Time(t);
 
-        public static bool Intersection(Time start1, Time end1, Time start2, Time end2) => !((end1._internalTime < start2._internalTime)
-                | (end2._internalTime < start1._internalTime));
+    public static bool Intersection(Time start1, Time end1, Time start2, Time end2) => !((end1._internalTime < start2._internalTime)
+            | (end2._internalTime < start1._internalTime));
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Intersection(Time start1, Time end1, Time start2, Time end2, out Time intersection)
-        {
-            var intersectionStart = Math.Max(start1._internalTime, start2._internalTime);
-            var intersectionEnd = Math.Min(end1._internalTime, end2._internalTime);
-            var intersectionDuration = intersectionEnd - intersectionStart;
-            var mask = ~(intersectionDuration >> 63);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool Intersection(Time start1, Time end1, Time start2, Time end2, out Time intersection)
+    {
+        var intersectionStart = Math.Max(start1._internalTime, start2._internalTime);
+        var intersectionEnd = Math.Min(end1._internalTime, end2._internalTime);
+        var intersectionDuration = intersectionEnd - intersectionStart;
+        var mask = ~(intersectionDuration >> 63);
 
-            intersection._internalTime = intersectionDuration & mask;
-            return mask != 0L;
-        }
+        intersection._internalTime = intersectionDuration & mask;
+        return mask != 0L;
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Intersection(Time start1, Time end1, Time start2, Time end2, out Time intersectionStart, out Time intersectionEnd)
-        {
-            var start = Math.Max(start1._internalTime, start2._internalTime);
-            var end = Math.Min(end1._internalTime, end2._internalTime);
-            var mask = ~((end - start) >> 63);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool Intersection(Time start1, Time end1, Time start2, Time end2, out Time intersectionStart, out Time intersectionEnd)
+    {
+        var start = Math.Max(start1._internalTime, start2._internalTime);
+        var end = Math.Min(end1._internalTime, end2._internalTime);
+        var mask = ~((end - start) >> 63);
 
-            intersectionStart._internalTime = start & mask;
-            intersectionEnd._internalTime = end & mask;
-            return mask != 0L;
-        }
+        intersectionStart._internalTime = start & mask;
+        intersectionEnd._internalTime = end & mask;
+        return mask != 0L;
+    }
 
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="t1"></param>
-        /// <param name="t2"></param>
-        /// <returns></returns>
-        public static Time operator -(Time t1, Time t2) => new Time() { _internalTime = t1._internalTime - t2._internalTime };
-
-        public static Time operator -(Time t1) => new Time() { _internalTime = -t1._internalTime };
-
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="t1"></param>
-        /// <param name="t2"></param>
-        /// <returns></returns>
-        public static bool operator !=(Time t1, Time t2) => t1._internalTime != t2._internalTime;
-
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="time"></param>
-        /// <param name="percent"></param>
-        /// <returns></returns>
-        public static Time operator *(float percent, Time time) => new Time() { _internalTime = (long)(Math.Round(percent * time._internalTime)) };
-
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="t1"></param>
-        /// <param name="t2"></param>
-        /// <returns></returns>
-        public static float operator /(Time t1, Time t2)
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="t1"></param>
+    /// <param name="t2"></param>
+    /// <returns></returns>
+    public static Time operator -(Time t1, Time t2) => new Time() { _internalTime = t1._internalTime - t2._internalTime };
+
+    public static Time operator -(Time t1) => new Time() { _internalTime = -t1._internalTime };
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="t1"></param>
+    /// <param name="t2"></param>
+    /// <returns></returns>
+    public static bool operator !=(Time t1, Time t2) => t1._internalTime != t2._internalTime;
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="time"></param>
+    /// <param name="percent"></param>
+    /// <returns></returns>
+    public static Time operator *(float percent, Time time) => new Time() { _internalTime = (long)(Math.Round(percent * time._internalTime)) };
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="t1"></param>
+    /// <param name="t2"></param>
+    /// <returns></returns>
+    public static float operator /(Time t1, Time t2)
+    {
+        if (t2 == Zero)
         {
-            if (t2 == Zero)
-            {
-                throw new DivideByZeroException();
-            }
-            return (float)t1._internalTime / t2._internalTime;
+            throw new DivideByZeroException();
         }
+        return (float)t1._internalTime / t2._internalTime;
+    }
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="t1"></param>
+    /// <param name="t2"></param>
+    /// <returns></returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Time operator +(Time t1, Time t2) => new Time() { _internalTime = t1._internalTime + t2._internalTime };
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="t1"></param>
+    /// <param name="t2"></param>
+    /// <returns></returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator <(Time t1, Time t2) => t1._internalTime < t2._internalTime;
 
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="t1"></param>
-        /// <param name="t2"></param>
-        /// <returns></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Time operator +(Time t1, Time t2) => new Time() { _internalTime = t1._internalTime + t2._internalTime };
-
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="t1"></param>
-        /// <param name="t2"></param>
-        /// <returns></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool operator <(Time t1, Time t2) => t1._internalTime < t2._internalTime;
-
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="t1"></param>
-        /// <param name="t2"></param>
-        /// <returns></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool operator <=(Time t1, Time t2) => t1._internalTime <= t2._internalTime;
-
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="t1"></param>
-        /// <param name="t2"></param>
-        /// <returns></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool operator ==(Time t1, Time t2) => t1._internalTime == t2._internalTime;
-
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="t1"></param>
-        /// <param name="t2"></param>
-        /// <returns></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool operator >(Time t1, Time t2) => t1._internalTime > t2._internalTime;
-
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="t1"></param>
-        /// <param name="t2"></param>
-        /// <returns></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool operator >=(Time t1, Time t2) => t1._internalTime >= t2._internalTime;
-
-        public static bool TryParse(string timeString, out Time time)
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="t1"></param>
+    /// <param name="t2"></param>
+    /// <returns></returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator <=(Time t1, Time t2) => t1._internalTime <= t2._internalTime;
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="t1"></param>
+    /// <param name="t2"></param>
+    /// <returns></returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator ==(Time t1, Time t2) => t1._internalTime == t2._internalTime;
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="t1"></param>
+    /// <param name="t2"></param>
+    /// <returns></returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator >(Time t1, Time t2) => t1._internalTime > t2._internalTime;
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="t1"></param>
+    /// <param name="t2"></param>
+    /// <returns></returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator >=(Time t1, Time t2) => t1._internalTime >= t2._internalTime;
+
+    public static bool TryParse(string timeString, out Time time)
+    {
+        string? error = null;
+        return TryParse(ref error, timeString, out time);
+    }
+
+    public static bool TryParse(
+        [NotNullWhen(false)] ref string? error, string timeString, out Time time)
+    {
+        time = new Time();
+        if (String.IsNullOrWhiteSpace(timeString))
         {
-            string? error = null;
-            return TryParse(ref error, timeString, out time);
+            error = "Time string is null or whitespace!";
+            return false;
         }
-
-        public static bool TryParse(
-            [NotNullWhen(false)]ref string? error, string timeString, out Time time)
+        int seconds = 0, minutes = 0, hours = 0;
+        int state = 0;
+        int currentTime = 0;
+        int currentNumber = 0;
+        for (int i = 0; i < timeString.Length; ++i)
         {
-            time = new Time();
-            if (String.IsNullOrWhiteSpace(timeString))
+            char c = timeString[i];
+            if (Char.IsWhiteSpace(c))
             {
-                error = "Time string is null or whitespace!";
-                return false;
+                continue;
             }
-            int seconds = 0, minutes = 0, hours = 0;
-            int state = 0;
-            int currentTime = 0;
-            int currentNumber = 0;
-            for (int i = 0; i < timeString.Length; ++i)
+            switch (state)
             {
-                char c = timeString[i];
-                if (Char.IsWhiteSpace(c))
-                {
-                    continue;
-                }
-                switch (state)
-                {
-                    // Initial State
-                    case 0:
+                // Initial State
+                case 0:
+                    {
+                        if ((c >= '0') & (c <= '9'))
                         {
-                            if ((c >= '0') & (c <= '9'))
-                            {
-                                currentNumber *= 10;
-                                currentNumber += (c - '0');
-                                state = 1;
-                                continue;
-                            }
-                            else
+                            currentNumber *= 10;
+                            currentNumber += (c - '0');
+                            state = 1;
+                            continue;
+                        }
+                        else
+                        {
+                            error = "Expected a number but found '" + c + "' instead!";
+                        }
+                    }
+                    return false;
+                // Collect number
+                case 1:
+                    {
+                        if ((c >= '0') & (c <= '9'))
+                        {
+                            currentNumber *= 10;
+                            currentNumber += (c - '0');
+                        }
+                        else if (c == ':')
+                        {
+                            switch (currentTime)
                             {
-                                error = "Expected a number but found '" + c + "' instead!";
+                                case 0:
+                                    hours = currentNumber;
+                                    break;
+
+                                case 1:
+                                    minutes = currentNumber;
+                                    break;
+
+                                case 2:
+                                    seconds = currentNumber;
+                                    break;
+
+                                default:
+                                    error = "Invalid Time level!";
+                                    return false;
                             }
+                            currentNumber = 0;
+                            currentTime++;
+                            state = 0;
                         }
-                        return false;
-                    // Collect number
-                    case 1:
+                        else if ((c == 'h') | (c == 'H'))
                         {
-                            if ((c >= '0') & (c <= '9'))
+                            if (currentTime <= 0)
                             {
-                                currentNumber *= 10;
-                                currentNumber += (c - '0');
+                                hours = currentNumber;
+                                currentTime = 1;
+                                currentNumber = 0;
+                                state = 2;
                             }
-                            else if (c == ':')
+                            else
                             {
-                                switch (currentTime)
-                                {
-                                    case 0:
-                                        hours = currentNumber;
-                                        break;
-
-                                    case 1:
-                                        minutes = currentNumber;
-                                        break;
-
-                                    case 2:
-                                        seconds = currentNumber;
-                                        break;
-
-                                    default:
-                                        error = "Invalid Time level!";
-                                        return false;
-                                }
-                                currentNumber = 0;
-                                currentTime++;
-                                state = 0;
+                                error = "Invalid place to enter hours!";
+                                return false;
                             }
-                            else if ((c == 'h') | (c == 'H'))
+                        }
+                        else if ((c == 'm') | (c == 'M'))
+                        {
+                            if (currentTime <= 1)
                             {
-                                if (currentTime <= 0)
-                                {
-                                    hours = currentNumber;
-                                    currentTime = 1;
-                                    currentNumber = 0;
-                                    state = 2;
-                                }
-                                else
-                                {
-                                    error = "Invalid place to enter hours!";
-                                    return false;
-                                }
+                                minutes = currentNumber;
+                                currentTime = 2;
+                                currentNumber = 0;
+                                state = 2;
                             }
-                            else if ((c == 'm') | (c == 'M'))
+                            else
                             {
-                                if (currentTime <= 1)
-                                {
-                                    minutes = currentNumber;
-                                    currentTime = 2;
-                                    currentNumber = 0;
-                                    state = 2;
-                                }
-                                else
-                                {
-                                    error = "Invalid place to enter minutes!";
-                                    return false;
-                                }
+                                error = "Invalid place to enter minutes!";
+                                return false;
                             }
-                            else if ((c == 's') | (c == 'S'))
+                        }
+                        else if ((c == 's') | (c == 'S'))
+                        {
+                            if (currentTime <= 2)
                             {
-                                if (currentTime <= 2)
-                                {
-                                    seconds = currentNumber;
-                                    currentTime = 3;
-                                    currentNumber = 0;
-                                    state = 2;
-                                }
-                                else
-                                {
-                                    error = "Invalid place to enter seconds!";
-                                    return false;
-                                }
+                                seconds = currentNumber;
+                                currentTime = 3;
+                                currentNumber = 0;
+                                state = 2;
                             }
-                            else if ((c == 'a') | (c == 'A'))
+                            else
                             {
-                                if (hours == 12)
-                                {
-                                    hours -= 12;
-                                }
-                                state = 4;
+                                error = "Invalid place to enter seconds!";
+                                return false;
                             }
-                            else if ((c == 'p') | (c == 'P'))
+                        }
+                        else if ((c == 'a') | (c == 'A'))
+                        {
+                            if (hours == 12)
                             {
-                                if (hours != 12)
-                                {
-                                    hours += 12;
-                                }
-                                state = 4;
+                                hours -= 12;
                             }
-                            else
+                            state = 4;
+                        }
+                        else if ((c == 'p') | (c == 'P'))
+                        {
+                            if (hours != 12)
                             {
-                                error = "Unexpected symbol '" + c + "'";
-                                return false;
+                                hours += 12;
                             }
+                            state = 4;
                         }
-                        break;
+                        else
+                        {
+                            error = "Unexpected symbol '" + c + "'";
+                            return false;
+                        }
+                    }
+                    break;
 
-                    case 2:
+                case 2:
+                    {
+                        if (!Char.IsLetter(c))
                         {
-                            if (!Char.IsLetter(c))
+                            if ((c >= '0') & (c <= '9'))
                             {
-                                if ((c >= '0') & (c <= '9'))
-                                {
-                                    currentNumber = (c - '0');
-                                    state = 1;
-                                }
+                                currentNumber = (c - '0');
+                                state = 1;
                             }
                         }
-                        break;
-                    // We received an A or a P, we need to find an M next or fail
-                    case 4:
+                    }
+                    break;
+                // We received an A or a P, we need to find an M next or fail
+                case 4:
+                    {
+                        if ((c == 'm' | c == 'M'))
                         {
-                            if ((c == 'm' | c == 'M'))
+                            switch (currentTime)
                             {
-                                switch (currentTime)
-                                {
-                                    case 0:
-                                        hours = currentNumber;
-                                        break;
-
-                                    case 1:
-                                        minutes = currentNumber;
-                                        break;
-
-                                    case 2:
-                                        seconds = currentNumber;
-                                        break;
-
-                                    case 3:
-                                        // do nothing in this case, we have had all of the data already entered
-                                        if (currentNumber != 0)
-                                        {
-                                            error = "Too many time entries have been found!";
-                                            return false;
-                                        }
-                                        break;
-
-                                    default:
-                                        error = "Unexpected time state found!";
+                                case 0:
+                                    hours = currentNumber;
+                                    break;
+
+                                case 1:
+                                    minutes = currentNumber;
+                                    break;
+
+                                case 2:
+                                    seconds = currentNumber;
+                                    break;
+
+                                case 3:
+                                    // do nothing in this case, we have had all of the data already entered
+                                    if (currentNumber != 0)
+                                    {
+                                        error = "Too many time entries have been found!";
                                         return false;
-                                }
-                                state = 0;
-                            }
-                            else
-                            {
-                                error = "We were expecting a 'm' but found '" + c + "' instead!";
-                                return false;
+                                    }
+                                    break;
+
+                                default:
+                                    error = "Unexpected time state found!";
+                                    return false;
                             }
+                            state = 0;
                         }
-                        break;
-                    default:
-                        error = "Unexpected state found!";
-                        return false;
-                }
-            }
-            if (state == 1)
-            {
-                switch (currentTime)
-                {
-                    case 0:
-                        hours = currentNumber;
-                        break;
-
-                    case 1:
-                        minutes = currentNumber;
-                        break;
-
-                    case 2:
-                        seconds = currentNumber;
-                        break;
-
-                    case 3:
-                        // do nothing in this case, we have had all of the data already entered
-                        if (currentNumber != 0)
+                        else
                         {
-                            error = "Too many time entries have been found!";
+                            error = "We were expecting a 'm' but found '" + c + "' instead!";
                             return false;
                         }
-                        break;
-                    default:
-                        error = "Unexpected time state found!";
-                        return false;
-                }
+                    }
+                    break;
+                default:
+                    error = "Unexpected state found!";
+                    return false;
             }
-            time._internalTime = (long)(hours * 3600 + minutes * 60 + seconds) * 1000;
-            return true;
         }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public int CompareTo(Time other)
+        if (state == 1)
         {
-            return _internalTime.CompareTo(other._internalTime);
+            switch (currentTime)
+            {
+                case 0:
+                    hours = currentNumber;
+                    break;
+
+                case 1:
+                    minutes = currentNumber;
+                    break;
+
+                case 2:
+                    seconds = currentNumber;
+                    break;
+
+                case 3:
+                    // do nothing in this case, we have had all of the data already entered
+                    if (currentNumber != 0)
+                    {
+                        error = "Too many time entries have been found!";
+                        return false;
+                    }
+                    break;
+                default:
+                    error = "Unexpected time state found!";
+                    return false;
+            }
         }
+        time._internalTime = (long)(hours * 3600 + minutes * 60 + seconds) * 1000;
+        return true;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int CompareTo(Time other)
+    {
+        return _internalTime.CompareTo(other._internalTime);
+    }
 
-        public override bool Equals(object? obj)
+    public override bool Equals(object? obj)
+    {
+        if (obj is Time other)
         {
-            if (obj is Time other)
-            {
-                return _internalTime == other._internalTime;
-            }
-            return base.Equals(obj);
+            return _internalTime == other._internalTime;
         }
+        return base.Equals(obj);
+    }
 
-        public override int GetHashCode() => base.GetHashCode();
+    public override int GetHashCode() => base.GetHashCode();
 
-        /// <summary>
-        ///
-        /// </summary>
-        /// <returns></returns>
-        public float ToFloat() => Hours + (Minutes * 0.01f) + (Seconds * 0.0001f);
+    /// <summary>
+    ///
+    /// </summary>
+    /// <returns></returns>
+    public float ToFloat() => Hours + (Minutes * 0.01f) + (Seconds * 0.0001f);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public float ToMinutes() => _internalTime * 1.6666666666666666666666666666667e-5f;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public float ToMinutes() => _internalTime * 1.6666666666666666666666666666667e-5f;
 
-        /// <summary>
-        ///
-        /// </summary>
-        /// <returns></returns>
-        override public string ToString()
+    /// <summary>
+    ///
+    /// </summary>
+    /// <returns></returns>
+    override public string ToString()
+    {
+        if ((_internalTime / 1000) % 60 == 0)
         {
-            if ((_internalTime / 1000) % 60 == 0)
-            {
-                return String.Format("{0}:{1:00}", Hours, Minutes);
-            }
-            else
-            {
-                return String.Format("{0}:{1:00}:{2:00}", Hours, Minutes, Seconds);
-            }
+            return String.Format("{0}:{1:00}", Hours, Minutes);
+        }
+        else
+        {
+            return String.Format("{0}:{1:00}:{2:00}", Hours, Minutes, Seconds);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/TMG-Framework/Data/TimePeriod.cs b/src/TMG-Framework/Data/TimePeriod.cs
index b1ece79..0ede168 100644
--- a/src/TMG-Framework/Data/TimePeriod.cs
+++ b/src/TMG-Framework/Data/TimePeriod.cs
@@ -16,43 +16,39 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
 
-namespace TMG
+namespace TMG;
+
+/// <summary>
+/// This class represents an identified range of time [Start, End).
+/// </summary>
+public struct TimePeriod
 {
     /// <summary>
-    /// This class represents an identified range of time [Start, End).
+    /// The start of the time period
+    /// </summary>
+    public Time Start { get; private set; }
+
+    /// <summary>
+    /// The end of the time period
+    /// </summary>
+    public Time End { get; private set; }
+
+    /// <summary>
+    /// Construct a time period from the given times.
     /// </summary>
-    public struct TimePeriod
+    /// <param name="start">The start time of the time period.(Inclusive)</param>
+    /// <param name="end">THe end time of the time period. (Exclusive)</param>
+    public TimePeriod(Time start, Time end)
     {
-        /// <summary>
-        /// The start of the time period
-        /// </summary>
-        public Time Start { get; private set; }
-
-        /// <summary>
-        /// The end of the time period
-        /// </summary>
-        public Time End { get; private set; }
-
-        /// <summary>
-        /// Construct a time period from the given times.
-        /// </summary>
-        /// <param name="start">The start time of the time period.(Inclusive)</param>
-        /// <param name="end">THe end time of the time period. (Exclusive)</param>
-        public TimePeriod(Time start, Time end)
-        {
-            Start = start;
-            End = end;
-        }
-
-        /// <summary>
-        /// Is the given time within this time period.
-        /// </summary>
-        /// <param name="time">The time to test for.</param>
-        /// <returns>True if it is in the time period, false otherwise.</returns>
-        public bool Contains(Time time) => (Start <= time) & (time < End);
+        Start = start;
+        End = end;
     }
+
+    /// <summary>
+    /// Is the given time within this time period.
+    /// </summary>
+    /// <param name="time">The time to test for.</param>
+    /// <returns>True if it is in the time period, false otherwise.</returns>
+    public bool Contains(Time time) => (Start <= time) & (time < End);
 }
diff --git a/src/TMG-Framework/Data/Vector.cs b/src/TMG-Framework/Data/Vector.cs
index 10d753b..4fbd10d 100644
--- a/src/TMG-Framework/Data/Vector.cs
+++ b/src/TMG-Framework/Data/Vector.cs
@@ -16,118 +16,117 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
+
 using System.Buffers;
-using System.Threading;
 using static TMG.Utilities.ExceptionHelper;
 
-namespace TMG
+namespace TMG;
+
+/// <summary>
+/// Represents a single dimension floating point data storage with a given shape.
+/// </summary>
+public sealed class Vector : IDisposable
 {
     /// <summary>
-    /// Represents a single dimension floating point data storage with a given shape.
+    /// The categories that shape this vector.
     /// </summary>
-    public sealed class Vector : IDisposable
-    {
-        /// <summary>
-        /// The categories that shape this vector.
-        /// </summary>
-        public Categories Categories { get; }
+    public Categories Categories { get; }
 
-        /// <summary>
-        /// The backing data for this vector.
-        /// </summary>
-        public Span<float> Data => _backingMemory is null ? ThrowAlreadyDisposed() : _backingMemory.Value.Span;
+    /// <summary>
+    /// The backing data for this vector.
+    /// </summary>
+    public Span<float> Data => _backingMemory is null ? ThrowAlreadyDisposed() : _backingMemory.Value.Span;
 
-        private Span<float> ThrowAlreadyDisposed()
-        {
-            throw new ObjectDisposedException(nameof(Vector));
-        }
+    private Span<float> ThrowAlreadyDisposed()
+    {
+        throw new ObjectDisposedException(nameof(Vector));
+    }
 
-        public void Dispose()
-        {
-            _backingMemory = default;
-            Thread.MemoryBarrier();
-            _allocator?.Dispose();
-            _allocator = null;
-        }
+    public void Dispose()
+    {
+        _backingMemory = default;
+        Thread.MemoryBarrier();
+        _allocator?.Dispose();
+        _allocator = null;
+    }
 
-        ~Vector()
-        {
-            Dispose();
-        }
+    ~Vector()
+    {
+        Dispose();
+    }
 
-        private Memory<float>? _backingMemory;
+    private Memory<float>? _backingMemory;
 
-        private IMemoryOwner<float>? _allocator;
+    private IMemoryOwner<float>? _allocator;
+
+    /// <summary>
+    /// Create a new vector given the shape of the categories.
+    /// </summary>
+    /// <param name="categories">The categories to shape the vector around.</param>
+    public Vector(Categories categories) : this(categories, null) { }
 
-        /// <summary>
-        /// Create a new vector given the shape of the categories.
-        /// </summary>
-        /// <param name="categories">The categories to shape the vector around.</param>
-        public Vector(Categories categories) : this (categories, null) {}
-        
 
-        /// <summary>
-        /// Create a new vector given the shape of the categories and an optional memory allocator.
-        /// </summary>
-        /// <param name="categories">The categories to shape the vector around.</param>
-        /// <param name="allocator">The memory pool to use for the vector data.</param>
-        public Vector(Categories categories, MemoryPool<float>? allocator)
+    /// <summary>
+    /// Create a new vector given the shape of the categories and an optional memory allocator.
+    /// </summary>
+    /// <param name="categories">The categories to shape the vector around.</param>
+    /// <param name="allocator">The memory pool to use for the vector data.</param>
+    public Vector(Categories categories, MemoryPool<float>? allocator)
+    {
+        if (categories == null)
         {
-            if(categories == null)
-            {
-                ThrowParameterNull(nameof(categories));
-            }
-            Categories = categories;
-            _allocator = allocator?.Rent(Categories.Count);
-            _backingMemory = _allocator?.Memory ?? new float[Categories.Count];
+            ThrowParameterNull(nameof(categories));
         }
+        Categories = categories;
+        _allocator = allocator?.Rent(Categories.Count);
+        _backingMemory = _allocator?.Memory ?? new float[Categories.Count];
+    }
+
+    /// <summary>
+    /// Create a new vector given the shape of the given vector.
+    /// This will not create a clone of the given vector.
+    /// </summary>
+    /// <param name="vector">The vector to use to create the shape from.</param>
+    public Vector(Vector vector) : this(vector, null) { }
 
-        /// <summary>
-        /// Create a new vector given the shape of the given vector.
-        /// This will not create a clone of the given vector.
-        /// </summary>
-        /// <param name="vector">The vector to use to create the shape from.</param>
-        public Vector(Vector vector) : this(vector, null) { }
-
-        /// <summary>
-        /// Create a new vector given the shape of the given vector and an optional memory allocator.
-        /// </summary>
-        /// <param name="vector">The vector to use to create the shape from.</param>
-        /// <param name="allocator">The memory pool to use for the vector data.</param>
-        public Vector(Vector vector, MemoryPool<float>? allocator)
+    /// <summary>
+    /// Create a new vector given the shape of the given vector and an optional memory allocator.
+    /// </summary>
+    /// <param name="vector">The vector to use to create the shape from.</param>
+    /// <param name="allocator">The memory pool to use for the vector data.</param>
+    public Vector(Vector vector, MemoryPool<float>? allocator)
+    {
+        if (vector == null)
         {
-            if(vector == null)
-            {
-                ThrowParameterNull(nameof(vector));
-            }
-            Categories = vector.Categories;
-            _allocator = allocator?.Rent(Categories.Count);
-            _backingMemory = _allocator?.Memory ?? new float[Categories.Count];
+            ThrowParameterNull(nameof(vector));
         }
+        Categories = vector.Categories;
+        _allocator = allocator?.Rent(Categories.Count);
+        _backingMemory = _allocator?.Memory ?? new float[Categories.Count];
+    }
 
-        public float this[CategoryIndex sparseIndex]
+    public float this[CategoryIndex sparseIndex]
+    {
+        get
         {
-            get
-            {
-                var index = Categories.GetFlatIndex(sparseIndex);
-                return index >= 0 ? Data[index] : 0.0f;
-            }
-            set
+            var index = Categories.GetFlatIndex(sparseIndex);
+            return index >= 0 ? Data[index] : 0.0f;
+        }
+        set
+        {
+            var index = Categories.GetFlatIndex(sparseIndex);
+            if (index >= 0)
             {
-                var index = Categories.GetFlatIndex(sparseIndex);
-                if (index >= 0)
-                {
-                    Data[index] = value;
-                }
-                ThrowOutOfRangeException(nameof(sparseIndex));
+                Data[index] = value;
             }
+            ThrowOutOfRangeException(nameof(sparseIndex));
         }
-
-        /// <summary>
-        /// The number of records contained in this vector.
-        /// </summary>
-        /// <returns>The number of elements.</returns>
-        public int Count => _backingMemory?.Length ?? 0;
     }
+
+    /// <summary>
+    /// The number of records contained in this vector.
+    /// </summary>
+    /// <returns>The number of elements.</returns>
+    public int Count => _backingMemory?.Length ?? 0;
 }
+
diff --git a/src/TMG-Framework/FileOperations/CopyFile.cs b/src/TMG-Framework/FileOperations/CopyFile.cs
index 92e40a5..069186d 100644
--- a/src/TMG-Framework/FileOperations/CopyFile.cs
+++ b/src/TMG-Framework/FileOperations/CopyFile.cs
@@ -16,95 +16,89 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.IO;
-using XTMF2;
 
-namespace TMG.FileOperations
+namespace TMG.FileOperations;
+
+[Module(Name = "Copy File", Description = "Copies a file (or directory) between two places with the option to delete after being copied.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public class CopyFile : BaseAction
 {
-    [Module(Name = "Copy File", Description = "Copies a file (or directory) between two places with the option to delete after being copied.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public class CopyFile : BaseAction
-    {
-        [Parameter(DefaultValue = "", Name = "Origin", Index = 0, Description = "The path to the file/directory to copy.")]
-        public IFunction<string> Origin = null!;
+    [Parameter(DefaultValue = "", Name = "Origin", Index = 0, Description = "The path to the file/directory to copy.")]
+    public IFunction<string> Origin = null!;
 
-        [Parameter(DefaultValue = "", Name = "Destination", Index = 1, Description = "The path to the file/directory to copy into.")]
-        public IFunction<string> Destination = null!;
+    [Parameter(DefaultValue = "", Name = "Destination", Index = 1, Description = "The path to the file/directory to copy into.")]
+    public IFunction<string> Destination = null!;
 
-        [Parameter(DefaultValue = "False", Name = "Move", Index = 2, Description = "Should the origin be erased after the file is copied?")]
-        public IFunction<bool> Move = null!;
+    [Parameter(DefaultValue = "False", Name = "Move", Index = 2, Description = "Should the origin be erased after the file is copied?")]
+    public IFunction<bool> Move = null!;
 
-        public override void Invoke()
+    public override void Invoke()
+    {
+        var oInfo = new FileInfo(Origin.Invoke());
+        var dInfo = new FileInfo(Destination.Invoke());
+        var move = Move.Invoke();
+        if (!oInfo.Exists)
         {
-            var oInfo = new FileInfo(Origin.Invoke());
-            var dInfo = new FileInfo(Destination.Invoke());
-            var move = Move.Invoke();
-            if(!oInfo.Exists)
+            throw new XTMFRuntimeException(this, $"There is no file at the path {oInfo.FullName}!");
+        }
+        var originIsDir = oInfo.Attributes.HasFlag(FileAttributes.Directory);
+        var destIsDir = dInfo.Attributes.HasFlag(FileAttributes.Directory);
+        if (originIsDir)
+        {
+            if (!destIsDir)
             {
-                throw new XTMFRuntimeException(this, $"There is no file at the path {oInfo.FullName}!");
+                throw new XTMFRuntimeException(this, $"The path {dInfo.FullName} is not a directory where are the source {oInfo.FullName} is!");
             }
-            var originIsDir = oInfo.Attributes.HasFlag(FileAttributes.Directory);
-            var destIsDir = dInfo.Attributes.HasFlag(FileAttributes.Directory);
-            if (originIsDir)
+            // copy the directories
+            DirectoryCopy(oInfo.FullName, dInfo.FullName);
+            Directory.Delete(oInfo.FullName);
+        }
+        else
+        {
+            if (destIsDir)
             {
-                if(!destIsDir)
-                {
-                    throw new XTMFRuntimeException(this, $"The path {dInfo.FullName} is not a directory where are the source {oInfo.FullName} is!");
-                }
-                // copy the directories
-                DirectoryCopy(oInfo.FullName, dInfo.FullName);
-                Directory.Delete(oInfo.FullName);
+                oInfo.CopyTo(dInfo.FullName, true);
             }
             else
             {
-                if(destIsDir)
-                {
-                    oInfo.CopyTo(dInfo.FullName, true);
-                }
-                else
-                {
-                    var directory = dInfo.Directory ?? 
-                        throw new XTMFRuntimeException(this, $"The path {dInfo.FullName} does not have a valid parent directory!");
-                    oInfo.CopyTo(directory.FullName, true);
-                }
+                var directory = dInfo.Directory ??
+                    throw new XTMFRuntimeException(this, $"The path {dInfo.FullName} does not have a valid parent directory!");
+                oInfo.CopyTo(directory.FullName, true);
             }
         }
+    }
 
-        private static void DirectoryCopy(string sourceDirectory, string destinationDirectory)
+    private static void DirectoryCopy(string sourceDirectory, string destinationDirectory)
+    {
+        // Get the subdirectories for the specified directory.
+        DirectoryInfo dir = new DirectoryInfo(sourceDirectory);
+        DirectoryInfo[] dirs = dir.GetDirectories();
+        if (!dir.Exists)
         {
-            // Get the subdirectories for the specified directory.
-            DirectoryInfo dir = new DirectoryInfo(sourceDirectory);
-            DirectoryInfo[] dirs = dir.GetDirectories();
-            if (!dir.Exists)
-            {
-                throw new DirectoryNotFoundException(
-                    "Source directory does not exist or could not be found: "
-                    + sourceDirectory);
-            }
+            throw new DirectoryNotFoundException(
+                "Source directory does not exist or could not be found: "
+                + sourceDirectory);
+        }
 
-            // If the destination directory doesn't exist, create it.
-            if (!Directory.Exists(destinationDirectory))
-            {
-                Directory.CreateDirectory(destinationDirectory);
-            }
+        // If the destination directory doesn't exist, create it.
+        if (!Directory.Exists(destinationDirectory))
+        {
+            Directory.CreateDirectory(destinationDirectory);
+        }
 
-            // Get the files in the directory and copy them to the new location.
-            FileInfo[] files = dir.GetFiles();
-            foreach (FileInfo file in files)
-            {
-                string temppath = Path.Combine(destinationDirectory, file.Name);
-                file.CopyTo(temppath, true);
-            }
+        // Get the files in the directory and copy them to the new location.
+        FileInfo[] files = dir.GetFiles();
+        foreach (FileInfo file in files)
+        {
+            string temppath = Path.Combine(destinationDirectory, file.Name);
+            file.CopyTo(temppath, true);
+        }
 
-            // If copying subdirectories, copy them and their contents to new location.
-            foreach (DirectoryInfo subdir in dirs)
-            {
-                string temppath = Path.Combine(destinationDirectory, subdir.Name);
-                DirectoryCopy(subdir.FullName, temppath);
-            }
+        // If copying subdirectories, copy them and their contents to new location.
+        foreach (DirectoryInfo subdir in dirs)
+        {
+            string temppath = Path.Combine(destinationDirectory, subdir.Name);
+            DirectoryCopy(subdir.FullName, temppath);
         }
     }
 }
diff --git a/src/TMG-Framework/FileOperations/DeleteFile.cs b/src/TMG-Framework/FileOperations/DeleteFile.cs
index 8390d2a..cd68078 100644
--- a/src/TMG-Framework/FileOperations/DeleteFile.cs
+++ b/src/TMG-Framework/FileOperations/DeleteFile.cs
@@ -16,36 +16,30 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.IO;
-using XTMF2;
 
-namespace TMG.FileOperations
+namespace TMG.FileOperations;
+
+[Module(Name = "Delete File", Description = "Delete a file (or directory).",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public sealed class DeleteFile : BaseAction
 {
-    [Module(Name = "Delete File", Description = "Delete a file (or directory).",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public sealed class DeleteFile : BaseAction
-    {
-        [Parameter(DefaultValue = "", Name = "To Delete", Index = 0, Description = "The path to delete.")]
-        public IFunction<string> ToDelete = null!;
+    [Parameter(DefaultValue = "", Name = "To Delete", Index = 0, Description = "The path to delete.")]
+    public IFunction<string> ToDelete = null!;
 
-        public override void Invoke()
+    public override void Invoke()
+    {
+        var info = new FileInfo(ToDelete.Invoke());
+        if (!info.Exists)
+        {
+            throw new XTMFRuntimeException(this, $"The file does not exist {info.FullName}!");
+        }
+        if (info.Attributes.HasFlag(FileAttributes.Directory))
+        {
+            new DirectoryInfo(info.FullName).Delete(true);
+        }
+        else
         {
-            var info = new FileInfo(ToDelete.Invoke());
-            if(!info.Exists)
-            {
-                throw new XTMFRuntimeException(this, $"The file does not exist {info.FullName}!");
-            }
-            if (info.Attributes.HasFlag(FileAttributes.Directory))
-            {
-                new DirectoryInfo(info.FullName).Delete(true);
-            }
-            else
-            {
-                info.Delete();
-            }
+            info.Delete();
         }
     }
 }
diff --git a/src/TMG-Framework/GlobalUsings.cs b/src/TMG-Framework/GlobalUsings.cs
new file mode 100644
index 0000000..0f513b1
--- /dev/null
+++ b/src/TMG-Framework/GlobalUsings.cs
@@ -0,0 +1,9 @@
+global using System;
+global using System.Collections.Generic;
+global using System.Diagnostics.CodeAnalysis;
+global using System.Linq;
+global using System.Runtime.CompilerServices;
+global using System.Runtime.InteropServices;
+global using System.Text;
+
+global using XTMF2;
diff --git a/src/TMG-Framework/Loading/LoadCategoriesFromCSV.cs b/src/TMG-Framework/Loading/LoadCategoriesFromCSV.cs
index d4489e1..bcaf3d7 100644
--- a/src/TMG-Framework/Loading/LoadCategoriesFromCSV.cs
+++ b/src/TMG-Framework/Loading/LoadCategoriesFromCSV.cs
@@ -16,11 +16,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
+
 using TMG.Utilities;
-using XTMF2;
 
 namespace TMG.Loading;
 
diff --git a/src/TMG-Framework/Loading/LoadCategoryMapFromThirdNormalizedCSV.cs b/src/TMG-Framework/Loading/LoadCategoryMapFromThirdNormalizedCSV.cs
index 8654563..fe1ad5c 100644
--- a/src/TMG-Framework/Loading/LoadCategoryMapFromThirdNormalizedCSV.cs
+++ b/src/TMG-Framework/Loading/LoadCategoryMapFromThirdNormalizedCSV.cs
@@ -16,173 +16,167 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
 using TMG.Utilities;
-using XTMF2;
 
-namespace TMG.Loading
+namespace TMG.Loading;
+
+[Module(Name = "Load Category Map From Third Normalized CSV",
+    Description = "Loads a category map (such as planning districts)",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public class LoadCategoryMapFromThirdNormalizedCSV : BaseFunction<CategoryMap>
 {
-    [Module(Name = "Load Category Map From Third Normalized CSV",
-        Description = "Loads a category map (such as planning districts)",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public class LoadCategoryMapFromThirdNormalizedCSV : BaseFunction<CategoryMap>
-    {
-        [SubModule(Index = 0, Required = true, Name = "Base Categories", Description = "The categories that this map from to the Destination Categories.")]
-        public IFunction<Categories> BaseCategories = null!;
+    [SubModule(Index = 0, Required = true, Name = "Base Categories", Description = "The categories that this map from to the Destination Categories.")]
+    public IFunction<Categories> BaseCategories = null!;
 
-        [SubModule(Index = 1, Required = false, Name = "Destination Categories", Description = "The categories that this map to from the Base Categories.  If not linked the CSV will create a new one based on the destination values found.")]
-        public IFunction<Categories>? DestinationCategories;
+    [SubModule(Index = 1, Required = false, Name = "Destination Categories", Description = "The categories that this map to from the Base Categories.  If not linked the CSV will create a new one based on the destination values found.")]
+    public IFunction<Categories>? DestinationCategories;
 
-        [SubModule(Index = 2, Required = true, Name = "CSV Stream", Description = "The stream that we will read from.")]
-        public IFunction<ReadStream> CSVStream = null!;
+    [SubModule(Index = 2, Required = true, Name = "CSV Stream", Description = "The stream that we will read from.")]
+    public IFunction<ReadStream> CSVStream = null!;
 
-        [Parameter(DefaultValue = "0", Name = "Base Column", Index = 3, Description = "The 0 indexed column containing the sparse map index for the base category index.")]
-        public IFunction<int> BaseColumn = null!;
+    [Parameter(DefaultValue = "0", Name = "Base Column", Index = 3, Description = "The 0 indexed column containing the sparse map index for the base category index.")]
+    public IFunction<int> BaseColumn = null!;
 
-        [Parameter(DefaultValue = "1", Name = "Destination Column", Index = 4, Description = "The 0 indexed column containing the sparse map index for the destination category index.")]
-        public IFunction<int> DestinationColumn = null!;
+    [Parameter(DefaultValue = "1", Name = "Destination Column", Index = 4, Description = "The 0 indexed column containing the sparse map index for the destination category index.")]
+    public IFunction<int> DestinationColumn = null!;
 
-        public override CategoryMap Invoke()
+    public override CategoryMap Invoke()
+    {
+        var destinationCategories = DestinationCategories?.Invoke();
+        if (destinationCategories is null)
         {
-            var destinationCategories = DestinationCategories?.Invoke();
-            if (destinationCategories is null)
-            {
-                return LoadWithCustomDestinations();
-            }
-            else
-            {
-                return LoadWithStrictDestinations(destinationCategories);
-            }
+            return LoadWithCustomDestinations();
         }
-
-        /// <summary>
-        /// Load the category map where we are generating the destinations on the fly.
-        /// </summary>
-        /// <returns>Returns the mapping of categories from the base to the destination.</returns>
-        private CategoryMap LoadWithCustomDestinations()
+        else
         {
-            var records = LoadMapRecords();
-            Categories destinationCategories = GetDestinationCategoriesFromRecords(records);
-            return Load(records, destinationCategories);
+            return LoadWithStrictDestinations(destinationCategories);
         }
+    }
 
-        /// <summary>
-        /// Load the category map where there are pre-defined destination categories.
-        /// </summary>
-        /// <param name="destinationCategories">The destination categories to map to.</param>
-        /// <returns>Returns the mapping of categories from the base to the destination.</returns>
-        private CategoryMap LoadWithStrictDestinations(Categories destinationCategories)
-        {
-            return Load(LoadMapRecords(), destinationCategories);
-        }
+    /// <summary>
+    /// Load the category map where we are generating the destinations on the fly.
+    /// </summary>
+    /// <returns>Returns the mapping of categories from the base to the destination.</returns>
+    private CategoryMap LoadWithCustomDestinations()
+    {
+        var records = LoadMapRecords();
+        Categories destinationCategories = GetDestinationCategoriesFromRecords(records);
+        return Load(records, destinationCategories);
+    }
 
-        /// <summary>
-        /// Generates a Categories object using the destinations specified in the loaded mapping records.
-        /// </summary>
-        /// <param name="records">The records of the map.</param>
-        /// <returns>A Categories object that represents the destinations from the records organized in ascending order.</returns>
-        /// <exception cref="XTMFRuntimeException">This throws when we are unable to create the categories object.</exception>
-        private Categories GetDestinationCategoriesFromRecords(List<(int baseSparseIndex, int destinationSparseIndex)> records)
-        {
-            string? error = null;
-            if(!Categories.CreateCategories(records
-                .Select(r => r.destinationSparseIndex)
-                .Distinct()
-                .OrderBy(r => r)
-                .ToList(), out var ret,ref error))
-            {
-                throw new XTMFRuntimeException(this, error);
-            }
-            return ret;
-        }
+    /// <summary>
+    /// Load the category map where there are pre-defined destination categories.
+    /// </summary>
+    /// <param name="destinationCategories">The destination categories to map to.</param>
+    /// <returns>Returns the mapping of categories from the base to the destination.</returns>
+    private CategoryMap LoadWithStrictDestinations(Categories destinationCategories)
+    {
+        return Load(LoadMapRecords(), destinationCategories);
+    }
 
-        /// <summary>
-        /// Creates the CategoryMap using the sparse records and destination categories.
-        /// </summary>
-        /// <param name="records">The records in sparse-space for the map.</param>
-        /// <param name="destinationCategories">The destination categories that we will check for.</param>
-        /// <returns>Returns a category map between the Base categories and the Destination categories.</returns>
-        /// <exception cref="XTMFRuntimeException">This is thrown if there is a sparse-record that is not defined in their respective category.</exception>
-        private CategoryMap Load(List<(int baseSparseIndex, int destinationSparseIndex)> records, Categories destinationCategories)
+    /// <summary>
+    /// Generates a Categories object using the destinations specified in the loaded mapping records.
+    /// </summary>
+    /// <param name="records">The records of the map.</param>
+    /// <returns>A Categories object that represents the destinations from the records organized in ascending order.</returns>
+    /// <exception cref="XTMFRuntimeException">This throws when we are unable to create the categories object.</exception>
+    private Categories GetDestinationCategoriesFromRecords(List<(int baseSparseIndex, int destinationSparseIndex)> records)
+    {
+        string? error = null;
+        if (!Categories.CreateCategories(records
+            .Select(r => r.destinationSparseIndex)
+            .Distinct()
+            .OrderBy(r => r)
+            .ToList(), out var ret, ref error))
         {
-            var baseCategories = BaseCategories!.Invoke();
-            var flatRecords = records
-                .Select(record =>
-                {
-                    var ret = (BaseIndex: baseCategories.GetFlatIndex(record.baseSparseIndex),
-                    DestinationIndex: destinationCategories.GetFlatIndex(record.destinationSparseIndex));
-                    if (ret.BaseIndex < 0)
-                    {
-                        ThrowBadBaseIndex(ret.BaseIndex);
-                    }
-                    if (ret.DestinationIndex < 0)
-                    {
-                        ThrowBadDestinationIndex(ret.DestinationIndex);
-                    }
-                    return ret;
-                }).ToList();
-            string? error = null;
-            if (!CategoryMap.CreateCategoryMap(baseCategories, destinationCategories, flatRecords, out var map, ref error))
-            {
-                throw new XTMFRuntimeException(this, error);
-            }
-            return map;
+            throw new XTMFRuntimeException(this, error);
         }
+        return ret;
+    }
 
-        /// <summary>
-        /// A helper function to throw if we load a sparse index that is not contained in the base categories.
-        /// </summary>
-        /// <param name="baseSparseIndex">The sparse index that was not found.</param>
-        /// <exception cref="XTMFRuntimeException">This always throws.</exception>
-        private void ThrowBadBaseIndex(int baseSparseIndex)
+    /// <summary>
+    /// Creates the CategoryMap using the sparse records and destination categories.
+    /// </summary>
+    /// <param name="records">The records in sparse-space for the map.</param>
+    /// <param name="destinationCategories">The destination categories that we will check for.</param>
+    /// <returns>Returns a category map between the Base categories and the Destination categories.</returns>
+    /// <exception cref="XTMFRuntimeException">This is thrown if there is a sparse-record that is not defined in their respective category.</exception>
+    private CategoryMap Load(List<(int baseSparseIndex, int destinationSparseIndex)> records, Categories destinationCategories)
+    {
+        var baseCategories = BaseCategories!.Invoke();
+        var flatRecords = records
+            .Select(record =>
+            {
+                var ret = (BaseIndex: baseCategories.GetFlatIndex(record.baseSparseIndex),
+                DestinationIndex: destinationCategories.GetFlatIndex(record.destinationSparseIndex));
+                if (ret.BaseIndex < 0)
+                {
+                    ThrowBadBaseIndex(ret.BaseIndex);
+                }
+                if (ret.DestinationIndex < 0)
+                {
+                    ThrowBadDestinationIndex(ret.DestinationIndex);
+                }
+                return ret;
+            }).ToList();
+        string? error = null;
+        if (!CategoryMap.CreateCategoryMap(baseCategories, destinationCategories, flatRecords, out var map, ref error))
         {
-            throw new XTMFRuntimeException(this, $"Found an invalid base category sparse index {baseSparseIndex} while loading in the category map!");
+            throw new XTMFRuntimeException(this, error);
         }
+        return map;
+    }
 
-        /// <summary>
-        /// A helper function to throw if we load a sparse index that is not contained in the destination categories.
-        /// </summary>
-        /// <param name="baseSparseIndex">The sparse index that was not found.</param>
-        /// <exception cref="XTMFRuntimeException">This always throws.</exception>
-        private void ThrowBadDestinationIndex(int destinationSparseIndex)
-        {
-            throw new XTMFRuntimeException(this, $"Found an invalid destination category sparse index {destinationSparseIndex} while loading in the category map!");
-        }
+    /// <summary>
+    /// A helper function to throw if we load a sparse index that is not contained in the base categories.
+    /// </summary>
+    /// <param name="baseSparseIndex">The sparse index that was not found.</param>
+    /// <exception cref="XTMFRuntimeException">This always throws.</exception>
+    private void ThrowBadBaseIndex(int baseSparseIndex)
+    {
+        throw new XTMFRuntimeException(this, $"Found an invalid base category sparse index {baseSparseIndex} while loading in the category map!");
+    }
 
-        /// <summary>
-        /// Loads the sparse-index mapping records from the stream.
-        /// </summary>
-        /// <returns>The sparse-indexed records.</returns>
-        /// <exception cref="XTMFRuntimeException">This is thrown if we are unable to properly parse a line.</exception>
-        private List<(int baseSparseIndex, int destinationSparseIndex)> LoadMapRecords()
+    /// <summary>
+    /// A helper function to throw if we load a sparse index that is not contained in the destination categories.
+    /// </summary>
+    /// <param name="baseSparseIndex">The sparse index that was not found.</param>
+    /// <exception cref="XTMFRuntimeException">This always throws.</exception>
+    private void ThrowBadDestinationIndex(int destinationSparseIndex)
+    {
+        throw new XTMFRuntimeException(this, $"Found an invalid destination category sparse index {destinationSparseIndex} while loading in the category map!");
+    }
+
+    /// <summary>
+    /// Loads the sparse-index mapping records from the stream.
+    /// </summary>
+    /// <returns>The sparse-indexed records.</returns>
+    /// <exception cref="XTMFRuntimeException">This is thrown if we are unable to properly parse a line.</exception>
+    private List<(int baseSparseIndex, int destinationSparseIndex)> LoadMapRecords()
+    {
+        var baseColumn = BaseColumn!.Invoke();
+        var destinationColumn = DestinationColumn!.Invoke();
+        int requiredColumns = Math.Max(baseColumn, destinationColumn) + 1;
+        var streamReader = new CsvReader(CSVStream!.Invoke(), true);
+        var records = new List<(int baseSparseIndex, int destinationSparseIndex)>();
+        try
         {
-            var baseColumn = BaseColumn!.Invoke();
-            var destinationColumn = DestinationColumn!.Invoke();
-            int requiredColumns = Math.Max(baseColumn, destinationColumn) + 1;
-            var streamReader = new CsvReader(CSVStream!.Invoke(), true);
-            var records = new List<(int baseSparseIndex, int destinationSparseIndex)>();
-            try
+            while (streamReader.LoadLine(out int columns))
             {
-                while (streamReader.LoadLine(out int columns))
+                if (columns >= requiredColumns)
                 {
-                    if (columns >= requiredColumns)
-                    {
-                        streamReader.Get(out int baseSparseIndex, baseColumn);
-                        streamReader.Get(out int destinationSparseIndex, destinationColumn);
-                        records.Add((baseSparseIndex, destinationSparseIndex));
-                    }
+                    streamReader.Get(out int baseSparseIndex, baseColumn);
+                    streamReader.Get(out int destinationSparseIndex, destinationColumn);
+                    records.Add((baseSparseIndex, destinationSparseIndex));
                 }
             }
-            catch
-            {
-                throw new XTMFRuntimeException(this, $"Unable to read category map from {streamReader.FileName} on line {streamReader.LineNumber}!");
-            }
-
-            return records;
         }
+        catch
+        {
+            throw new XTMFRuntimeException(this, $"Unable to read category map from {streamReader.FileName} on line {streamReader.LineNumber}!");
+        }
+
+        return records;
     }
 }
+
diff --git a/src/TMG-Framework/Loading/LoadMatrixFromCSVMatrix.cs b/src/TMG-Framework/Loading/LoadMatrixFromCSVMatrix.cs
index 28ed1f5..907f829 100644
--- a/src/TMG-Framework/Loading/LoadMatrixFromCSVMatrix.cs
+++ b/src/TMG-Framework/Loading/LoadMatrixFromCSVMatrix.cs
@@ -16,63 +16,58 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
+
 using TMG.Utilities;
-using XTMF2;
 
-namespace TMG.Loading
+namespace TMG.Loading;
+
+[Module(Name = "Load Matrix From CSV", Description = "Loads a matrix of data in the shape of the SparseMap from a CSV in third normalized form.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public sealed class LoadMatrixFromCSVMatrix : BaseFunction<ReadStream, Matrix>
 {
-    [Module(Name = "Load Matrix From CSV", Description = "Loads a matrix of data in the shape of the SparseMap from a CSV in third normalized form.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public sealed class LoadMatrixFromCSVMatrix : BaseFunction<ReadStream, Matrix>
-    {
-        [SubModule(Required = true, Name = "Row Categories", Description = "The sparse map this vector will be shaped in.", Index = 0)]
-        public IFunction<Categories> RowCategories = null!;
+    [SubModule(Required = true, Name = "Row Categories", Description = "The sparse map this vector will be shaped in.", Index = 0)]
+    public IFunction<Categories> RowCategories = null!;
 
-        [SubModule(Required = true, Name = "Column Categories", Description = "The sparse map this vector will be shaped in.", Index = 1)]
-        public IFunction<Categories> ColumnCategories = null!;
+    [SubModule(Required = true, Name = "Column Categories", Description = "The sparse map this vector will be shaped in.", Index = 1)]
+    public IFunction<Categories> ColumnCategories = null!;
 
-        public override Matrix Invoke(ReadStream stream)
+    public override Matrix Invoke(ReadStream stream)
+    {
+        var columnCategories = ColumnCategories.Invoke();
+        var rowCategories = RowCategories.Invoke();
+        var ret = new Matrix(rowCategories, columnCategories);
+        var flatData = ret.Data;
+        var rowSize = columnCategories.Count;
+        using (var reader = new CsvReader(stream, true))
         {
-            var columnCategories = ColumnCategories.Invoke();
-            var rowCategories = RowCategories.Invoke();
-            var ret = new Matrix(rowCategories, columnCategories);
-            var flatData = ret.Data;
-            var rowSize = columnCategories.Count;
-            using (var reader = new CsvReader(stream, true))
+            var headers = reader.Headers;
+            // read in the destination indexes
+            int[] destinationFlatIndex = new int[headers.Length - 1];
+            for (int i = 1; i < headers.Length; i++)
             {
-                var headers = reader.Headers;
-                // read in the destination indexes
-                int[] destinationFlatIndex = new int[headers.Length - 1];
-                for (int i = 1; i < headers.Length; i++)
+                var sparseIndex = int.Parse(headers[i]);
+                if ((destinationFlatIndex[i - 1] = columnCategories.GetFlatIndex(sparseIndex)) < 0)
                 {
-                    var sparseIndex = int.Parse(headers[i]);
-                    if((destinationFlatIndex[i - 1] = columnCategories.GetFlatIndex(sparseIndex)) < 0)
-                    {
-                        throw new XTMFRuntimeException(this, $"Invalid sparse column index {sparseIndex}!");
-                    }
+                    throw new XTMFRuntimeException(this, $"Invalid sparse column index {sparseIndex}!");
                 }
-                while(reader.LoadLine(out var columns))
+            }
+            while (reader.LoadLine(out var columns))
+            {
+                if (columns >= destinationFlatIndex.Length + 1)
                 {
-                    if(columns >= destinationFlatIndex.Length + 1)
+                    reader.Get(out int sparseIndex, 0);
+                    var originOffset = rowCategories.GetFlatIndex(sparseIndex) * rowSize;
+                    if (originOffset < 0)
+                    {
+                        throw new XTMFRuntimeException(this, $"Invalid sparse row index {sparseIndex}!");
+                    }
+                    for (int i = 0; i < destinationFlatIndex.Length; i++)
                     {
-                        reader.Get(out int sparseIndex, 0);
-                        var originOffset = rowCategories.GetFlatIndex(sparseIndex) * rowSize;
-                        if(originOffset < 0)
-                        {
-                            throw new XTMFRuntimeException(this, $"Invalid sparse row index {sparseIndex}!");
-                        }
-                        for (int i = 0; i < destinationFlatIndex.Length; i++)
-                        {
-                            reader.Get(out flatData[originOffset + destinationFlatIndex[i]], i + 1);
-                        }
+                        reader.Get(out flatData[originOffset + destinationFlatIndex[i]], i + 1);
                     }
                 }
             }
-            return ret;
         }
+        return ret;
     }
 }
diff --git a/src/TMG-Framework/Loading/LoadMatrixFromCSVThirdNormalized.cs b/src/TMG-Framework/Loading/LoadMatrixFromCSVThirdNormalized.cs
index 147515a..9088c6b 100644
--- a/src/TMG-Framework/Loading/LoadMatrixFromCSVThirdNormalized.cs
+++ b/src/TMG-Framework/Loading/LoadMatrixFromCSVThirdNormalized.cs
@@ -16,80 +16,76 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
+
 using TMG.Utilities;
-using XTMF2;
 
-namespace TMG.Loading
+namespace TMG.Loading;
+
+[Module(Name = "Load Matrix From CSV", Description = "Loads a matrix of data in the shape of the SparseMap from a CSV in third normalized form.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public sealed class LoadMatrixFromCSVThirdNormalized : BaseFunction<ReadStream, Matrix>
 {
-    [Module(Name = "Load Matrix From CSV", Description = "Loads a matrix of data in the shape of the SparseMap from a CSV in third normalized form.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public sealed class LoadMatrixFromCSVThirdNormalized : BaseFunction<ReadStream, Matrix>
-    {
-        [SubModule(Required = true, Name = "Row Categories", Description = "The sparse map this vector will be shaped in.", Index = 0)]
-        public IFunction<Categories> RowCategories = null!;
+    [SubModule(Required = true, Name = "Row Categories", Description = "The sparse map this vector will be shaped in.", Index = 0)]
+    public IFunction<Categories> RowCategories = null!;
 
-        [SubModule(Required = true, Name = "Column Categories", Description = "The sparse map this vector will be shaped in.", Index = 1)]
-        public IFunction<Categories> ColumnCategories = null!;
+    [SubModule(Required = true, Name = "Column Categories", Description = "The sparse map this vector will be shaped in.", Index = 1)]
+    public IFunction<Categories> ColumnCategories = null!;
 
-        [Parameter(DefaultValue = "0", Name = "Origin Column", Index = 2, Description = "The 0 indexed column containing the sparse map index for the origin.")]
-        public IFunction<int> OriginColumn = null!;
+    [Parameter(DefaultValue = "0", Name = "Origin Column", Index = 2, Description = "The 0 indexed column containing the sparse map index for the origin.")]
+    public IFunction<int> OriginColumn = null!;
 
-        [Parameter(DefaultValue = "1", Name = "Destination Column", Index = 3, Description = "The 0 indexed column containing the sparse map index for the destination.")]
-        public IFunction<int> DestinationColumn = null!;
+    [Parameter(DefaultValue = "1", Name = "Destination Column", Index = 3, Description = "The 0 indexed column containing the sparse map index for the destination.")]
+    public IFunction<int> DestinationColumn = null!;
 
-        [Parameter(DefaultValue = "2", Name = "Data Column", Index = 4, Description = "The 0 indexed column containing the data to load index.")]
-        public IFunction<int> DataColumn = null!;
+    [Parameter(DefaultValue = "2", Name = "Data Column", Index = 4, Description = "The 0 indexed column containing the data to load index.")]
+    public IFunction<int> DataColumn = null!;
 
-        public override Matrix Invoke(ReadStream stream)
+    public override Matrix Invoke(ReadStream stream)
+    {
+        var rowCategories = RowCategories.Invoke();
+        var columnCategories = ColumnCategories.Invoke();
+        var rowSize = rowCategories.Count;
+        var ret = new Matrix(rowCategories, columnCategories);
+        var data = ret.Data;
+        var originColumn = OriginColumn.Invoke();
+        var destinationColumn = DestinationColumn.Invoke();
+        var dataColumn = DataColumn.Invoke();
+        if (originColumn < 0 || destinationColumn < 0 || dataColumn < 0)
         {
-            var rowCategories = RowCategories.Invoke();
-            var columnCategories = ColumnCategories.Invoke();
-            var rowSize = rowCategories.Count;
-            var ret = new Matrix(rowCategories, columnCategories);
-            var data = ret.Data;
-            var originColumn = OriginColumn.Invoke();
-            var destinationColumn = DestinationColumn.Invoke();
-            var dataColumn = DataColumn.Invoke();
-            if (originColumn < 0 || destinationColumn < 0 || dataColumn < 0)
-            {
-                throw new XTMFRuntimeException(this, "Column indexes must be greater than or equal to zero!");
-            }
-            var minColumnSize = Math.Max(originColumn, dataColumn);
-            using (var reader = new CsvReader(stream, true))
+            throw new XTMFRuntimeException(this, "Column indexes must be greater than or equal to zero!");
+        }
+        var minColumnSize = Math.Max(originColumn, dataColumn);
+        using (var reader = new CsvReader(stream, true))
+        {
+            reader.LoadLine();
+            while (reader.LoadLine(out var columns))
             {
-                reader.LoadLine();
-                while (reader.LoadLine(out var columns))
+                // This is strictly greater because the column size is 0 indexed
+                if (columns > minColumnSize)
                 {
-                    // This is strictly greater because the column size is 0 indexed
-                    if (columns > minColumnSize)
+                    int flatOrigin, flatDestination;
+                    reader.Get(out int originIndex, originColumn);
+                    reader.Get(out int destinationIndex, originColumn);
+                    reader.Get(out float dataValue, dataColumn);
+                    if ((flatOrigin = rowCategories.GetFlatIndex(originIndex)) >= 0 && (flatDestination = columnCategories.GetFlatIndex(destinationIndex)) >= 0)
+                    {
+                        // if we know where to put it
+                        data[flatOrigin * rowSize + flatDestination] = dataValue;
+                    }
+                    else
                     {
-                        int flatOrigin, flatDestination;
-                        reader.Get(out int originIndex, originColumn);
-                        reader.Get(out int destinationIndex, originColumn);
-                        reader.Get(out float dataValue, dataColumn);
-                        if ((flatOrigin = rowCategories.GetFlatIndex(originIndex)) >= 0 && (flatDestination = columnCategories.GetFlatIndex(destinationIndex)) >= 0)
+                        if (flatOrigin < 0)
                         {
-                            // if we know where to put it
-                            data[flatOrigin * rowSize + flatDestination] = dataValue;
+                            throw new XTMFRuntimeException(this, $"An invalid origin was specified {originIndex}!");
                         }
                         else
                         {
-                            if (flatOrigin < 0)
-                            {
-                                throw new XTMFRuntimeException(this, $"An invalid origin was specified {originIndex}!");
-                            }
-                            else
-                            {
-                                throw new XTMFRuntimeException(this, $"An invalid destination was specified {destinationIndex}!");
-                            }
+                            throw new XTMFRuntimeException(this, $"An invalid destination was specified {destinationIndex}!");
                         }
                     }
                 }
             }
-            return ret;
         }
+        return ret;
     }
 }
diff --git a/src/TMG-Framework/Loading/LoadMatrixFromMTX.cs b/src/TMG-Framework/Loading/LoadMatrixFromMTX.cs
index 0967881..e653a8e 100644
--- a/src/TMG-Framework/Loading/LoadMatrixFromMTX.cs
+++ b/src/TMG-Framework/Loading/LoadMatrixFromMTX.cs
@@ -16,163 +16,155 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Text;
-using TMG.Utilities;
-using XTMF2;
-
-namespace TMG.Loading
+
+namespace TMG.Loading;
+
+[Module(Name = "Load SparseMatrix From MTX", Description = "Loads a matrix of data in the shape of the SparseMap from an EMME matrix file.",
+DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public sealed class LoadMatrixFromMTX : BaseFunction<ReadStream, Matrix>
 {
-    [Module(Name = "Load SparseMatrix From MTX", Description = "Loads a matrix of data in the shape of the SparseMap from an EMME matrix file.",
-    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public sealed class LoadMatrixFromMTX : BaseFunction<ReadStream, Matrix>
-    {
-        [SubModule(Required = true, Name = "Map", Description = "The sparse map this vector will be shaped in.", Index = 0)]
-        public IFunction<Categories> Categories = null!;
+    [SubModule(Required = true, Name = "Map", Description = "The sparse map this vector will be shaped in.", Index = 0)]
+    public IFunction<Categories> Categories = null!;
 
-        [Parameter(Name = "Convert Between Zone Systems", DefaultValue = "false", Description = "A function that converts between the zone system of the matrix and the zone system of the map.", Index = 1)]
-        public IFunction<bool> ConvertBetweenZoneSystems = null!;
+    [Parameter(Name = "Convert Between Zone Systems", DefaultValue = "false", Description = "A function that converts between the zone system of the matrix and the zone system of the map.", Index = 1)]
+    public IFunction<bool> ConvertBetweenZoneSystems = null!;
 
-        private const uint MagicNumber = 0xC4D4F1B2;
+    private const uint MagicNumber = 0xC4D4F1B2;
 
-        private const int FloatType = 0x1;
+    private const int FloatType = 0x1;
 
-        public override Matrix Invoke(ReadStream context)
+    public override Matrix Invoke(ReadStream context)
+    {
+        var categories = Categories.Invoke();
+        var matrix = new Matrix(categories, categories);
+        using (var reader = new BinaryReader(context))
         {
-            var categories = Categories.Invoke();
-            var matrix = new Matrix(categories, categories);
-            using (var reader = new BinaryReader(context))
+            var magic = reader.ReadUInt32();
+            if (magic != MagicNumber)
             {
-                var magic = reader.ReadUInt32();
-                if(magic != MagicNumber)
-                {
-                    throw new XTMFRuntimeException(this, "The file was not an EMME matrix!");
-                }
-                // version
-                reader.ReadInt32();
-                var type = reader.ReadInt32();
-                if(type != FloatType)
-                {
-                    throw new XTMFRuntimeException(this, "The matrix was not using a float type!");
-                }
-                var numberOfIndexes = reader.ReadInt32();
-                if(numberOfIndexes != 2)
-                {
-                    throw new XTMFRuntimeException(this, $"The matrix contained {numberOfIndexes} dimensions!");
-                }
-
-                var convert = ConvertBetweenZoneSystems.Invoke();
-                if(!convert)
-                {
-                    LoadWithoutConversion(categories, matrix, reader);
-                }
-                else
-                {
-                    LoadWithConversion(categories, matrix, reader);
-                }
+                throw new XTMFRuntimeException(this, "The file was not an EMME matrix!");
             }
-            return matrix;
-        }
-
-        private void LoadWithoutConversion(Categories categories, Matrix matrix, BinaryReader reader)
-        {
-            int firstSize = reader.ReadInt32();
-            int secondSize = reader.ReadInt32();
-            if (categories.Count != firstSize)
+            // version
+            reader.ReadInt32();
+            var type = reader.ReadInt32();
+            if (type != FloatType)
             {
-                throw new XTMFRuntimeException(this, "The matrix had the wrong number of elements in the first dimension!");
+                throw new XTMFRuntimeException(this, "The matrix was not using a float type!");
             }
-            if (categories.Count != secondSize)
+            var numberOfIndexes = reader.ReadInt32();
+            if (numberOfIndexes != 2)
             {
-                throw new XTMFRuntimeException(this, "The matrix had the wrong number of elements in the second dimension!");
+                throw new XTMFRuntimeException(this, $"The matrix contained {numberOfIndexes} dimensions!");
             }
-            ValidateIndexes(reader, categories);
-            ValidateIndexes(reader, categories);
 
-            var data = matrix.Data;
-            var dataSize = data.Length * sizeof(float);
-            var soFar = 0;
-            while (soFar < dataSize)
+            var convert = ConvertBetweenZoneSystems.Invoke();
+            if (!convert)
             {
-                var amount = reader.Read(MemoryMarshal.Cast<float, byte>(data)[soFar..dataSize]);
-                if (amount == 0)
-                {
-                    throw new XTMFRuntimeException(this, $"The matrix expected {dataSize}bytes but we only could get {soFar}bytes!");
-                }
-                soFar += amount;
+                LoadWithoutConversion(categories, matrix, reader);
+            }
+            else
+            {
+                LoadWithConversion(categories, matrix, reader);
             }
         }
+        return matrix;
+    }
+
+    private void LoadWithoutConversion(Categories categories, Matrix matrix, BinaryReader reader)
+    {
+        int firstSize = reader.ReadInt32();
+        int secondSize = reader.ReadInt32();
+        if (categories.Count != firstSize)
+        {
+            throw new XTMFRuntimeException(this, "The matrix had the wrong number of elements in the first dimension!");
+        }
+        if (categories.Count != secondSize)
+        {
+            throw new XTMFRuntimeException(this, "The matrix had the wrong number of elements in the second dimension!");
+        }
+        ValidateIndexes(reader, categories);
+        ValidateIndexes(reader, categories);
 
-        private void LoadWithConversion(Categories categories, Matrix matrix, BinaryReader reader)
+        var data = matrix.Data;
+        var dataSize = data.Length * sizeof(float);
+        var soFar = 0;
+        while (soFar < dataSize)
         {
-            int rowSize = reader.ReadInt32();
-            int columnSize = reader.ReadInt32();
-            
-            if (rowSize != columnSize)
+            var amount = reader.Read(MemoryMarshal.Cast<float, byte>(data)[soFar..dataSize]);
+            if (amount == 0)
             {
-                throw new XTMFRuntimeException(this, "The matrix was not square!");
+                throw new XTMFRuntimeException(this, $"The matrix expected {dataSize}bytes but we only could get {soFar}bytes!");
             }
+            soFar += amount;
+        }
+    }
 
-            // Load in the column categories (sparse space)
-            var rows = new int[rowSize];
-            var columns = new int[columnSize];
+    private void LoadWithConversion(Categories categories, Matrix matrix, BinaryReader reader)
+    {
+        int rowSize = reader.ReadInt32();
+        int columnSize = reader.ReadInt32();
 
-            reader.ReadExactly(MemoryMarshal.Cast<int, byte>(rows.AsSpan()));
-            reader.ReadExactly(MemoryMarshal.Cast<int, byte>(columns.AsSpan()));
+        if (rowSize != columnSize)
+        {
+            throw new XTMFRuntimeException(this, "The matrix was not square!");
+        }
+
+        // Load in the column categories (sparse space)
+        var rows = new int[rowSize];
+        var columns = new int[columnSize];
 
-            // Load in the matrix data
-            var numberOfElements = rowSize * columnSize;
-            var dataSize = numberOfElements * sizeof(float);
-            var data = new float[numberOfElements];
-            var dataSpan = data.AsSpan();
-            var soFar = 0;
-            while (soFar < dataSize)
+        reader.ReadExactly(MemoryMarshal.Cast<int, byte>(rows.AsSpan()));
+        reader.ReadExactly(MemoryMarshal.Cast<int, byte>(columns.AsSpan()));
+
+        // Load in the matrix data
+        var numberOfElements = rowSize * columnSize;
+        var dataSize = numberOfElements * sizeof(float);
+        var data = new float[numberOfElements];
+        var dataSpan = data.AsSpan();
+        var soFar = 0;
+        while (soFar < dataSize)
+        {
+            var amount = reader.Read(MemoryMarshal.Cast<float, byte>(dataSpan)[soFar..dataSize]);
+            if (amount == 0)
             {
-                var amount = reader.Read(MemoryMarshal.Cast<float, byte>(dataSpan)[soFar..dataSize]);
-                if (amount == 0)
-                {
-                    throw new XTMFRuntimeException(this, $"The matrix expected {dataSize}bytes but we only could get {soFar}bytes!");
-                }
-                soFar += amount;
+                throw new XTMFRuntimeException(this, $"The matrix expected {dataSize}bytes but we only could get {soFar}bytes!");
             }
+            soFar += amount;
+        }
 
-            ref var matrixData = ref MemoryMarshal.GetReference(matrix.Data);
-            ref var rData = ref MemoryMarshal.GetReference(dataSpan);
-            var matrixColumnSize = matrix.NumberOfColumns;
-            for (int i = 0; i < rowSize; i++)
+        ref var matrixData = ref MemoryMarshal.GetReference(matrix.Data);
+        ref var rData = ref MemoryMarshal.GetReference(dataSpan);
+        var matrixColumnSize = matrix.NumberOfColumns;
+        for (int i = 0; i < rowSize; i++)
+        {
+            var rowIndex = categories.GetFlatIndex(rows[i]);
+            if (rowIndex < 0)
             {
-                var rowIndex = categories.GetFlatIndex(rows[i]);
-                if (rowIndex < 0)
-                {
-                    continue;
-                }
-                for (int j = 0; j < columnSize; j++)
+                continue;
+            }
+            for (int j = 0; j < columnSize; j++)
+            {
+                var columnIndex = categories.GetFlatIndex(columns[j]);
+                if (columnIndex >= 0)
                 {
-                    var columnIndex = categories.GetFlatIndex(columns[j]);
-                    if (columnIndex >= 0)
-                    {
-                        ref var writeTo = ref Unsafe.Add(ref matrixData, rowIndex * matrixColumnSize + columnIndex);
-                        writeTo = Unsafe.Add(ref rData, i * columnSize + j);
-                    }
+                    ref var writeTo = ref Unsafe.Add(ref matrixData, rowIndex * matrixColumnSize + columnIndex);
+                    writeTo = Unsafe.Add(ref rData, i * columnSize + j);
                 }
             }
         }
+    }
 
-        private void ValidateIndexes(BinaryReader reader, Categories categories)
+    private void ValidateIndexes(BinaryReader reader, Categories categories)
+    {
+        var length = categories.Count;
+        for (int i = 0; i < length; i++)
         {
-            var length = categories.Count;
-            for (int i = 0; i < length; i++)
+            var index = reader.ReadInt32();
+            if (index != categories.GetSparseIndex(i))
             {
-                var index = reader.ReadInt32();
-                if(index != categories.GetSparseIndex(i))
-                {
-                    throw new XTMFRuntimeException(this, $"The matrix file has an index of {index} where we were expecting an index of {categories.GetSparseIndex(i)}!");
-                }
+                throw new XTMFRuntimeException(this, $"The matrix file has an index of {index} where we were expecting an index of {categories.GetSparseIndex(i)}!");
             }
         }
     }
 }
+
diff --git a/src/TMG-Framework/Loading/LoadVectorFromCSV.cs b/src/TMG-Framework/Loading/LoadVectorFromCSV.cs
index 50c13df..338b12d 100644
--- a/src/TMG-Framework/Loading/LoadVectorFromCSV.cs
+++ b/src/TMG-Framework/Loading/LoadVectorFromCSV.cs
@@ -16,62 +16,58 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
+
 using TMG.Utilities;
-using XTMF2;
 
-namespace TMG.Loading
+namespace TMG.Loading;
+
+[Module(Name = "Load Vector From CSV", Description = "Loads a map where each row has a different sparse index.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public sealed class LoadVectorFromCSV : BaseFunction<ReadStream, Vector>
 {
-    [Module(Name = "Load Vector From CSV", Description = "Loads a map where each row has a different sparse index.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public sealed class LoadVectorFromCSV : BaseFunction<ReadStream, Vector>
-    {
-        [SubModule(Required = true, Name = "Categories", Description = "The sparse map this vector will be shaped in.", Index = 0)]
-        public IFunction<Categories> Categories = null!;
+    [SubModule(Required = true, Name = "Categories", Description = "The sparse map this vector will be shaped in.", Index = 0)]
+    public IFunction<Categories> Categories = null!;
 
-        [Parameter(DefaultValue = "0", Name = "Map Column", Index = 1, Description = "The 0 indexed column containing the sparse map index.")]
-        public IFunction<int> MapColumn = null!;
+    [Parameter(DefaultValue = "0", Name = "Map Column", Index = 1, Description = "The 0 indexed column containing the sparse map index.")]
+    public IFunction<int> MapColumn = null!;
 
-        [Parameter(DefaultValue = "1", Name = "Data Column", Index = 2, Description = "The 0 indexed column containing the data to load index.")]
-        public IFunction<int> DataColumn = null!;
+    [Parameter(DefaultValue = "1", Name = "Data Column", Index = 2, Description = "The 0 indexed column containing the data to load index.")]
+    public IFunction<int> DataColumn = null!;
 
-        public override Vector Invoke(ReadStream stream)
+    public override Vector Invoke(ReadStream stream)
+    {
+        var map = Categories.Invoke();
+        var ret = new Vector(map);
+        var data = ret.Data;
+        var mapColumn = MapColumn.Invoke();
+        var dataColumn = DataColumn.Invoke();
+        if (mapColumn < 0 || dataColumn < 0)
         {
-            var map = Categories.Invoke();
-            var ret = new Vector(map);
-            var data = ret.Data;
-            var mapColumn = MapColumn.Invoke();
-            var dataColumn = DataColumn.Invoke();
-            if(mapColumn < 0 || dataColumn < 0)
-            {
-                throw new XTMFRuntimeException(this, "Column indexes must be greater than or equal to zero!");
-            }
-            var minColumnSize = Math.Max(mapColumn, dataColumn);
-            using (var reader = new CsvReader(stream, true))
+            throw new XTMFRuntimeException(this, "Column indexes must be greater than or equal to zero!");
+        }
+        var minColumnSize = Math.Max(mapColumn, dataColumn);
+        using (var reader = new CsvReader(stream, true))
+        {
+            while (reader.LoadLine(out var columns))
             {
-                while(reader.LoadLine(out var columns))
+                // This is strictly greater because the column size is 0 indexed
+                if (columns > minColumnSize)
                 {
-                    // This is strictly greater because the column size is 0 indexed
-                    if(columns > minColumnSize)
+                    int flatIndex;
+                    reader.Get(out int mapIndex, mapColumn);
+                    reader.Get(out float dataValue, dataColumn);
+                    if ((flatIndex = map.GetFlatIndex(mapIndex)) >= 0)
+                    {
+                        // if we know where to put it
+                        data[flatIndex] = dataValue;
+                    }
+                    else
                     {
-                        int flatIndex;
-                        reader.Get(out int mapIndex, mapColumn);
-                        reader.Get(out float dataValue, dataColumn);
-                        if((flatIndex = map.GetFlatIndex(mapIndex)) >= 0)
-                        {
-                            // if we know where to put it
-                            data[flatIndex] = dataValue;
-                        }
-                        else
-                        {
-                            throw new XTMFRuntimeException(this, $"An invalid sparse map index was specified {mapIndex}!");
-                        }
+                        throw new XTMFRuntimeException(this, $"An invalid sparse map index was specified {mapIndex}!");
                     }
                 }
             }
-            return ret;
         }
+        return ret;
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/ASTNode.cs b/src/TMG-Framework/Processing/AST/ASTNode.cs
index f1e7b84..8b3fe02 100644
--- a/src/TMG-Framework/Processing/AST/ASTNode.cs
+++ b/src/TMG-Framework/Processing/AST/ASTNode.cs
@@ -17,92 +17,87 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System.Diagnostics.CodeAnalysis;
-using XTMF2;
-using TMG.Utilities;
+namespace TMG.Frameworks.Data.Processing.AST;
 
-namespace TMG.Frameworks.Data.Processing.AST
+public abstract class AstNode
 {
-    public abstract class AstNode
+    /// <summary>
+    /// The starting point of the node
+    /// </summary>
+    internal readonly int Start;
+
+    protected AstNode(int start)
     {
-        /// <summary>
-        /// The starting point of the node
-        /// </summary>
-        internal readonly int Start;
+        Start = start;
+    }
 
-        protected AstNode(int start)
-        {
-            Start = start;
-        }
+    public abstract ComputationResult Evaluate(IModule[] dataSources);
 
-        public abstract ComputationResult Evaluate(IModule[] dataSources);
+    internal abstract bool OptimizeAst(
+        ref Expression ex,
+        [NotNullWhen(false)] ref string? error);
+}
 
-        internal abstract bool OptimizeAst(
-            ref Expression ex,
-            [NotNullWhen(false)] ref string? error);
-    }
+public class ComputationResult
+{
+    public bool IsOdResult => OdData is not null;
 
-    public class ComputationResult
-    {
-        public bool IsOdResult => OdData is not null;
+    public bool IsVectorResult => VectorData is not null;
 
-        public bool IsVectorResult => VectorData is not null;
+    public bool Error => ErrorMessage is not null;
 
-        public bool Error => ErrorMessage is not null;
+    public string? ErrorMessage { get; private set; }
 
-        public string? ErrorMessage { get; private set; }
+    public bool Accumulator { get; private set; }
 
-        public bool Accumulator { get; private set; }
+    public enum VectorDirection
+    {
+        Unassigned,
+        Horizontal,
+        Vertical
+    }
 
-        public enum VectorDirection
-        {
-            Unassigned,
-            Horizontal,
-            Vertical
-        }
+    public VectorDirection Direction { get; private set; }
 
-        public VectorDirection Direction { get; private set; }
+    public Matrix OdData { get; }
 
-        public Matrix OdData { get; }
+    public Vector VectorData { get; }
 
-        public Vector VectorData { get; }
+    public float LiteralValue { get; }
 
-        public float LiteralValue { get; }
-        
-        public bool IsValue => !IsOdResult && !IsVectorResult && !Error;
+    public bool IsValue => !IsOdResult && !IsVectorResult && !Error;
 
-// TODO: Get these warnings fixes once we have the time to do so. For now, we will just suppress them.
+    // TODO: Get these warnings fixes once we have the time to do so. For now, we will just suppress them.
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
-        public ComputationResult(float value)
-        {
-            LiteralValue = value;
-        }
-
-        public ComputationResult(Matrix data, bool accumulator)
-        {
-            OdData = data;
-            Accumulator = accumulator;
-        }
-
-        public ComputationResult(Vector data, bool accumulator, VectorDirection direction = VectorDirection.Unassigned)
-        {
-            VectorData = data;
-            Accumulator = accumulator;
-            Direction = direction;
-        }
-
-        public ComputationResult(ComputationResult res, VectorDirection direction)
-        {
-            OdData = res.OdData;
-            LiteralValue = res.LiteralValue;
-            VectorData = res.VectorData;
-            Direction = direction;
-        }
-
-        public ComputationResult(string errorMessage)
-        {
-            ErrorMessage = errorMessage;
-        }
-    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
+    public ComputationResult(float value)
+    {
+        LiteralValue = value;
+    }
+
+    public ComputationResult(Matrix data, bool accumulator)
+    {
+        OdData = data;
+        Accumulator = accumulator;
+    }
+
+    public ComputationResult(Vector data, bool accumulator, VectorDirection direction = VectorDirection.Unassigned)
+    {
+        VectorData = data;
+        Accumulator = accumulator;
+        Direction = direction;
+    }
+
+    public ComputationResult(ComputationResult res, VectorDirection direction)
+    {
+        OdData = res.OdData;
+        LiteralValue = res.LiteralValue;
+        VectorData = res.VectorData;
+        Direction = direction;
+    }
+
+    public ComputationResult(string errorMessage)
+    {
+        ErrorMessage = errorMessage;
     }
+#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
 }
diff --git a/src/TMG-Framework/Processing/AST/Add.cs b/src/TMG-Framework/Processing/AST/Add.cs
index e1a915f..8e2a255 100644
--- a/src/TMG-Framework/Processing/AST/Add.cs
+++ b/src/TMG-Framework/Processing/AST/Add.cs
@@ -17,195 +17,193 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
-using System.Diagnostics.CodeAnalysis;
 using TMG.Utilities;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public class Add : BinaryExpression
 {
-    public class Add : BinaryExpression
+    public Add(int start) : base(start)
+    {
+
+    }
+
+    internal override bool OptimizeAst(
+        ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
     {
-        public Add(int start) : base(start)
+        if (!base.OptimizeAst(ref ex, ref error))
+        {
+            return false;
+        }
+        if (!OptimizeFusedMultiplyAdd(ref ex, ref error)
+            || !OptimizeLiterals(ref ex, ref error))
         {
 
+            return false;
         }
+        return true;
+    }
 
-        internal override bool OptimizeAst(
-            ref Expression ex,
-            [NotNullWhen(false)] ref string? error)
+    private bool OptimizeLiterals(
+        [NotNullWhen(true)] ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        var lhs = Lhs as Literal;
+        var rhs = Rhs as Literal;
+        if (lhs != null && rhs != null)
         {
-            if(!base.OptimizeAst(ref ex, ref error))
-            {
-                return false;
-            }
-            if(!OptimizeFusedMultiplyAdd(ref ex, ref error)
-                || !OptimizeLiterals(ref ex, ref error))
-            {
-
-                return false;
-            }
+            ex = new Literal(Start, lhs.Value + rhs.Value);
             return true;
         }
+        return true;
+    }
 
-        private bool OptimizeLiterals(
-            [NotNullWhen(true)] ref Expression ex,
-            [NotNullWhen(false)] ref string? error)
+    private bool OptimizeFusedMultiplyAdd(
+        ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        var lhsMul = Lhs as Multiply;
+        var rhsMul = Rhs as Multiply;
+        if (lhsMul is not null)
         {
-            var lhs = Lhs as Literal;
-            var rhs = Rhs as Literal;
-            if(lhs != null && rhs != null)
+            ex = new FusedMultiplyAdd(Start, Rhs?.Start ?? -1)
             {
-                ex = new Literal(Start, lhs.Value + rhs.Value);
-                return true;
-            }
-            return true;
+                MulLhs = lhsMul.Lhs,
+                MulRhs = lhsMul.Rhs,
+                Add = Rhs
+            };
+        }
+        else if (rhsMul != null)
+        {
+            ex = new FusedMultiplyAdd(Start, Lhs?.Start ?? -1)
+            {
+                MulLhs = rhsMul.Lhs,
+                MulRhs = rhsMul.Rhs,
+                Add = Lhs
+            };
         }
+        return true;
+    }
 
-        private bool OptimizeFusedMultiplyAdd(
-            ref Expression ex,
-            [NotNullWhen(false)] ref string? error)
+    public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    {
+        // see if we have two values, in this case we can skip doing the matrix operation
+        if (lhs.IsValue && rhs.IsValue)
+        {
+            return new ComputationResult(lhs.LiteralValue + rhs.LiteralValue);
+        }
+        // float / matrix
+        if (lhs.IsValue)
         {
-            var lhsMul = Lhs as Multiply;
-            var rhsMul = Rhs as Multiply;
-            if (lhsMul is not null)
+            if (rhs.IsVectorResult)
             {
-                ex = new FusedMultiplyAdd(Start, Rhs?.Start ?? -1)
-                {
-                    MulLhs = lhsMul.Lhs,
-                    MulRhs = lhsMul.Rhs,
-                    Add = Rhs
-                };
+                var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData.Categories);
+                var flat = retVector.Data;
+                VectorHelper.Add(flat, rhs.VectorData.Data, lhs.LiteralValue);
+                return new ComputationResult(retVector, true);
             }
-            else if (rhsMul != null)
+            else
             {
-                ex = new FusedMultiplyAdd(Start, Lhs?.Start ?? -1)
-                { 
-                    MulLhs = rhsMul.Lhs,
-                    MulRhs = rhsMul.Rhs,
-                    Add = Lhs
-                };
+                var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData.RowCategories, rhs.OdData.ColumnCategories);
+                VectorHelper.Add(retMatrix.Data, rhs.OdData.Data, lhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
             }
-            return true;
         }
-
-        public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+        else if (rhs.IsValue)
         {
-            // see if we have two values, in this case we can skip doing the matrix operation
-            if (lhs.IsValue && rhs.IsValue)
+            if (lhs.IsVectorResult)
             {
-                return new ComputationResult(lhs.LiteralValue + rhs.LiteralValue);
+                var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData.Categories);
+                var flat = retVector.Data;
+                VectorHelper.Add(flat, lhs.VectorData.Data, rhs.LiteralValue);
+                return new ComputationResult(retVector, true);
             }
-            // float / matrix
-            if (lhs.IsValue)
+            else
             {
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData.Categories);
-                    var flat = retVector.Data;
-                    VectorHelper.Add(flat, rhs.VectorData.Data, lhs.LiteralValue);
-                    return new ComputationResult(retVector, true);
-                }
-                else
-                {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData.RowCategories, rhs.OdData.ColumnCategories);
-                    VectorHelper.Add(retMatrix.Data, rhs.OdData.Data, lhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
-                }
+                // matrix / float
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData.RowCategories, lhs.OdData.ColumnCategories);
+                VectorHelper.Add(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
             }
-            else if (rhs.IsValue)
+        }
+        else
+        {
+            if (lhs.IsVectorResult || rhs.IsVectorResult)
             {
-                if (lhs.IsVectorResult)
+                if (lhs.IsVectorResult && rhs.IsVectorResult)
                 {
-                    var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData.Categories);
-                    var flat = retVector.Data;
-                    VectorHelper.Add(flat, lhs.VectorData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retVector, true);
-                }
-                else
-                {
-                    // matrix / float
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData.RowCategories, lhs.OdData.ColumnCategories);
-                    VectorHelper.Add(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
+                    var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+                    VectorHelper.Add(retMatrix.Data, 0, lhs.VectorData.Data, 0, rhs.VectorData.Data, 0, retMatrix.Data.Length);
+                    return new ComputationResult(retMatrix, true, lhs.Direction);
                 }
-            }
-            else
-            {
-                if (lhs.IsVectorResult || rhs.IsVectorResult)
+                else if (lhs.IsVectorResult)
                 {
-                    if (lhs.IsVectorResult && rhs.IsVectorResult)
-                    {
-                        var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.Add(retMatrix.Data, 0, lhs.VectorData.Data, 0, rhs.VectorData.Data, 0, retMatrix.Data.Length);
-                        return new ComputationResult(retMatrix, true, lhs.Direction);
-                    }
-                    else if (lhs.IsVectorResult)
+                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData.RowCategories, rhs.OdData.ColumnCategories);
+                    var flatLhs = lhs.VectorData.Data;
+                    var rowSize = flatLhs.Length;
+                    if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
-                        var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData.RowCategories, rhs.OdData.ColumnCategories);
-                        var flatLhs = lhs.VectorData.Data;
-                        var rowSize = flatLhs.Length;
-                        if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var rhsRow = rhs.OdData.GetRow(i);
-                                VectorHelper.Add(retRow, rhsRow, flatLhs[i]);
-                            }
+                            var retRow = retMatrix.GetRow(i);
+                            var rhsRow = rhs.OdData.GetRow(i);
+                            VectorHelper.Add(retRow, rhsRow, flatLhs[i]);
                         }
-                        else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var rhsRow = rhs.OdData.GetRow(i);
-                                VectorHelper.Add(retRow, rhsRow, flatLhs);
-                            }
-                        }
-                        else
+                    }
+                    else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            var retRow = retMatrix.GetRow(i);
+                            var rhsRow = rhs.OdData.GetRow(i);
+                            VectorHelper.Add(retRow, rhsRow, flatLhs);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
                     else
                     {
-                        var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData.RowCategories, lhs.OdData.ColumnCategories);
-                        var flatLhs = lhs.OdData.Data;
-                        var flatRhs = rhs.VectorData.Data;
-                        var rowSize = flatRhs.Length;
-                        if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var lhsRow = lhs.OdData.GetRow(i);
-                                VectorHelper.Add(retRow, lhsRow, flatRhs[i]);
-                            }
-                        }
-                        else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
+                    return new ComputationResult(retMatrix, true);
+                }
+                else
+                {
+                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData.RowCategories, lhs.OdData.ColumnCategories);
+                    var flatLhs = lhs.OdData.Data;
+                    var flatRhs = rhs.VectorData.Data;
+                    var rowSize = flatRhs.Length;
+                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var lhsRow = lhs.OdData.GetRow(i);
-                                VectorHelper.Add(retRow, lhsRow, flatRhs);
-                            }
+                            var retRow = retMatrix.GetRow(i);
+                            var lhsRow = lhs.OdData.GetRow(i);
+                            VectorHelper.Add(retRow, lhsRow, flatRhs[i]);
                         }
-                        else
+                    }
+                    else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            var retRow = retMatrix.GetRow(i);
+                            var lhsRow = lhs.OdData.GetRow(i);
+                            VectorHelper.Add(retRow, lhsRow, flatRhs);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
-                }
-                else
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.Add(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                    else
+                    {
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
                     return new ComputationResult(retMatrix, true);
                 }
             }
+            else
+            {
+                var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+                VectorHelper.Add(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
+            }
         }
     }
 }
+
diff --git a/src/TMG-Framework/Processing/AST/CompareAnd.cs b/src/TMG-Framework/Processing/AST/CompareAnd.cs
index 683b607..fbb9f7f 100644
--- a/src/TMG-Framework/Processing/AST/CompareAnd.cs
+++ b/src/TMG-Framework/Processing/AST/CompareAnd.cs
@@ -17,134 +17,131 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using XTMF2;
 using TMG.Utilities;
-using System;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class CompareAnd : BinaryExpression
 {
-    public sealed class CompareAnd : BinaryExpression
+
+    public CompareAnd(int start) : base(start)
     {
 
-        public CompareAnd(int start) : base(start)
-        {
+    }
 
+    public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    {
+        // see if we have two values, in this case we can skip doing the matrix operation
+        if (lhs.IsValue && rhs.IsValue)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return new ComputationResult(lhs.LiteralValue == rhs.LiteralValue ? 1 : 0);
         }
-
-        public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+        // float / matrix
+        if (lhs.IsValue)
         {
-            // see if we have two values, in this case we can skip doing the matrix operation
-            if (lhs.IsValue && rhs.IsValue)
+            if (rhs.IsVectorResult)
             {
-                // ReSharper disable once CompareOfFloatsByEqualityOperator
-                return new ComputationResult(lhs.LiteralValue == rhs.LiteralValue ? 1 : 0);
+                var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FlagAnd(flat, lhs.LiteralValue, rhs.VectorData.Data);
+                return new ComputationResult(retVector, true, rhs.Direction);
             }
-            // float / matrix
-            if (lhs.IsValue)
+            else
             {
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FlagAnd(flat, lhs.LiteralValue, rhs.VectorData.Data);
-                    return new ComputationResult(retVector, true, rhs.Direction);
-                }
-                else
-                {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                    VectorHelper.FlagAnd(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                VectorHelper.FlagAnd(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
             }
-            else if (rhs.IsValue)
+        }
+        else if (rhs.IsValue)
+        {
+            if (lhs.IsVectorResult)
             {
-                if (lhs.IsVectorResult)
-                {
-                    var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FlagAnd(flat, lhs.VectorData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retVector, true, lhs.Direction);
-                }
-                else
-                {
-                    // matrix / float
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    VectorHelper.FlagAnd(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FlagAnd(flat, lhs.VectorData.Data, rhs.LiteralValue);
+                return new ComputationResult(retVector, true, lhs.Direction);
             }
             else
             {
-                if (lhs.IsVectorResult || rhs.IsVectorResult)
+                // matrix / float
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                VectorHelper.FlagAnd(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
+            }
+        }
+        else
+        {
+            if (lhs.IsVectorResult || rhs.IsVectorResult)
+            {
+                if (lhs.IsVectorResult && rhs.IsVectorResult)
                 {
-                    if (lhs.IsVectorResult && rhs.IsVectorResult)
-                    {
-                        var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FlagAnd(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
-                        return new ComputationResult(retMatrix, true, lhs.Direction);
-                    }
-                    else if (lhs.IsVectorResult)
+                    var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+                    VectorHelper.FlagAnd(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
+                    return new ComputationResult(retMatrix, true, lhs.Direction);
+                }
+                else if (lhs.IsVectorResult)
+                {
+                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatRhs = rhs.OdData.Data;
+                    var flatLhs = lhs.VectorData.Data;
+                    var rowSize = flatLhs.Length;
+                    if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
-                        var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatRhs = rhs.OdData.Data;
-                        var flatLhs = lhs.VectorData.Data;
-                        var rowSize = flatLhs.Length;
-                        if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagAnd(retMatrix.GetRow(i), flatLhs[i], flatRhs.Slice(i * rowSize, rowSize));
-                            }
+                            VectorHelper.FlagAnd(retMatrix.GetRow(i), flatLhs[i], flatRhs.Slice(i * rowSize, rowSize));
                         }
-                        else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagAnd(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
-                            }
-                        }
-                        else
+                    }
+                    else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            VectorHelper.FlagAnd(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
                     else
                     {
-                        var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatLhs = lhs.OdData.Data;
-                        var flatRhs = rhs.VectorData.Data;
-                        var rowSize = flatRhs.Length;
-                        if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagAnd(retMatrix.GetRow(i), flatRhs[i], flatLhs.Slice(i * rowSize, rowSize));
-                            }
-                        }
-                        else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
+                    return new ComputationResult(retMatrix, true);
+                }
+                else
+                {
+                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatLhs = lhs.OdData.Data;
+                    var flatRhs = rhs.VectorData.Data;
+                    var rowSize = flatRhs.Length;
+                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagAnd(retMatrix.GetRow(i), flatRhs, flatLhs.Slice(i * rowSize, rowSize));
-                            }
+                            VectorHelper.FlagAnd(retMatrix.GetRow(i), flatRhs[i], flatLhs.Slice(i * rowSize, rowSize));
                         }
-                        else
+                    }
+                    else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            VectorHelper.FlagAnd(retMatrix.GetRow(i), flatRhs, flatLhs.Slice(i * rowSize, rowSize));
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
-                }
-                else
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.FlagAnd(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                    else
+                    {
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
                     return new ComputationResult(retMatrix, true);
                 }
             }
+            else
+            {
+                var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+                VectorHelper.FlagAnd(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
+            }
         }
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/CompareEqual.cs b/src/TMG-Framework/Processing/AST/CompareEqual.cs
index 6d265d8..55f7127 100644
--- a/src/TMG-Framework/Processing/AST/CompareEqual.cs
+++ b/src/TMG-Framework/Processing/AST/CompareEqual.cs
@@ -17,133 +17,130 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using XTMF2;
 using TMG.Utilities;
-using System;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class CompareEqual : BinaryExpression
 {
-    public sealed class CompareEqual : BinaryExpression
+    public CompareEqual(int start) : base(start)
     {
-        public CompareEqual(int start) : base(start)
-        {
 
-        }
+    }
 
-        public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    {
+        // see if we have two values, in this case we can skip doing the matrix operation
+        if (lhs.IsValue && rhs.IsValue)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return new ComputationResult(lhs.LiteralValue == rhs.LiteralValue ? 1 : 0);
+        }
+        // float / matrix
+        if (lhs.IsValue)
         {
-            // see if we have two values, in this case we can skip doing the matrix operation
-            if (lhs.IsValue && rhs.IsValue)
+            if (rhs.IsVectorResult)
             {
-                // ReSharper disable once CompareOfFloatsByEqualityOperator
-                return new ComputationResult(lhs.LiteralValue == rhs.LiteralValue ? 1 : 0);
+                var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FlagIfEquals(flat, lhs.LiteralValue, rhs.VectorData.Data);
+                return new ComputationResult(retVector, true, rhs.Direction);
             }
-            // float / matrix
-            if (lhs.IsValue)
+            else
             {
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FlagIfEquals(flat, lhs.LiteralValue, rhs.VectorData.Data);
-                    return new ComputationResult(retVector, true, rhs.Direction);
-                }
-                else
-                {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                    VectorHelper.FlagIfEquals(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                VectorHelper.FlagIfEquals(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
             }
-            else if (rhs.IsValue)
+        }
+        else if (rhs.IsValue)
+        {
+            if (lhs.IsVectorResult)
             {
-                if (lhs.IsVectorResult)
-                {
-                    var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FlagIfEquals(flat, lhs.VectorData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retVector, true, lhs.Direction);
-                }
-                else
-                {
-                    // matrix / float
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    VectorHelper.FlagIfEquals(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FlagIfEquals(flat, lhs.VectorData.Data, rhs.LiteralValue);
+                return new ComputationResult(retVector, true, lhs.Direction);
             }
             else
             {
-                if (lhs.IsVectorResult || rhs.IsVectorResult)
+                // matrix / float
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                VectorHelper.FlagIfEquals(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
+            }
+        }
+        else
+        {
+            if (lhs.IsVectorResult || rhs.IsVectorResult)
+            {
+                if (lhs.IsVectorResult && rhs.IsVectorResult)
                 {
-                    if (lhs.IsVectorResult && rhs.IsVectorResult)
-                    {
-                        var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FlagIfEquals(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
-                        return new ComputationResult(retMatrix, true, lhs.Direction);
-                    }
-                    else if (lhs.IsVectorResult)
+                    var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+                    VectorHelper.FlagIfEquals(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
+                    return new ComputationResult(retMatrix, true, lhs.Direction);
+                }
+                else if (lhs.IsVectorResult)
+                {
+                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatRhs = rhs.OdData.Data;
+                    var flatLhs = lhs.VectorData.Data;
+                    var rowSize = flatLhs.Length;
+                    if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
-                        var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatRhs = rhs.OdData.Data;
-                        var flatLhs = lhs.VectorData.Data;
-                        var rowSize = flatLhs.Length;
-                        if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfEquals(retMatrix.Data.Slice(i * rowSize, rowSize), flatLhs[i], flatRhs.Slice(i * rowSize, rowSize));
-                            }
+                            VectorHelper.FlagIfEquals(retMatrix.Data.Slice(i * rowSize, rowSize), flatLhs[i], flatRhs.Slice(i * rowSize, rowSize));
                         }
-                        else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfEquals(retMatrix.Data.Slice(i * rowSize, rowSize), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
-                            }
-                        }
-                        else
+                    }
+                    else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to compare equal a vector without directionality to a matrix starting at position " + (Lhs?.Start ?? -1) + "!");
+                            VectorHelper.FlagIfEquals(retMatrix.Data.Slice(i * rowSize, rowSize), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
                     else
                     {
-                        var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatLhs = lhs.OdData.Data;
-                        var flatRhs = rhs.VectorData.Data;
-                        var rowSize = flatRhs.Length;
-                        if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfEquals(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs[i]);
-                            }
-                        }
-                        else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        return new ComputationResult("Unable to compare equal a vector without directionality to a matrix starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
+                    return new ComputationResult(retMatrix, true);
+                }
+                else
+                {
+                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatLhs = lhs.OdData.Data;
+                    var flatRhs = rhs.VectorData.Data;
+                    var rowSize = flatRhs.Length;
+                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfEquals(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs);
-                            }
+                            VectorHelper.FlagIfEquals(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs[i]);
                         }
-                        else
+                    }
+                    else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to compare equal a vector without directionality to a matrix starting at position " + (Lhs?.Start ?? -1) + "!");
+                            VectorHelper.FlagIfEquals(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
-                }
-                else
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.FlagIfEquals(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                    else
+                    {
+                        return new ComputationResult("Unable to compare equal a vector without directionality to a matrix starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
                     return new ComputationResult(retMatrix, true);
                 }
             }
+            else
+            {
+                var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+                VectorHelper.FlagIfEquals(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
+            }
         }
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/CompareGreaterThan.cs b/src/TMG-Framework/Processing/AST/CompareGreaterThan.cs
index cdfb74f..93ca14a 100644
--- a/src/TMG-Framework/Processing/AST/CompareGreaterThan.cs
+++ b/src/TMG-Framework/Processing/AST/CompareGreaterThan.cs
@@ -17,132 +17,129 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using XTMF2;
 using TMG.Utilities;
-using System;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class CompareGreaterThan : BinaryExpression
 {
-    public sealed class CompareGreaterThan : BinaryExpression
+    public CompareGreaterThan(int start) : base(start)
     {
-        public CompareGreaterThan(int start) : base(start)
-        {
 
-        }
+    }
 
-        public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    {
+        // see if we have two values, in this case we can skip doing the matrix operation
+        if (lhs.IsValue && rhs.IsValue)
+        {
+            return new ComputationResult(lhs.LiteralValue > rhs.LiteralValue ? 1 : 0);
+        }
+        // float / matrix
+        if (lhs.IsValue)
         {
-            // see if we have two values, in this case we can skip doing the matrix operation
-            if (lhs.IsValue && rhs.IsValue)
+            if (rhs.IsVectorResult)
             {
-                return new ComputationResult(lhs.LiteralValue > rhs.LiteralValue ? 1 : 0);
+                var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FlagIfGreaterThan(flat, lhs.LiteralValue, rhs.VectorData.Data);
+                return new ComputationResult(retVector, true, rhs.Direction);
             }
-            // float / matrix
-            if (lhs.IsValue)
+            else
             {
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FlagIfGreaterThan(flat, lhs.LiteralValue, rhs.VectorData.Data);
-                    return new ComputationResult(retVector, true, rhs.Direction);
-                }
-                else
-                {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                    VectorHelper.FlagIfGreaterThan(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                VectorHelper.FlagIfGreaterThan(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
             }
-            else if (rhs.IsValue)
+        }
+        else if (rhs.IsValue)
+        {
+            if (lhs.IsVectorResult)
             {
-                if (lhs.IsVectorResult)
-                {
-                    var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FlagIfGreaterThan(flat, lhs.VectorData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retVector, true, lhs.Direction);
-                }
-                else
-                {
-                    // matrix / float
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    VectorHelper.FlagIfGreaterThan(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FlagIfGreaterThan(flat, lhs.VectorData.Data, rhs.LiteralValue);
+                return new ComputationResult(retVector, true, lhs.Direction);
             }
             else
             {
-                if (lhs.IsVectorResult || rhs.IsVectorResult)
+                // matrix / float
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                VectorHelper.FlagIfGreaterThan(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
+            }
+        }
+        else
+        {
+            if (lhs.IsVectorResult || rhs.IsVectorResult)
+            {
+                if (lhs.IsVectorResult && rhs.IsVectorResult)
                 {
-                    if (lhs.IsVectorResult && rhs.IsVectorResult)
-                    {
-                        var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FlagIfGreaterThan(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
-                        return new ComputationResult(retMatrix, true, lhs.Direction);
-                    }
-                    else if (lhs.IsVectorResult)
+                    var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+                    VectorHelper.FlagIfGreaterThan(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
+                    return new ComputationResult(retMatrix, true, lhs.Direction);
+                }
+                else if (lhs.IsVectorResult)
+                {
+                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatRhs = rhs.OdData.Data;
+                    var flatLhs = lhs.VectorData.Data;
+                    var rowSize = flatLhs.Length;
+                    if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
-                        var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatRhs = rhs.OdData.Data;
-                        var flatLhs = lhs.VectorData.Data;
-                        var rowSize = flatLhs.Length;
-                        if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfGreaterThan(retMatrix.GetRow(i), flatLhs[i], flatRhs.Slice(i * rowSize, rowSize));
-                            }
+                            VectorHelper.FlagIfGreaterThan(retMatrix.GetRow(i), flatLhs[i], flatRhs.Slice(i * rowSize, rowSize));
                         }
-                        else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfGreaterThan(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
-                            }
-                        }
-                        else
+                    }
+                    else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            VectorHelper.FlagIfGreaterThan(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
                     else
                     {
-                        var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatLhs = lhs.OdData.Data;
-                        var flatRhs = rhs.VectorData.Data;
-                        var rowSize = flatRhs.Length;
-                        if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfGreaterThan(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs[i]);
-                            }
-                        }
-                        else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
+                    return new ComputationResult(retMatrix, true);
+                }
+                else
+                {
+                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatLhs = lhs.OdData.Data;
+                    var flatRhs = rhs.VectorData.Data;
+                    var rowSize = flatRhs.Length;
+                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfGreaterThan(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs);
-                            }
+                            VectorHelper.FlagIfGreaterThan(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs[i]);
                         }
-                        else
+                    }
+                    else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            VectorHelper.FlagIfGreaterThan(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
-                }
-                else
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.FlagIfGreaterThan(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                    else
+                    {
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
                     return new ComputationResult(retMatrix, true);
                 }
             }
+            else
+            {
+                var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+                VectorHelper.FlagIfGreaterThan(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
+            }
         }
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/CompareGreaterThanOrEqual.cs b/src/TMG-Framework/Processing/AST/CompareGreaterThanOrEqual.cs
index 5fed622..b6ebb72 100644
--- a/src/TMG-Framework/Processing/AST/CompareGreaterThanOrEqual.cs
+++ b/src/TMG-Framework/Processing/AST/CompareGreaterThanOrEqual.cs
@@ -17,132 +17,129 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using XTMF2;
 using TMG.Utilities;
-using System;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class CompareGreaterThanOrEqual : BinaryExpression
 {
-    public sealed class CompareGreaterThanOrEqual : BinaryExpression
+    public CompareGreaterThanOrEqual(int start) : base(start)
     {
-        public CompareGreaterThanOrEqual(int start) : base(start)
-        {
 
-        }
+    }
 
-        public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    {
+        // see if we have two values, in this case we can skip doing the matrix operation
+        if (lhs.IsValue && rhs.IsValue)
+        {
+            return new ComputationResult(lhs.LiteralValue >= rhs.LiteralValue ? 1 : 0);
+        }
+        // float / matrix
+        if (lhs.IsValue)
         {
-            // see if we have two values, in this case we can skip doing the matrix operation
-            if (lhs.IsValue && rhs.IsValue)
+            if (rhs.IsVectorResult)
             {
-                return new ComputationResult(lhs.LiteralValue >= rhs.LiteralValue ? 1 : 0);
+                var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FlagIfGreaterThanOrEqual(flat, lhs.LiteralValue, rhs.VectorData.Data);
+                return new ComputationResult(retVector, true, rhs.Direction);
             }
-            // float / matrix
-            if (lhs.IsValue)
+            else
             {
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FlagIfGreaterThanOrEqual(flat, lhs.LiteralValue, rhs.VectorData.Data);
-                    return new ComputationResult(retVector, true, rhs.Direction);
-                }
-                else
-                {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                    VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
             }
-            else if (rhs.IsValue)
+        }
+        else if (rhs.IsValue)
+        {
+            if (lhs.IsVectorResult)
             {
-                if (lhs.IsVectorResult)
-                {
-                    var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FlagIfGreaterThanOrEqual(flat, lhs.VectorData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retVector, true, lhs.Direction);
-                }
-                else
-                {
-                    // matrix / float
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FlagIfGreaterThanOrEqual(flat, lhs.VectorData.Data, rhs.LiteralValue);
+                return new ComputationResult(retVector, true, lhs.Direction);
             }
             else
             {
-                if (lhs.IsVectorResult || rhs.IsVectorResult)
+                // matrix / float
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
+            }
+        }
+        else
+        {
+            if (lhs.IsVectorResult || rhs.IsVectorResult)
+            {
+                if (lhs.IsVectorResult && rhs.IsVectorResult)
                 {
-                    if (lhs.IsVectorResult && rhs.IsVectorResult)
-                    {
-                        var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
-                        return new ComputationResult(retMatrix, true, lhs.Direction);
-                    }
-                    else if (lhs.IsVectorResult)
+                    var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+                    VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
+                    return new ComputationResult(retMatrix, true, lhs.Direction);
+                }
+                else if (lhs.IsVectorResult)
+                {
+                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatRhs = rhs.OdData.Data;
+                    var flatLhs = lhs.VectorData.Data;
+                    var rowSize = flatLhs.Length;
+                    if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
-                        var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatRhs = rhs.OdData.Data;
-                        var flatLhs = lhs.VectorData.Data;
-                        var rowSize = flatLhs.Length;
-                        if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.GetRow(i), flatLhs[i], flatRhs.Slice(i * rowSize, rowSize));
-                            }
+                            VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.GetRow(i), flatLhs[i], flatRhs.Slice(i * rowSize, rowSize));
                         }
-                        else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
-                            }
-                        }
-                        else
+                    }
+                    else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to compare vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
                     else
                     {
-                        var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatLhs = lhs.OdData.Data;
-                        var flatRhs = rhs.VectorData.Data;
-                        var rowSize = flatRhs.Length;
-                        if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs[i]);
-                            }
-                        }
-                        else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        return new ComputationResult("Unable to compare vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
+                    return new ComputationResult(retMatrix, true);
+                }
+                else
+                {
+                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatLhs = lhs.OdData.Data;
+                    var flatRhs = rhs.VectorData.Data;
+                    var rowSize = flatRhs.Length;
+                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs);
-                            }
+                            VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs[i]);
                         }
-                        else
+                    }
+                    else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
-                }
-                else
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                    else
+                    {
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
                     return new ComputationResult(retMatrix, true);
                 }
             }
+            else
+            {
+                var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
+            }
         }
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/CompareNotEquals.cs b/src/TMG-Framework/Processing/AST/CompareNotEquals.cs
index 9139314..8406852 100644
--- a/src/TMG-Framework/Processing/AST/CompareNotEquals.cs
+++ b/src/TMG-Framework/Processing/AST/CompareNotEquals.cs
@@ -17,133 +17,130 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using XTMF2;
 using TMG.Utilities;
-using System;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class CompareNotEquals : BinaryExpression
 {
-    public sealed class CompareNotEquals : BinaryExpression
+    public CompareNotEquals(int start) : base(start)
     {
-        public CompareNotEquals(int start) : base(start)
-        {
 
-        }
+    }
 
-        public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    {
+        // see if we have two values, in this case we can skip doing the matrix operation
+        if (lhs.IsValue && rhs.IsValue)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return new ComputationResult(lhs.LiteralValue != rhs.LiteralValue ? 1 : 0);
+        }
+        // float / matrix
+        if (lhs.IsValue)
         {
-            // see if we have two values, in this case we can skip doing the matrix operation
-            if (lhs.IsValue && rhs.IsValue)
+            if (rhs.IsVectorResult)
             {
-                // ReSharper disable once CompareOfFloatsByEqualityOperator
-                return new ComputationResult(lhs.LiteralValue != rhs.LiteralValue ? 1 : 0);
+                var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FlagIfNotEquals(flat, lhs.LiteralValue, rhs.VectorData.Data);
+                return new ComputationResult(retVector, true, rhs.Direction);
             }
-            // float / matrix
-            if (lhs.IsValue)
+            else
             {
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FlagIfNotEquals(flat, lhs.LiteralValue, rhs.VectorData.Data);
-                    return new ComputationResult(retVector, true, rhs.Direction);
-                }
-                else
-                {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                    VectorHelper.FlagIfNotEquals(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                VectorHelper.FlagIfNotEquals(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
             }
-            else if (rhs.IsValue)
+        }
+        else if (rhs.IsValue)
+        {
+            if (lhs.IsVectorResult)
             {
-                if (lhs.IsVectorResult)
-                {
-                    var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FlagIfNotEquals(flat, lhs.VectorData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retVector, true, lhs.Direction);
-                }
-                else
-                {
-                    // matrix / float
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    VectorHelper.FlagIfNotEquals(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FlagIfNotEquals(flat, lhs.VectorData.Data, rhs.LiteralValue);
+                return new ComputationResult(retVector, true, lhs.Direction);
             }
             else
             {
-                if (lhs.IsVectorResult || rhs.IsVectorResult)
+                // matrix / float
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                VectorHelper.FlagIfNotEquals(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
+            }
+        }
+        else
+        {
+            if (lhs.IsVectorResult || rhs.IsVectorResult)
+            {
+                if (lhs.IsVectorResult && rhs.IsVectorResult)
                 {
-                    if (lhs.IsVectorResult && rhs.IsVectorResult)
-                    {
-                        var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FlagIfNotEquals(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
-                        return new ComputationResult(retMatrix, true, lhs.Direction);
-                    }
-                    else if (lhs.IsVectorResult)
+                    var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+                    VectorHelper.FlagIfNotEquals(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
+                    return new ComputationResult(retMatrix, true, lhs.Direction);
+                }
+                else if (lhs.IsVectorResult)
+                {
+                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatRhs = rhs.OdData.Data;
+                    var flatLhs = lhs.VectorData.Data;
+                    var rowSize = flatLhs.Length;
+                    if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
-                        var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatRhs = rhs.OdData.Data;
-                        var flatLhs = lhs.VectorData.Data;
-                        var rowSize = flatLhs.Length;
-                        if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfNotEquals(retMatrix.GetRow(i), flatLhs[i], flatRhs.Slice(i * rowSize, rowSize));
-                            }
+                            VectorHelper.FlagIfNotEquals(retMatrix.GetRow(i), flatLhs[i], flatRhs.Slice(i * rowSize, rowSize));
                         }
-                        else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfNotEquals(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
-                            }
-                        }
-                        else
+                    }
+                    else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            VectorHelper.FlagIfNotEquals(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
                     else
                     {
-                        var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatLhs = lhs.OdData.Data;
-                        var flatRhs = rhs.VectorData.Data;
-                        var rowSize = flatRhs.Length;
-                        if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfNotEquals(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs[i]);
-                            }
-                        }
-                        else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
+                    return new ComputationResult(retMatrix, true);
+                }
+                else
+                {
+                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatLhs = lhs.OdData.Data;
+                    var flatRhs = rhs.VectorData.Data;
+                    var rowSize = flatRhs.Length;
+                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagIfNotEquals(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs);
-                            }
+                            VectorHelper.FlagIfNotEquals(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs[i]);
                         }
-                        else
+                    }
+                    else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            VectorHelper.FlagIfNotEquals(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
-                }
-                else
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.FlagIfNotEquals(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                    else
+                    {
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
                     return new ComputationResult(retMatrix, true);
                 }
             }
+            else
+            {
+                var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+                VectorHelper.FlagIfNotEquals(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
+            }
         }
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/CompareOr.cs b/src/TMG-Framework/Processing/AST/CompareOr.cs
index ddf2b19..9b303a6 100644
--- a/src/TMG-Framework/Processing/AST/CompareOr.cs
+++ b/src/TMG-Framework/Processing/AST/CompareOr.cs
@@ -17,134 +17,131 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using XTMF2;
 using TMG.Utilities;
-using System;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class CompareOr : BinaryExpression
 {
-    public sealed class CompareOr : BinaryExpression
+
+    public CompareOr(int start) : base(start)
     {
 
-        public CompareOr(int start) : base(start)
-        {
+    }
 
+    public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    {
+        // see if we have two values, in this case we can skip doing the matrix operation
+        if (lhs.IsValue && rhs.IsValue)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return new ComputationResult(lhs.LiteralValue == rhs.LiteralValue ? 1 : 0);
         }
-
-        public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+        // float / matrix
+        if (lhs.IsValue)
         {
-            // see if we have two values, in this case we can skip doing the matrix operation
-            if (lhs.IsValue && rhs.IsValue)
+            if (rhs.IsVectorResult)
             {
-                // ReSharper disable once CompareOfFloatsByEqualityOperator
-                return new ComputationResult(lhs.LiteralValue == rhs.LiteralValue ? 1 : 0);
+                var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FlagOr(flat, lhs.LiteralValue, rhs.VectorData.Data);
+                return new ComputationResult(retVector, true, rhs.Direction);
             }
-            // float / matrix
-            if (lhs.IsValue)
+            else
             {
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FlagOr(flat, lhs.LiteralValue, rhs.VectorData.Data);
-                    return new ComputationResult(retVector, true, rhs.Direction);
-                }
-                else
-                {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                    VectorHelper.FlagOr(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                VectorHelper.FlagOr(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
             }
-            else if (rhs.IsValue)
+        }
+        else if (rhs.IsValue)
+        {
+            if (lhs.IsVectorResult)
             {
-                if (lhs.IsVectorResult)
-                {
-                    var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FlagOr(flat, lhs.VectorData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retVector, true, lhs.Direction);
-                }
-                else
-                {
-                    // matrix / float
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    VectorHelper.FlagOr(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FlagOr(flat, lhs.VectorData.Data, rhs.LiteralValue);
+                return new ComputationResult(retVector, true, lhs.Direction);
             }
             else
             {
-                if (lhs.IsVectorResult || rhs.IsVectorResult)
+                // matrix / float
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                VectorHelper.FlagOr(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
+            }
+        }
+        else
+        {
+            if (lhs.IsVectorResult || rhs.IsVectorResult)
+            {
+                if (lhs.IsVectorResult && rhs.IsVectorResult)
                 {
-                    if (lhs.IsVectorResult && rhs.IsVectorResult)
-                    {
-                        var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FlagOr(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
-                        return new ComputationResult(retMatrix, true, lhs.Direction);
-                    }
-                    else if (lhs.IsVectorResult)
+                    var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+                    VectorHelper.FlagOr(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
+                    return new ComputationResult(retMatrix, true, lhs.Direction);
+                }
+                else if (lhs.IsVectorResult)
+                {
+                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatRhs = rhs.OdData.Data;
+                    var flatLhs = lhs.VectorData.Data;
+                    var rowSize = flatLhs.Length;
+                    if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
-                        var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatRhs = rhs.OdData.Data;
-                        var flatLhs = lhs.VectorData.Data;
-                        var rowSize = flatLhs.Length;
-                        if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagOr(retMatrix.GetRow(i), flatLhs[i], flatRhs.Slice(i * rowSize, rowSize));
-                            }
+                            VectorHelper.FlagOr(retMatrix.GetRow(i), flatLhs[i], flatRhs.Slice(i * rowSize, rowSize));
                         }
-                        else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagOr(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
-                            }
-                        }
-                        else
+                    }
+                    else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            VectorHelper.FlagOr(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
                     else
                     {
-                        var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatLhs = lhs.OdData.Data;
-                        var flatRhs = rhs.VectorData.Data;
-                        var rowSize = flatRhs.Length;
-                        if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagOr(retMatrix.GetRow(i), flatRhs[i], flatLhs.Slice(i * rowSize, rowSize));
-                            }
-                        }
-                        else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
+                    return new ComputationResult(retMatrix, true);
+                }
+                else
+                {
+                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatLhs = lhs.OdData.Data;
+                    var flatRhs = rhs.VectorData.Data;
+                    var rowSize = flatRhs.Length;
+                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                VectorHelper.FlagOr(retMatrix.GetRow(i), flatRhs, flatLhs.Slice(i * rowSize, rowSize));
-                            }
+                            VectorHelper.FlagOr(retMatrix.GetRow(i), flatRhs[i], flatLhs.Slice(i * rowSize, rowSize));
                         }
-                        else
+                    }
+                    else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            VectorHelper.FlagOr(retMatrix.GetRow(i), flatRhs, flatLhs.Slice(i * rowSize, rowSize));
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
-                }
-                else
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.FlagOr(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                    else
+                    {
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
                     return new ComputationResult(retMatrix, true);
                 }
             }
+            else
+            {
+                var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+                VectorHelper.FlagOr(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
+            }
         }
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/Compiler.cs b/src/TMG-Framework/Processing/AST/Compiler.cs
index 56f269a..9196ca3 100644
--- a/src/TMG-Framework/Processing/AST/Compiler.cs
+++ b/src/TMG-Framework/Processing/AST/Compiler.cs
@@ -17,18 +17,15 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System.Diagnostics.CodeAnalysis;
+namespace TMG.Frameworks.Data.Processing.AST;
 
-namespace TMG.Frameworks.Data.Processing.AST
+public static class Compiler
 {
-    public static class Compiler
+    public static bool Compile(string expression,
+        [NotNullWhen(true)] out Expression? ex,
+        [NotNullWhen(false)] ref string? error)
     {
-        public static bool Compile(string expression, 
-            [NotNullWhen(true)] out Expression? ex,
-            [NotNullWhen(false)] ref string? error)
-        {
-            var buffer = expression.ToCharArray();
-            return Expression.Compile(buffer, 0, buffer.Length, out ex, ref error) && Expression.Optimize(ref ex, ref error);
-        }
+        var buffer = expression.ToCharArray();
+        return Expression.Compile(buffer, 0, buffer.Length, out ex, ref error) && Expression.Optimize(ref ex, ref error);
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/Divide.cs b/src/TMG-Framework/Processing/AST/Divide.cs
index aa0fce0..c2665cd 100644
--- a/src/TMG-Framework/Processing/AST/Divide.cs
+++ b/src/TMG-Framework/Processing/AST/Divide.cs
@@ -17,165 +17,161 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using XTMF2;
 using TMG.Utilities;
-using System;
-using System.Diagnostics.CodeAnalysis;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class Divide : BinaryExpression
 {
-    public sealed class Divide : BinaryExpression
+    public Divide(int start) : base(start)
     {
-        public Divide(int start) : base(start)
-        {
 
-        }
+    }
 
-        internal override bool OptimizeAst(
-            ref Expression ex,
-            [NotNullWhen(false)] ref string? error)
+    internal override bool OptimizeAst(
+        ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        if (!base.OptimizeAst(ref ex, ref error))
+        {
+            return false;
+        }
+        var lhs = Lhs as Literal;
+        var rhs = Rhs as Literal;
+        if (lhs != null && rhs != null)
+        {
+            ex = new Literal(Start, lhs.Value / rhs.Value);
+        }
+        else if (rhs != null)
         {
-            if (!base.OptimizeAst(ref ex, ref error))
+            // if the RHS is a literal we can replace it with a multiply instead
+            ex = new Multiply(Start)
             {
-                return false;
-            }
-            var lhs = Lhs as Literal;
-            var rhs = Rhs as Literal;
-            if (lhs != null && rhs != null)
+                Lhs = Lhs,
+                Rhs = new Literal(rhs.Start, 1.0f / rhs.Value)
+            };
+        }
+        return true;
+    }
+
+    public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    {
+        // see if we have two values, in this case we can skip doing the matrix operation
+        if (lhs.IsValue && rhs.IsValue)
+        {
+            return new ComputationResult(lhs.LiteralValue / rhs.LiteralValue);
+        }
+        // float / matrix
+        if (lhs.IsValue)
+        {
+            if (rhs.IsVectorResult)
             {
-                ex = new Literal(Start, lhs.Value / rhs.Value);
+                var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.Divide(flat, lhs.LiteralValue, rhs.VectorData.Data);
+                return new ComputationResult(retVector, true);
             }
-            else if(rhs != null)
+            else
             {
-                // if the RHS is a literal we can replace it with a multiply instead
-                ex = new Multiply(Start)
-                {
-                    Lhs = Lhs,
-                    Rhs = new Literal(rhs.Start, 1.0f / rhs.Value)
-                };
+                var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                VectorHelper.Divide(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
             }
-            return true;
         }
-
-        public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+        else if (rhs.IsValue)
         {
-            // see if we have two values, in this case we can skip doing the matrix operation
-            if (lhs.IsValue && rhs.IsValue)
+            if (lhs.IsVectorResult)
             {
-                return new ComputationResult(lhs.LiteralValue / rhs.LiteralValue);
+                var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.Divide(flat, lhs.VectorData.Data, rhs.LiteralValue);
+                return new ComputationResult(retVector, true);
             }
-            // float / matrix
-            if (lhs.IsValue)
+            else
             {
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.Divide(flat, lhs.LiteralValue, rhs.VectorData.Data);
-                    return new ComputationResult(retVector, true);
-                }
-                else
-                {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                    VectorHelper.Divide(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
-                    return new ComputationResult(retMatrix, true);
-                }
+                // matrix / float
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                VectorHelper.Divide(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
             }
-            else if (rhs.IsValue)
+        }
+        else
+        {
+            if (lhs.IsVectorResult || rhs.IsVectorResult)
             {
-                if (lhs.IsVectorResult)
-                {
-                    var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.Divide(flat, lhs.VectorData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retVector, true);
-                }
-                else
+                if (lhs.IsVectorResult && rhs.IsVectorResult)
                 {
-                    // matrix / float
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    VectorHelper.Divide(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
+                    var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+                    VectorHelper.Divide(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
+                    return new ComputationResult(retMatrix, true, lhs.Direction);
                 }
-            }
-            else
-            {
-                if (lhs.IsVectorResult || rhs.IsVectorResult)
+                else if (lhs.IsVectorResult)
                 {
-                    if (lhs.IsVectorResult && rhs.IsVectorResult)
-                    {
-                        var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.Divide(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
-                        return new ComputationResult(retMatrix, true, lhs.Direction);
-                    }
-                    else if (lhs.IsVectorResult)
+                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                    var flatLhs = lhs.VectorData.Data;
+                    var rowSize = flatLhs.Length;
+                    if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
-                        var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                        var flatLhs = lhs.VectorData.Data;
-                        var rowSize = flatLhs.Length;
-                        if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        { 
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var retRight = rhs.OdData.GetRow(i);
-                                VectorHelper.Divide(retRow, flatLhs[i], retRight);
-                            }
-                        }
-                        else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var retRight = rhs.OdData.GetRow(i);
-                                VectorHelper.Divide(retRow, flatLhs, retRight);
-                            }
+                            var retRow = retMatrix.GetRow(i);
+                            var retRight = rhs.OdData.GetRow(i);
+                            VectorHelper.Divide(retRow, flatLhs[i], retRight);
                         }
-                        else
+                    }
+                    else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            var retRow = retMatrix.GetRow(i);
+                            var retRight = rhs.OdData.GetRow(i);
+                            VectorHelper.Divide(retRow, flatLhs, retRight);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
                     else
                     {
-                        var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                        var flatRet = retMatrix.Data;
-                        var flatLhs = lhs.OdData.Data;
-                        var flatRhs = rhs.VectorData.Data;
-                        var rowSize = flatRhs.Length;
-                        if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var retLeft = lhs.OdData.GetRow(i);
-                                VectorHelper.Divide(retRow, retLeft, flatRhs[i]);
-                            }
-                        }
-                        else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
+                    return new ComputationResult(retMatrix, true);
+                }
+                else
+                {
+                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                    var flatRet = retMatrix.Data;
+                    var flatLhs = lhs.OdData.Data;
+                    var flatRhs = rhs.VectorData.Data;
+                    var rowSize = flatRhs.Length;
+                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var retLeft = lhs.OdData.GetRow(i);
-                                VectorHelper.Divide(retRow, retLeft, flatRhs);
-                            }
+                            var retRow = retMatrix.GetRow(i);
+                            var retLeft = lhs.OdData.GetRow(i);
+                            VectorHelper.Divide(retRow, retLeft, flatRhs[i]);
                         }
-                        else
+                    }
+                    else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            var retRow = retMatrix.GetRow(i);
+                            var retLeft = lhs.OdData.GetRow(i);
+                            VectorHelper.Divide(retRow, retLeft, flatRhs);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
-                }
-                else
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.Divide(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                    else
+                    {
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
                     return new ComputationResult(retMatrix, true);
                 }
             }
+            else
+            {
+                var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+                VectorHelper.Divide(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
+            }
         }
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/Exponent.cs b/src/TMG-Framework/Processing/AST/Exponent.cs
index 92cfbe6..1d85ab8 100644
--- a/src/TMG-Framework/Processing/AST/Exponent.cs
+++ b/src/TMG-Framework/Processing/AST/Exponent.cs
@@ -16,136 +16,134 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using XTMF2;
-using System;
+
 using TMG.Utilities;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class Exponent : BinaryExpression
 {
-    public sealed class Exponent : BinaryExpression
+    public Exponent(int start) : base(start)
     {
-        public Exponent(int start) : base(start)
-        {
 
-        }
+    }
 
-        public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    {
+        // see if we have two values, in this case we can skip doing the matrix operation
+        if (lhs.IsValue && rhs.IsValue)
+        {
+            return new ComputationResult((float)Math.Pow(lhs.LiteralValue, rhs.LiteralValue));
+        }
+        // float / matrix
+        if (lhs.IsValue)
         {
-            // see if we have two values, in this case we can skip doing the matrix operation
-            if (lhs.IsValue && rhs.IsValue)
+            if (rhs.IsVectorResult)
             {
-                return new ComputationResult((float)Math.Pow(lhs.LiteralValue, rhs.LiteralValue));
+                var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.Pow(flat, lhs.LiteralValue, rhs.VectorData.Data);
+                return new ComputationResult(retVector, true);
             }
-            // float / matrix
-            if (lhs.IsValue)
+            else
             {
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.Pow(flat, lhs.LiteralValue, rhs.VectorData.Data);
-                    return new ComputationResult(retVector, true);
-                }
-                else
-                {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                    VectorHelper.Pow(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                VectorHelper.Pow(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
             }
-            else if (rhs.IsValue)
+        }
+        else if (rhs.IsValue)
+        {
+            if (lhs.IsVectorResult)
             {
-                if (lhs.IsVectorResult)
-                {
-                    var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.Pow(flat, lhs.VectorData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retVector, true);
-                }
-                else
-                {
-                    // matrix / float
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    VectorHelper.Pow(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.Pow(flat, lhs.VectorData.Data, rhs.LiteralValue);
+                return new ComputationResult(retVector, true);
             }
             else
             {
-                if (lhs.IsVectorResult || rhs.IsVectorResult)
+                // matrix / float
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                VectorHelper.Pow(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
+            }
+        }
+        else
+        {
+            if (lhs.IsVectorResult || rhs.IsVectorResult)
+            {
+                if (lhs.IsVectorResult && rhs.IsVectorResult)
                 {
-                    if (lhs.IsVectorResult && rhs.IsVectorResult)
-                    {
-                        var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.Pow(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
-                        return new ComputationResult(retMatrix, true, lhs.Direction);
-                    }
-                    else if (lhs.IsVectorResult)
+                    var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+                    VectorHelper.Pow(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
+                    return new ComputationResult(retMatrix, true, lhs.Direction);
+                }
+                else if (lhs.IsVectorResult)
+                {
+                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                    var flatLhs = lhs.VectorData.Data;
+                    var rowSize = flatLhs.Length;
+                    if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
-                        var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                        var flatLhs = lhs.VectorData.Data;
-                        var rowSize = flatLhs.Length;
-                        if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var rhsRow = rhs.OdData.GetRow(i);
-                                VectorHelper.Pow(retRow, flatLhs[i], rhsRow);
-                            }
-                        }
-                        else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var rhsRow = rhs.OdData.GetRow(i);
-                                VectorHelper.Pow(retRow, flatLhs, rhsRow);
-                            }
+                            var retRow = retMatrix.GetRow(i);
+                            var rhsRow = rhs.OdData.GetRow(i);
+                            VectorHelper.Pow(retRow, flatLhs[i], rhsRow);
                         }
-                        else
+                    }
+                    else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to subtract vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            var retRow = retMatrix.GetRow(i);
+                            var rhsRow = rhs.OdData.GetRow(i);
+                            VectorHelper.Pow(retRow, flatLhs, rhsRow);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
                     else
                     {
-                        var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                        var flatRhs = rhs.VectorData.Data;
-                        var rowSize = flatRhs.Length;
-                        if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var lhsRow = lhs.OdData.GetRow(i);
-                                VectorHelper.Pow(retRow, lhsRow, flatRhs[i]);
-                            }
-                        }
-                        else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        return new ComputationResult("Unable to subtract vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
+                    return new ComputationResult(retMatrix, true);
+                }
+                else
+                {
+                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                    var flatRhs = rhs.VectorData.Data;
+                    var rowSize = flatRhs.Length;
+                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var lhsRow = lhs.OdData.GetRow(i);
-                                VectorHelper.Pow(retRow, lhsRow, flatRhs);
-                            }
+                            var retRow = retMatrix.GetRow(i);
+                            var lhsRow = lhs.OdData.GetRow(i);
+                            VectorHelper.Pow(retRow, lhsRow, flatRhs[i]);
                         }
-                        else
+                    }
+                    else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to subtract vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            var retRow = retMatrix.GetRow(i);
+                            var lhsRow = lhs.OdData.GetRow(i);
+                            VectorHelper.Pow(retRow, lhsRow, flatRhs);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
-                }
-                else
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.Pow(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                    else
+                    {
+                        return new ComputationResult("Unable to subtract vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
                     return new ComputationResult(retMatrix, true);
                 }
             }
+            else
+            {
+                var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+                VectorHelper.Pow(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
+            }
         }
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/Expression.cs b/src/TMG-Framework/Processing/AST/Expression.cs
index ee9c4fe..c19b694 100644
--- a/src/TMG-Framework/Processing/AST/Expression.cs
+++ b/src/TMG-Framework/Processing/AST/Expression.cs
@@ -17,481 +17,449 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Text;
-using System.Threading.Tasks;
-using XTMF2;
-
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public abstract class Expression : AstNode
 {
-    public abstract class Expression : AstNode
+
+    public Expression(int start) : base(start)
     {
 
-        public Expression(int start) : base(start)
-        {
+    }
 
-        }
+    private static bool FailWithError(
+        [NotNullWhen(false)] out ComputationResult? result, string message)
+    {
+        result = new ComputationResult(message);
+        return false;
+    }
 
-        private static bool FailWithError(
-            [NotNullWhen(false)] out ComputationResult? result, string message)
+    protected bool ValidateSizes(ComputationResult lhs, ComputationResult rhs, int position,
+        [NotNullWhen(false)] out ComputationResult? errorResult)
+    {
+        errorResult = null;
+        if (lhs.IsValue || lhs.IsVectorResult && rhs.IsOdResult)
         {
-            result = new ComputationResult(message);
-            return false;
+            var temp = rhs;
+            rhs = lhs;
+            lhs = temp;
         }
-
-        protected bool ValidateSizes(ComputationResult lhs, ComputationResult rhs, int position, 
-            [NotNullWhen(false)] out ComputationResult? errorResult)
+        if (lhs.IsOdResult)
         {
-            errorResult = null;
-            if (lhs.IsValue || lhs.IsVectorResult && rhs.IsOdResult)
-            {
-                var temp = rhs;
-                rhs = lhs;
-                lhs = temp;
-            }
-            if (lhs.IsOdResult)
+            if (rhs.IsOdResult)
             {
-                if (rhs.IsOdResult)
+                if (!(lhs.OdData!.ColumnCategories == rhs.OdData!.ColumnCategories
+                    && lhs.OdData.RowCategories == rhs.OdData.RowCategories))
                 {
-                    if (!(lhs.OdData!.ColumnCategories == rhs.OdData!.ColumnCategories
-                        && lhs.OdData.RowCategories == rhs.OdData.RowCategories))
-                    {
-                        return FailWithError(out errorResult, $"Operation at position {position} failed because data was not of compatible categories.");
-                    }
+                    return FailWithError(out errorResult, $"Operation at position {position} failed because data was not of compatible categories.");
                 }
-                else if (rhs.IsVectorResult)
+            }
+            else if (rhs.IsVectorResult)
+            {
+                switch (rhs.Direction)
                 {
-                    switch (rhs.Direction)
-                    {
-                        case ComputationResult.VectorDirection.Horizontal:
-                            if (!(lhs.OdData!.ColumnCategories == rhs.VectorData!.Categories))
-                            {
-                                return FailWithError(out errorResult, $"Operation at position {position} failed because data was not of compatible categories.");
-                            }
-                            break;
-                        case ComputationResult.VectorDirection.Vertical:
-                            if (!(lhs.OdData!.RowCategories == rhs.VectorData!.Categories))
-                            {
-                                return FailWithError(out errorResult, $"Operation at position {position} failed because data was not of compatible categories.");
-                            }
-                            break;
-                        case ComputationResult.VectorDirection.Unassigned:
-                            return FailWithError(out errorResult, $"Operation at position {position} failed because a non-oriented vector can not be applied to a matrix.");
-                    }
+                    case ComputationResult.VectorDirection.Horizontal:
+                        if (!(lhs.OdData!.ColumnCategories == rhs.VectorData!.Categories))
+                        {
+                            return FailWithError(out errorResult, $"Operation at position {position} failed because data was not of compatible categories.");
+                        }
+                        break;
+                    case ComputationResult.VectorDirection.Vertical:
+                        if (!(lhs.OdData!.RowCategories == rhs.VectorData!.Categories))
+                        {
+                            return FailWithError(out errorResult, $"Operation at position {position} failed because data was not of compatible categories.");
+                        }
+                        break;
+                    case ComputationResult.VectorDirection.Unassigned:
+                        return FailWithError(out errorResult, $"Operation at position {position} failed because a non-oriented vector can not be applied to a matrix.");
                 }
             }
-            else if (lhs.IsVectorResult)
+        }
+        else if (lhs.IsVectorResult)
+        {
+            if (rhs.IsVectorResult)
             {
-                if (rhs.IsVectorResult)
+                if (lhs.VectorData!.Categories != rhs.VectorData!.Categories)
                 {
-                    if (lhs.VectorData!.Categories != rhs.VectorData!.Categories)
-                    {
-                        return FailWithError(out errorResult, "Operation failed because data was not of compatible categories.");
-                    }
+                    return FailWithError(out errorResult, "Operation failed because data was not of compatible categories.");
                 }
             }
-            return true;
         }
+        return true;
+    }
 
-        private static int FindEndOfBracket(char[] buffer, int start, int length, 
-            [NotNullWhen(false)] ref string? error)
+    private static int FindEndOfBracket(char[] buffer, int start, int length,
+        [NotNullWhen(false)] ref string? error)
+    {
+        int bracketLevel = 1;
+        int i = start;
+        for (; i < start + length && bracketLevel > 0; i++)
         {
-            int bracketLevel = 1;
-            int i = start;
-            for (; i < start + length && bracketLevel > 0; i++)
+            if (buffer[i] == ')')
             {
-                if (buffer[i] == ')')
-                {
-                    bracketLevel--;
-                }
-                else if (buffer[i] == '(')
-                {
-                    bracketLevel++;
-                }
+                bracketLevel--;
             }
-            if (bracketLevel == 0)
+            else if (buffer[i] == '(')
             {
-                return i - 1;
+                bracketLevel++;
             }
-            error = "Unable to find end of bracket starting at position " + start;
-            return -1;
         }
-
-        internal static bool Optimize(
-            [NotNullWhen(true)] ref Expression ex,
-            [NotNullWhen(false)] ref string? error)
+        if (bracketLevel == 0)
         {
-            // if this ever becomes a real problem try to add some optimization to the expression tree
-            return ex.OptimizeAst(ref ex, ref error);
+            return i - 1;
         }
+        error = "Unable to find end of bracket starting at position " + start;
+        return -1;
+    }
+
+    internal static bool Optimize(
+        [NotNullWhen(true)] ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        // if this ever becomes a real problem try to add some optimization to the expression tree
+        return ex.OptimizeAst(ref ex, ref error);
+    }
 
 
-        private static int FindStartOfBracket(char[] buffer, int start, int length, 
-            [NotNullWhen(false)] ref string? error)
+    private static int FindStartOfBracket(char[] buffer, int start, int length,
+        [NotNullWhen(false)] ref string? error)
+    {
+        int bracketLevel = 1;
+        int i = start + length - 1;
+        for (; i >= start && bracketLevel > 0; i--)
         {
-            int bracketLevel = 1;
-            int i = start + length - 1;
-            for (; i >= start && bracketLevel > 0; i--)
+            if (buffer[i] == '(')
             {
-                if (buffer[i] == '(')
-                {
-                    bracketLevel--;
-                }
-                else if (buffer[i] == ')')
-                {
-                    bracketLevel++;
-                }
+                bracketLevel--;
             }
-            if (bracketLevel == 0)
+            else if (buffer[i] == ')')
             {
-                return i + 1;
+                bracketLevel++;
             }
-            error = "Unable to find start of bracket with the end bracket at position " + start;
-            return -1;
         }
+        if (bracketLevel == 0)
+        {
+            return i + 1;
+        }
+        error = "Unable to find start of bracket with the end bracket at position " + start;
+        return -1;
+    }
 
-        private static bool AnyNonWhitespace(char[] buffer, int start, int length)
+    private static bool AnyNonWhitespace(char[] buffer, int start, int length)
+    {
+        for (int i = start; i < start + length; i++)
         {
-            for (int i = start; i < start + length; i++)
+            if (buffer[i] != ' ')
             {
-                if (buffer[i] != ' ')
-                {
-                    return true;
-                }
+                return true;
             }
-            return false;
         }
+        return false;
+    }
 
-        private static bool IsCompareType(Expression e)
+    private static bool IsCompareType(Expression e)
+    {
+        var t = e.GetType();
+        if (t == typeof(Bracket))
         {
-            var t = e.GetType();
-            if (t == typeof(Bracket))
+            var inner = ((Bracket)e).InnerExpression;
+            if (inner is null)
             {
-                var inner = ((Bracket)e).InnerExpression;
-                if (inner is null)
-                {
-                    return false;
-                }
-                return IsCompareType(inner);
+                return false;
             }
-            return t == typeof(CompareEqual)
-                || t == typeof(CompareNotEquals)
-                || t == typeof(CompareGreaterThan)
-                || t == typeof(CompareGreaterThanOrEqual)
-                || t == typeof(CompareAnd)
-                || t == typeof(CompareOr);
-        }
-
-        public static bool Compile(char[] buffer, int start, int length, 
-            [NotNullWhen(true)] out Expression? ex,
-            [NotNullWhen(false)] ref string? error)
-        {
-            ex = null;
-            var endPlusOne = (length + start);
-            // support AND and OR for our compare operations
-            for (int i = start; i < endPlusOne; i++)
+            return IsCompareType(inner);
+        }
+        return t == typeof(CompareEqual)
+            || t == typeof(CompareNotEquals)
+            || t == typeof(CompareGreaterThan)
+            || t == typeof(CompareGreaterThanOrEqual)
+            || t == typeof(CompareAnd)
+            || t == typeof(CompareOr);
+    }
+
+    public static bool Compile(char[] buffer, int start, int length,
+        [NotNullWhen(true)] out Expression? ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        ex = null;
+        var endPlusOne = (length + start);
+        // support AND and OR for our compare operations
+        for (int i = start; i < endPlusOne; i++)
+        {
+            switch (buffer[i])
             {
-                switch (buffer[i])
-                {
-                    case '(':
+                case '(':
+                    {
+                        int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
+                        if (endIndex < 0)
                         {
-                            int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
-                            if (endIndex < 0)
-                            {
-                                error = $"At position {i} we found a '(' character without an accompanying ')'";
-                                return false;
-                            }
-                            i = endIndex;
+                            error = $"At position {i} we found a '(' character without an accompanying ')'";
+                            return false;
                         }
-                        break;
-                    case '&':
+                        i = endIndex;
+                    }
+                    break;
+                case '&':
+                    {
+                        BinaryExpression toReturn = new CompareAnd(i);
+                        if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
+                        if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
+                        // test LHS to make sure it is a compare
+                        if (!IsCompareType(toReturn.Lhs) && !IsCompareType(toReturn.Rhs))
                         {
-                            BinaryExpression toReturn = new CompareAnd(i);
-                            if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
-                            if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
-                            // test LHS to make sure it is a compare
-                            if (!IsCompareType(toReturn.Lhs) && !IsCompareType(toReturn.Rhs))
-                            {
-                                error = $"At position {i} we found an '&' character where neither the LHS and the RHS were flag types, at least one is required!";
-                                return false;
-                            }
-                            ex = toReturn;
-                            return true;
+                            error = $"At position {i} we found an '&' character where neither the LHS and the RHS were flag types, at least one is required!";
+                            return false;
+                        }
+                        ex = toReturn;
+                        return true;
+                    }
+                case '|':
+                    {
+                        BinaryExpression toReturn = new CompareOr(i);
+                        if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
+                        if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
+                        // test LHS to make sure it is a compare
+                        if (!IsCompareType(toReturn.Lhs))
+                        {
+                            error = $"At position {i} we found a '|' character where the LHS was not a flag type!";
+                            return false;
                         }
-                    case '|':
+                        // test RHS to make sure it is a compare
+                        if (!IsCompareType(toReturn.Rhs))
                         {
-                            BinaryExpression toReturn = new CompareOr(i);
-                            if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
-                            if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
-                            // test LHS to make sure it is a compare
-                            if (!IsCompareType(toReturn.Lhs))
-                            {
-                                error = $"At position {i} we found a '|' character where the LHS was not a flag type!";
-                                return false;
-                            }
-                            // test RHS to make sure it is a compare
-                            if (!IsCompareType(toReturn.Rhs))
-                            {
-                                error = $"At position {i} we found a '|' character where the RHS was not a flag type!";
-                                return false;
-                            }
-                            ex = toReturn;
-                            return true;
+                            error = $"At position {i} we found a '|' character where the RHS was not a flag type!";
+                            return false;
                         }
-                }
+                        ex = toReturn;
+                        return true;
+                    }
             }
-            // support compare
-            for (int i = start; i < endPlusOne; i++)
+        }
+        // support compare
+        for (int i = start; i < endPlusOne; i++)
+        {
+            switch (buffer[i])
             {
-                switch (buffer[i])
-                {
-                    case '(':
+                case '(':
+                    {
+                        int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
+                        if (endIndex < 0)
                         {
-                            int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
-                            if (endIndex < 0)
-                            {
-                                error = $"At position {i} we found a '(' character without an accompanying ')'";
-                                return false;
-                            }
-                            i = endIndex;
+                            error = $"At position {i} we found a '(' character without an accompanying ')'";
+                            return false;
                         }
-                        break;
-                    case '=':
+                        i = endIndex;
+                    }
+                    break;
+                case '=':
+                    {
+                        if (i + 1 < endPlusOne && buffer[i + 1] == '=')
                         {
-                            if (i + 1 < endPlusOne && buffer[i + 1] == '=')
-                            {
-                                BinaryExpression toReturn = new CompareEqual(i);
-                                if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
-                                if (!Compile(buffer, i + 2, endPlusOne - i - 2, out toReturn.Rhs, ref error)) return false;
-                                ex = toReturn;
-                                return true;
-                            }
-                            else
-                            {
-                                error = $"At position {i} we found an '=' character without an accompanying '='!";
-                                return false;
-                            }
+                            BinaryExpression toReturn = new CompareEqual(i);
+                            if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
+                            if (!Compile(buffer, i + 2, endPlusOne - i - 2, out toReturn.Rhs, ref error)) return false;
+                            ex = toReturn;
+                            return true;
                         }
-                    case '!':
+                        else
                         {
-                            if (i + 1 < endPlusOne && buffer[i + 1] == '=')
-                            {
-                                BinaryExpression toReturn = new CompareNotEquals(i);
-                                if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
-                                if (!Compile(buffer, i + 2, endPlusOne - i - 2, out toReturn.Rhs, ref error)) return false;
-                                ex = toReturn;
-                                return true;
-                            }
-                            else
-                            {
-                                error = $"At position {i} we found an '!' character without an accompanying '='!";
-                                return false;
-                            }
+                            error = $"At position {i} we found an '=' character without an accompanying '='!";
+                            return false;
                         }
-                    case '>':
+                    }
+                case '!':
+                    {
+                        if (i + 1 < endPlusOne && buffer[i + 1] == '=')
                         {
-                            if (i + 1 < endPlusOne && buffer[i + 1] == '=')
-                            {
-                                BinaryExpression toReturn = new CompareGreaterThanOrEqual(i);
-                                if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
-                                if (!Compile(buffer, i + 2, endPlusOne - i - 2, out toReturn.Rhs, ref error)) return false;
-                                ex = toReturn;
-                                return true;
-                            }
-                            else
-                            {
-                                BinaryExpression toReturn = new CompareGreaterThan(i);
-                                if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
-                                if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
-                                ex = toReturn;
-                                return true;
-                            }
+                            BinaryExpression toReturn = new CompareNotEquals(i);
+                            if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
+                            if (!Compile(buffer, i + 2, endPlusOne - i - 2, out toReturn.Rhs, ref error)) return false;
+                            ex = toReturn;
+                            return true;
                         }
-                    case '<':
+                        else
                         {
-                            if (i + 1 < endPlusOne && buffer[i + 1] == '=')
-                            {
-                                // Inverse the LHS and RHS to reuse the greater comparisons
-                                BinaryExpression toReturn = new CompareGreaterThanOrEqual(i);
-                                if (!Compile(buffer, i + 2, endPlusOne - i - 2, out toReturn.Lhs, ref error)) return false;
-                                if (!Compile(buffer, start, i - start, out toReturn.Rhs, ref error)) return false;
-                                ex = toReturn;
-                                return true;
-                            }
-                            else
-                            {
-                                // Inverse the LHS and RHS to reuse the greater comparisons
-                                BinaryExpression toReturn = new CompareGreaterThan(i);
-                                if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Lhs, ref error)) return false;
-                                if (!Compile(buffer, start, i - start, out toReturn.Rhs, ref error)) return false;
-                                ex = toReturn;
-                                return true;
-                            }
+                            error = $"At position {i} we found an '!' character without an accompanying '='!";
+                            return false;
                         }
-                }
-            }
-            // try to extract +
-            for (int i = start; i < endPlusOne; i++)
-            {
-                switch (buffer[i])
-                {
-                    case '(':
+                    }
+                case '>':
+                    {
+                        if (i + 1 < endPlusOne && buffer[i + 1] == '=')
                         {
-                            int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
-                            if (endIndex < 0)
-                            {
-                                error = $"At position {i} we found a '(' character without an accompanying ')'";
-                                return false;
-                            }
-                            i = endIndex;
+                            BinaryExpression toReturn = new CompareGreaterThanOrEqual(i);
+                            if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
+                            if (!Compile(buffer, i + 2, endPlusOne - i - 2, out toReturn.Rhs, ref error)) return false;
+                            ex = toReturn;
+                            return true;
                         }
-                        break;
-                    case '+':
+                        else
                         {
-                            BinaryExpression toReturn = new Add(i);
-                            if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error))
-                            {
-                                return false;
-                            }
+                            BinaryExpression toReturn = new CompareGreaterThan(i);
+                            if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
                             if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
                             ex = toReturn;
                             return true;
                         }
-                }
-            }
-            // try to extract -
-            for (int i = start; i < endPlusOne; i++)
-            {
-                switch (buffer[i])
-                {
-                    case '(':
+                    }
+                case '<':
+                    {
+                        if (i + 1 < endPlusOne && buffer[i + 1] == '=')
                         {
-                            int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
-                            if (endIndex < 0)
-                            {
-                                error = $"At position {i} we found a '(' character without an accompanying ')'";
-                                return false;
-                            }
-                            i = endIndex;
+                            // Inverse the LHS and RHS to reuse the greater comparisons
+                            BinaryExpression toReturn = new CompareGreaterThanOrEqual(i);
+                            if (!Compile(buffer, i + 2, endPlusOne - i - 2, out toReturn.Lhs, ref error)) return false;
+                            if (!Compile(buffer, start, i - start, out toReturn.Rhs, ref error)) return false;
+                            ex = toReturn;
+                            return true;
                         }
-                        break;
-                    case '-':
+                        else
                         {
-                            BinaryExpression toReturn = new Subtract(i);
-                            if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error))
-                            {
-                                // check to see if it is negate
-                                if (buffer[i] == '-')
-                                {
-                                    bool anythingAfter = false;
-                                    for (int k = i + 1; k < endPlusOne; k++)
-                                    {
-                                        if (!char.IsWhiteSpace(buffer[k]))
-                                        {
-                                            anythingAfter = true;
-                                            break;
-                                        }
-                                    }
-                                    if (anythingAfter)
-                                    {
-                                        error = null;
-                                        continue;
-                                    }
-                                }
-                                return false;
-                            }
-                            if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
+                            // Inverse the LHS and RHS to reuse the greater comparisons
+                            BinaryExpression toReturn = new CompareGreaterThan(i);
+                            if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Lhs, ref error)) return false;
+                            if (!Compile(buffer, start, i - start, out toReturn.Rhs, ref error)) return false;
                             ex = toReturn;
                             return true;
                         }
-                }
+                    }
             }
-            // if there are no adds work on multiplies fix this for division
-            for (int i = start; i < endPlusOne; i++)
+        }
+        // try to extract +
+        for (int i = start; i < endPlusOne; i++)
+        {
+            switch (buffer[i])
             {
-                switch (buffer[i])
-                {
-                    case '(':
+                case '(':
+                    {
+                        int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
+                        if (endIndex < 0)
                         {
-                            int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
-                            if (endIndex < 0)
-                            {
-                                error = $"At position {i} we found a '(' character without an accompanying ')'";
-                                return false;
-                            }
-                            i = endIndex;
+                            error = $"At position {i} we found a '(' character without an accompanying ')'";
+                            return false;
                         }
-                        break;
-                    case '*':
+                        i = endIndex;
+                    }
+                    break;
+                case '+':
+                    {
+                        BinaryExpression toReturn = new Add(i);
+                        if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error))
                         {
-                            BinaryExpression toReturn = new Multiply(i);
-                            if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
-                            if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
-                            ex = toReturn;
-                            return true;
+                            return false;
                         }
-                }
+                        if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
+                        ex = toReturn;
+                        return true;
+                    }
             }
-            // if there are no adds work on division
-            for (int i = length + start - 1; i >= start; i--)
+        }
+        // try to extract -
+        for (int i = start; i < endPlusOne; i++)
+        {
+            switch (buffer[i])
             {
-                switch (buffer[i])
-                {
-                    case ')':
+                case '(':
+                    {
+                        int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
+                        if (endIndex < 0)
                         {
-                            int endIndex = FindStartOfBracket(buffer, start, i - start, ref error);
-                            if (endIndex < 0)
-                            {
-                                error = $"At position {i} we found a ')' character without an accompanying '('";
-                                return false;
-                            }
-                            i = endIndex;
+                            error = $"At position {i} we found a '(' character without an accompanying ')'";
+                            return false;
                         }
-                        break;
-                    case '/':
+                        i = endIndex;
+                    }
+                    break;
+                case '-':
+                    {
+                        BinaryExpression toReturn = new Subtract(i);
+                        if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error))
                         {
-                            BinaryExpression toReturn = new Divide(i);
-                            if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
-                            if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
-                            ex = toReturn;
-                            return true;
+                            // check to see if it is negate
+                            if (buffer[i] == '-')
+                            {
+                                bool anythingAfter = false;
+                                for (int k = i + 1; k < endPlusOne; k++)
+                                {
+                                    if (!char.IsWhiteSpace(buffer[k]))
+                                    {
+                                        anythingAfter = true;
+                                        break;
+                                    }
+                                }
+                                if (anythingAfter)
+                                {
+                                    error = null;
+                                    continue;
+                                }
+                            }
+                            return false;
                         }
-                }
+                        if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
+                        ex = toReturn;
+                        return true;
+                    }
             }
-            // support exponents
-            for (int i = start; i < endPlusOne; i++)
+        }
+        // if there are no adds work on multiplies fix this for division
+        for (int i = start; i < endPlusOne; i++)
+        {
+            switch (buffer[i])
             {
-                switch (buffer[i])
-                {
-                    case '(':
+                case '(':
+                    {
+                        int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
+                        if (endIndex < 0)
                         {
-                            int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
-                            if (endIndex < 0)
-                            {
-                                error = $"At position {i} we found a '(' character without an accompanying ')'";
-                                return false;
-                            }
-                            i = endIndex;
+                            error = $"At position {i} we found a '(' character without an accompanying ')'";
+                            return false;
                         }
-                        break;
-                    case '^':
+                        i = endIndex;
+                    }
+                    break;
+                case '*':
+                    {
+                        BinaryExpression toReturn = new Multiply(i);
+                        if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
+                        if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
+                        ex = toReturn;
+                        return true;
+                    }
+            }
+        }
+        // if there are no adds work on division
+        for (int i = length + start - 1; i >= start; i--)
+        {
+            switch (buffer[i])
+            {
+                case ')':
+                    {
+                        int endIndex = FindStartOfBracket(buffer, start, i - start, ref error);
+                        if (endIndex < 0)
                         {
-                            BinaryExpression toReturn = new Exponent(i);
-                            if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
-                            if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
-                            ex = toReturn;
-                            return true;
+                            error = $"At position {i} we found a ')' character without an accompanying '('";
+                            return false;
                         }
-                }
+                        i = endIndex;
+                    }
+                    break;
+                case '/':
+                    {
+                        BinaryExpression toReturn = new Divide(i);
+                        if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
+                        if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
+                        ex = toReturn;
+                        return true;
+                    }
             }
-            // support negate
-            for (int i = start; i < endPlusOne; i++)
+        }
+        // support exponents
+        for (int i = start; i < endPlusOne; i++)
+        {
+            switch (buffer[i])
             {
-                switch (buffer[i])
-                {
-                    case '(':
+                case '(':
+                    {
                         int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
                         if (endIndex < 0)
                         {
@@ -499,310 +467,334 @@ public static bool Compile(char[] buffer, int start, int length,
                             return false;
                         }
                         i = endIndex;
-                        break;
-                    case '-':
-                        {
-                            MonoExpression toReturn = new Negate(start);
-                            if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.InnerExpression, ref error)) return false;
-                            ex = toReturn;
-                            return true;
-                        }
-                }
+                    }
+                    break;
+                case '^':
+                    {
+                        BinaryExpression toReturn = new Exponent(i);
+                        if (!Compile(buffer, start, i - start, out toReturn.Lhs, ref error)) return false;
+                        if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.Rhs, ref error)) return false;
+                        ex = toReturn;
+                        return true;
+                    }
             }
-            StringBuilder builder = new StringBuilder();
-            bool first = true;
-            bool complete = false;
-            // check for function calls
-            for (int i = start; i < start + length && !complete; i++)
+        }
+        // support negate
+        for (int i = start; i < endPlusOne; i++)
+        {
+            switch (buffer[i])
             {
-                switch (buffer[i])
-                {
-                    case ' ':
-                        if (!first)
+                case '(':
+                    int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
+                    if (endIndex < 0)
+                    {
+                        error = $"At position {i} we found a '(' character without an accompanying ')'";
+                        return false;
+                    }
+                    i = endIndex;
+                    break;
+                case '-':
+                    {
+                        MonoExpression toReturn = new Negate(start);
+                        if (!Compile(buffer, i + 1, endPlusOne - i - 1, out toReturn.InnerExpression, ref error)) return false;
+                        ex = toReturn;
+                        return true;
+                    }
+            }
+        }
+        StringBuilder builder = new StringBuilder();
+        bool first = true;
+        bool complete = false;
+        // check for function calls
+        for (int i = start; i < start + length && !complete; i++)
+        {
+            switch (buffer[i])
+            {
+                case ' ':
+                    if (!first)
+                    {
+                        complete = true;
+                    }
+                    break;
+                case '(':
+                    {
+                        if (first)
                         {
                             complete = true;
                         }
-                        break;
-                    case '(':
+                        else
                         {
-                            if (first)
+                            int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
+                            if (endIndex < 0)
                             {
-                                complete = true;
+                                error = $"At position {i} we found a '(' character without an accompanying ')'";
+                                return false;
                             }
-                            else
+                            List<Expression> parameters = new List<Expression>();
+                            int lastStart = i + 1;
+                            Expression? p;
+                            for (int j = i + 1; j < endIndex; j++)
                             {
-                                int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
-                                if (endIndex < 0)
+                                if (buffer[j] == '(')
                                 {
-                                    error = $"At position {i} we found a '(' character without an accompanying ')'";
-                                    return false;
-                                }
-                                List<Expression> parameters = new List<Expression>();
-                                int lastStart = i + 1;
-                                Expression? p;
-                                for (int j = i + 1; j < endIndex; j++)
-                                {
-                                    if (buffer[j] == '(')
-                                    {
-                                        // skip to the end
-                                        var innerEndIndex = FindEndOfBracket(buffer, j + 1, endIndex, ref error);
-                                        if (innerEndIndex < 0)
-                                        {
-                                            error = $"At position {j} we found a '(' character without an accompanying ')'";
-                                            return false;
-                                        }
-                                        j = innerEndIndex;
-                                    }
-                                    if (buffer[j] == ',')
+                                    // skip to the end
+                                    var innerEndIndex = FindEndOfBracket(buffer, j + 1, endIndex, ref error);
+                                    if (innerEndIndex < 0)
                                     {
-                                        if (!Compile(buffer, lastStart, j - lastStart, out p, ref error))
-                                        {
-                                            return false;
-                                        }
-                                        parameters.Add(p);
-                                        lastStart = j + 1;
+                                        error = $"At position {j} we found a '(' character without an accompanying ')'";
+                                        return false;
                                     }
+                                    j = innerEndIndex;
                                 }
-                                if (AnyNonWhitespace(buffer, lastStart, endIndex - lastStart))
+                                if (buffer[j] == ',')
                                 {
-                                    // add the final parameter
-                                    if (!Compile(buffer, lastStart, endIndex - lastStart, out p, ref error))
+                                    if (!Compile(buffer, lastStart, j - lastStart, out p, ref error))
                                     {
                                         return false;
                                     }
                                     parameters.Add(p);
+                                    lastStart = j + 1;
                                 }
-                                if (!FunctionCall.GetCall(start, builder.ToString(), parameters.ToArray(), out FunctionCall? toReturn, ref error))
+                            }
+                            if (AnyNonWhitespace(buffer, lastStart, endIndex - lastStart))
+                            {
+                                // add the final parameter
+                                if (!Compile(buffer, lastStart, endIndex - lastStart, out p, ref error))
                                 {
                                     return false;
                                 }
-                                ex = toReturn;
-                                return true;
-                            }
-                        }
-                        break;
-                    default:
-                        first = false;
-                        builder.Append(buffer[i]);
-                        break;
-                }
-            }
-            // deal with brackets
-            for (int i = start; i < start + length; i++)
-            {
-                switch (buffer[i])
-                {
-                    case '(':
-                        {
-                            int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
-                            if (endIndex < 0)
-                            {
-                                error = $"At position {i} we found a '(' character without an accompanying ')'";
-                                return false;
+                                parameters.Add(p);
                             }
-                            var toReturn = new Bracket(i);
-                            if (!Compile(buffer, i + 1, (endIndex - i) - 1, out toReturn.InnerExpression, ref error))
+                            if (!FunctionCall.GetCall(start, builder.ToString(), parameters.ToArray(), out FunctionCall? toReturn, ref error))
                             {
                                 return false;
                             }
                             ex = toReturn;
                             return true;
                         }
-                }
+                    }
+                    break;
+                default:
+                    first = false;
+                    builder.Append(buffer[i]);
+                    break;
             }
-            // try to extract literal / variable name
-            builder.Clear();
-            first = true;
-            complete = false;
-            int index = -1;
-            for (int i = start; i < endPlusOne && !complete; i++)
+        }
+        // deal with brackets
+        for (int i = start; i < start + length; i++)
+        {
+            switch (buffer[i])
             {
-                switch (buffer[i])
-                {
-                    case ' ':
-                        if (first)
-                        {
-                            // just skip
-                        }
-                        else
+                case '(':
+                    {
+                        int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
+                        if (endIndex < 0)
                         {
-                            complete = true;
-                            // end of string
+                            error = $"At position {i} we found a '(' character without an accompanying ')'";
+                            return false;
                         }
-                        break;
-                    default:
-                        if (first)
+                        var toReturn = new Bracket(i);
+                        if (!Compile(buffer, i + 1, (endIndex - i) - 1, out toReturn.InnerExpression, ref error))
                         {
-                            first = false;
-                            index = i;
+                            return false;
                         }
-                        builder.Append(buffer[i]);
-                        break;
-                }
-            }
-            var value = builder.ToString();
-            if (value.Length <= 0)
-            {
-                error = "We were unable to read in a value at position " + start;
-                return false;
-            }
-            if (float.TryParse(value, out float f))
-            {
-                // if we can read it in as a floating point number
-                ex = new Literal(index, f);
+                        ex = toReturn;
+                        return true;
+                    }
             }
-            else
+        }
+        // try to extract literal / variable name
+        builder.Clear();
+        first = true;
+        complete = false;
+        int index = -1;
+        for (int i = start; i < endPlusOne && !complete; i++)
+        {
+            switch (buffer[i])
             {
-                ex = new Variable(index, value);
+                case ' ':
+                    if (first)
+                    {
+                        // just skip
+                    }
+                    else
+                    {
+                        complete = true;
+                        // end of string
+                    }
+                    break;
+                default:
+                    if (first)
+                    {
+                        first = false;
+                        index = i;
+                    }
+                    builder.Append(buffer[i]);
+                    break;
             }
-            return true;
         }
+        var value = builder.ToString();
+        if (value.Length <= 0)
+        {
+            error = "We were unable to read in a value at position " + start;
+            return false;
+        }
+        if (float.TryParse(value, out float f))
+        {
+            // if we can read it in as a floating point number
+            ex = new Literal(index, f);
+        }
+        else
+        {
+            ex = new Variable(index, value);
+        }
+        return true;
     }
+}
 
 
-    public abstract class MonoExpression : Expression
-    {
-        public Expression? InnerExpression;
+public abstract class MonoExpression : Expression
+{
+    public Expression? InnerExpression;
 
-        public MonoExpression(int start) : base(start)
-        {
+    public MonoExpression(int start) : base(start)
+    {
 
-        }
+    }
 
-        internal override bool OptimizeAst( 
-            ref Expression ex,
-            [NotNullWhen(false)] ref string? error)
+    internal override bool OptimizeAst(
+        ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        if (InnerExpression is null)
         {
-            if (InnerExpression is null)
-            {
-                error = "MonoExpression at position " + Start + " has no inner expression!";
-                return false;
-            }
-            return InnerExpression.OptimizeAst(ref InnerExpression, ref error);
+            error = "MonoExpression at position " + Start + " has no inner expression!";
+            return false;
         }
+        return InnerExpression.OptimizeAst(ref InnerExpression, ref error);
     }
+}
+
+public abstract class BinaryExpression : Expression
+{
+    public Expression? Lhs;
+    public Expression? Rhs;
 
-    public abstract class BinaryExpression : Expression
+    public BinaryExpression(int start) : base(start)
     {
-        public Expression? Lhs;
-        public Expression? Rhs;
 
-        public BinaryExpression(int start) : base(start)
-        {
+    }
 
+    public override ComputationResult Evaluate(IModule[] dataSources)
+    {
+        ComputationResult lhs = null!;
+        ComputationResult rhs = null!;
+        if (Lhs is null)
+        {
+            return new ComputationResult($"BinaryExpression at position {Start} has no LHS!");
         }
-
-        public override ComputationResult Evaluate(IModule[] dataSources)
+        if (Rhs is null)
         {
-            ComputationResult lhs = null!;
-            ComputationResult rhs = null!;
-            if (Lhs is null)
-            {
-                return new ComputationResult($"BinaryExpression at position {Start} has no LHS!");
-            }
-            if (Rhs is null)
-            {
-                return new ComputationResult($"BinaryExpression at position {Start} has no RHS!");
-            }
-            Parallel.Invoke(
-                () => lhs = Lhs.Evaluate(dataSources),
-                () => rhs = Rhs.Evaluate(dataSources));
-            if (lhs.Error)
-            {
-                return lhs;
-            }
-            else if (rhs.Error)
-            {
-                return rhs;
-            }
-            if (!ValidateSizes(lhs, rhs, Start, out var errorResult))
-            {
-                return errorResult;
-            }
-            return Evaluate(lhs, rhs);
+            return new ComputationResult($"BinaryExpression at position {Start} has no RHS!");
         }
-
-        public abstract ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs);
-
-        internal override bool OptimizeAst(ref Expression ex, 
-            [NotNullWhen(false)] ref string? error)
+        Parallel.Invoke(
+            () => lhs = Lhs.Evaluate(dataSources),
+            () => rhs = Rhs.Evaluate(dataSources));
+        if (lhs.Error)
         {
-            if (Lhs is null)
-            {
-                error = "BinaryExpression at position " + Start + " has no LHS!";
-                return false;
-            }
-            if (Rhs is null)
-            {
-                error = "BinaryExpression at position " + Start + " has no RHS!";
-                return false;
-            }
-            if (!Lhs.OptimizeAst(ref Lhs, ref error) || !Rhs.OptimizeAst(ref Rhs, ref error))
-            {
-                return false;
-            }
-            return true;
+            return lhs;
         }
-    }
-
-    public abstract class Value : Expression
-    {
-        public Value(int start) : base(start)
+        else if (rhs.Error)
         {
-
+            return rhs;
         }
-
-        internal override bool OptimizeAst(ref Expression ex, 
-            [NotNullWhen(false)] ref string? error)
+        if (!ValidateSizes(lhs, rhs, Start, out var errorResult))
         {
-            return true;
+            return errorResult;
         }
+        return Evaluate(lhs, rhs);
     }
 
-    public class Bracket : MonoExpression
+    public abstract ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs);
+
+    internal override bool OptimizeAst(ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
     {
-        public Bracket(int start) : base(start)
+        if (Lhs is null)
         {
-
+            error = "BinaryExpression at position " + Start + " has no LHS!";
+            return false;
         }
-
-        public override ComputationResult Evaluate(IModule[] dataSources)
+        if (Rhs is null)
         {
-            if (InnerExpression is null)
-            {
-                return new ComputationResult($"Bracket at position {Start} has no inner expression!");
-            }
-            return InnerExpression.Evaluate(dataSources);
+            error = "BinaryExpression at position " + Start + " has no RHS!";
+            return false;
         }
-
-        internal override bool OptimizeAst(ref Expression ex,
-            [NotNullWhen(false)] ref string? error)
+        if (!Lhs.OptimizeAst(ref Lhs, ref error) || !Rhs.OptimizeAst(ref Rhs, ref error))
         {
-            if (InnerExpression is null)
-            {
-                error = "MonoExpression at position " + Start + " has no inner expression!";
-                return false;
-            }
-            if (!InnerExpression.OptimizeAst(ref ex, ref error))
-            {
-                return false;
-            }
-            return true;
+            return false;
         }
+        return true;
     }
+}
 
-    public class Literal : Value
+public abstract class Value : Expression
+{
+    public Value(int start) : base(start)
     {
-        public readonly float Value;
 
-        public Literal(int start, float value) : base(start)
+    }
+
+    internal override bool OptimizeAst(ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        return true;
+    }
+}
+
+public class Bracket : MonoExpression
+{
+    public Bracket(int start) : base(start)
+    {
+
+    }
+
+    public override ComputationResult Evaluate(IModule[] dataSources)
+    {
+        if (InnerExpression is null)
         {
-            Value = value;
+            return new ComputationResult($"Bracket at position {Start} has no inner expression!");
         }
+        return InnerExpression.Evaluate(dataSources);
+    }
 
-        public override ComputationResult Evaluate(IModule[] dataSources)
+    internal override bool OptimizeAst(ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        if (InnerExpression is null)
+        {
+            error = "MonoExpression at position " + Start + " has no inner expression!";
+            return false;
+        }
+        if (!InnerExpression.OptimizeAst(ref ex, ref error))
         {
-            return new ComputationResult(Value);
+            return false;
         }
+        return true;
+    }
+}
+
+public class Literal : Value
+{
+    public readonly float Value;
+
+    public Literal(int start, float value) : base(start)
+    {
+        Value = value;
+    }
+
+    public override ComputationResult Evaluate(IModule[] dataSources)
+    {
+        return new ComputationResult(Value);
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/FunctionCall.cs b/src/TMG-Framework/Processing/AST/FunctionCall.cs
index 118e7b4..d0a79a0 100644
--- a/src/TMG-Framework/Processing/AST/FunctionCall.cs
+++ b/src/TMG-Framework/Processing/AST/FunctionCall.cs
@@ -16,956 +16,952 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
+
 using TMG.Utilities;
-using XTMF2;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class FunctionCall : Value
 {
-    public sealed class FunctionCall : Value
+
+    public enum FunctionType
     {
+        Undefined,
+        Transpose,
+        SumRows,
+        SumColumns,
+        AsHorizontal,
+        AsVertical,
+        Sum,
+        Abs,
+        Avg,
+        AvgRows,
+        AvgColumns,
+        E,
+        Pi,
+        Length,
+        LengthColumns,
+        LengthRows,
+        ZeroMatrix,
+        Matrix,
+        IdentityMatrix,
+        Log,
+        Sqrt,
+        If,
+        IfNaN,
+        Normalize,
+        NormalizeColumns,
+        NormalizeRows
+    }
 
-        public enum FunctionType
-        {
-            Undefined,
-            Transpose,
-            SumRows,
-            SumColumns,
-            AsHorizontal,
-            AsVertical,
-            Sum,
-            Abs,
-            Avg,
-            AvgRows,
-            AvgColumns,
-            E,
-            Pi,
-            Length,
-            LengthColumns,
-            LengthRows,
-            ZeroMatrix,
-            Matrix,
-            IdentityMatrix,
-            Log,
-            Sqrt,
-            If,
-            IfNaN,
-            Normalize,
-            NormalizeColumns,
-            NormalizeRows
-        }
-
-        private readonly FunctionType _type;
-
-        private readonly Expression[] _parameters;
-
-        private FunctionCall(int start, FunctionType call, Expression[] parameters) : base(start)
-        {
-            _parameters = parameters;
-            _type = call;
-        }
-
-        internal override bool OptimizeAst(ref Expression ex, 
-            [NotNullWhen(false)] ref string? error)
-        {
-            for (int i = 0; i < _parameters.Length; i++)
-            {
-                if (!_parameters[i].OptimizeAst(ref _parameters[i], ref error))
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
+    private readonly FunctionType _type;
+
+    private readonly Expression[] _parameters;
 
-        public static bool GetCall(int start, string call, Expression[] parameters, 
-            [NotNullWhen(true)] out FunctionCall? ex,
-            [NotNullWhen(false)] ref string? error)
+    private FunctionCall(int start, FunctionType call, Expression[] parameters) : base(start)
+    {
+        _parameters = parameters;
+        _type = call;
+    }
+
+    internal override bool OptimizeAst(ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        for (int i = 0; i < _parameters.Length; i++)
         {
-            //decode the call to a type
-            ex = null;
-            if (!Decode(call, ref error, out FunctionType type))
+            if (!_parameters[i].OptimizeAst(ref _parameters[i], ref error))
             {
                 return false;
             }
-            ex = new FunctionCall(start, type, parameters);
-            return true;
         }
+        return true;
+    }
+
+    public static bool GetCall(int start, string call, Expression[] parameters,
+        [NotNullWhen(true)] out FunctionCall? ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        //decode the call to a type
+        ex = null;
+        if (!Decode(call, ref error, out FunctionType type))
+        {
+            return false;
+        }
+        ex = new FunctionCall(start, type, parameters);
+        return true;
+    }
 
-        private static bool Decode(string call, 
-            [NotNullWhen(false)] ref string? error,
-            out FunctionType type)
+    private static bool Decode(string call,
+        [NotNullWhen(false)] ref string? error,
+        out FunctionType type)
+    {
+        type = FunctionType.Undefined;
+        call = call.ToLowerInvariant();
+        switch (call)
         {
-            type = FunctionType.Undefined;
-            call = call.ToLowerInvariant();
-            switch (call)
-            {
-                case "ashorizontal":
-                    type = FunctionType.AsHorizontal;
-                    return true;
-                case "asvertical":
-                    type = FunctionType.AsVertical;
-                    return true;
-                case "transpose":
-                    type = FunctionType.Transpose;
-                    return true;
-                case "sumrows":
-                    type = FunctionType.SumRows;
-                    return true;
-                case "sumcolumns":
-                    type = FunctionType.SumColumns;
-                    return true;
-                case "sum":
-                    type = FunctionType.Sum;
-                    return true;
-                case "abs":
-                    type = FunctionType.Abs;
-                    return true;
-                case "avg":
-                    type = FunctionType.Avg;
-                    return true;
-                case "avgrows":
-                    type = FunctionType.AvgRows;
-                    return true;
-                case "avgcolumns":
-                    type = FunctionType.AvgColumns;
-                    return true;
-                case "e":
-                    type = FunctionType.E;
-                    return true;
-                case "pi":
-                    type = FunctionType.Pi;
-                    return true;
-                case "length":
-                    type = FunctionType.Length;
-                    return true;
-                case "lengthrows":
-                    type = FunctionType.LengthRows;
-                    return true;
-                case "lengthcolumns":
-                    type = FunctionType.LengthColumns;
-                    return true;
-                case "zeromatrix":
-                    type = FunctionType.ZeroMatrix;
-                    return true;
-                case "matrix":
-                    type = FunctionType.Matrix;
-                    return true;
-                case "identitymatrix":
-                    type = FunctionType.IdentityMatrix;
-                    return true;
-                case "log":
-                    type = FunctionType.Log;
-                    return true;
-                case "sqrt":
-                    type = FunctionType.Sqrt;
-                    return true;
-                case "if":
-                    type = FunctionType.If;
-                    return true;
-                case "ifnan":
-                    type = FunctionType.IfNaN;
-                    return true;
-                case "normalize":
-                    type = FunctionType.Normalize;
-                    return true;
-                case "normalizecolumns":
-                    type = FunctionType.NormalizeColumns;
-                    return true;
-                case "normalizerows":
-                    type = FunctionType.NormalizeRows;
-                    return true;
-                default:
-                    error = "The function '" + call + "' is undefined!";
-                    return false;
-            }
+            case "ashorizontal":
+                type = FunctionType.AsHorizontal;
+                return true;
+            case "asvertical":
+                type = FunctionType.AsVertical;
+                return true;
+            case "transpose":
+                type = FunctionType.Transpose;
+                return true;
+            case "sumrows":
+                type = FunctionType.SumRows;
+                return true;
+            case "sumcolumns":
+                type = FunctionType.SumColumns;
+                return true;
+            case "sum":
+                type = FunctionType.Sum;
+                return true;
+            case "abs":
+                type = FunctionType.Abs;
+                return true;
+            case "avg":
+                type = FunctionType.Avg;
+                return true;
+            case "avgrows":
+                type = FunctionType.AvgRows;
+                return true;
+            case "avgcolumns":
+                type = FunctionType.AvgColumns;
+                return true;
+            case "e":
+                type = FunctionType.E;
+                return true;
+            case "pi":
+                type = FunctionType.Pi;
+                return true;
+            case "length":
+                type = FunctionType.Length;
+                return true;
+            case "lengthrows":
+                type = FunctionType.LengthRows;
+                return true;
+            case "lengthcolumns":
+                type = FunctionType.LengthColumns;
+                return true;
+            case "zeromatrix":
+                type = FunctionType.ZeroMatrix;
+                return true;
+            case "matrix":
+                type = FunctionType.Matrix;
+                return true;
+            case "identitymatrix":
+                type = FunctionType.IdentityMatrix;
+                return true;
+            case "log":
+                type = FunctionType.Log;
+                return true;
+            case "sqrt":
+                type = FunctionType.Sqrt;
+                return true;
+            case "if":
+                type = FunctionType.If;
+                return true;
+            case "ifnan":
+                type = FunctionType.IfNaN;
+                return true;
+            case "normalize":
+                type = FunctionType.Normalize;
+                return true;
+            case "normalizecolumns":
+                type = FunctionType.NormalizeColumns;
+                return true;
+            case "normalizerows":
+                type = FunctionType.NormalizeRows;
+                return true;
+            default:
+                error = "The function '" + call + "' is undefined!";
+                return false;
         }
+    }
 
-        public override ComputationResult Evaluate(IModule[] dataSources)
+    public override ComputationResult Evaluate(IModule[] dataSources)
+    {
+        // first evaluate the parameters
+        var values = new ComputationResult[_parameters.Length];
+        switch (_parameters.Length)
         {
-            // first evaluate the parameters
-            var values = new ComputationResult[_parameters.Length];
-            switch (_parameters.Length)
-            {
-                case 0:
-                    break;
-                case 1:
+            case 0:
+                break;
+            case 1:
+                {
+                    values[0] = _parameters[0].Evaluate(dataSources);
+                    if (values[0].Error)
                     {
-                        values[0] = _parameters[0].Evaluate(dataSources);
-                        if (values[0].Error)
-                        {
-                            return values[0];
-                        }
+                        return values[0];
                     }
-                    break;
-                default:
+                }
+                break;
+            default:
+                {
+                    System.Threading.Tasks.Parallel.For(0, values.Length, (int i) =>
                     {
-                        System.Threading.Tasks.Parallel.For(0, values.Length, (int i) =>
-                        {
-                            values[i] = _parameters[i].Evaluate(dataSources);
-                        });
-                        for (int i = 0; i < values.Length; i++)
+                        values[i] = _parameters[i].Evaluate(dataSources);
+                    });
+                    for (int i = 0; i < values.Length; i++)
+                    {
+                        if (values[i].Error)
                         {
-                            if (values[i].Error)
-                            {
-                                return values[i];
-                            }
+                            return values[i];
                         }
                     }
-                    break;
-            }
+                }
+                break;
+        }
 
-            switch (_type)
-            {
-                case FunctionType.AsHorizontal:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("AsHorizontal at position " + Start + " was executed with the wrong number of parameters!");
-                    }
-                    if (!values[0].IsVectorResult)
-                    {
-                        return new ComputationResult("AsHorizontal at position " + Start + " was executed with a parameter that was not a vector!");
-                    }
-                    return new ComputationResult(values[0], ComputationResult.VectorDirection.Horizontal);
-                case FunctionType.AsVertical:
+        switch (_type)
+        {
+            case FunctionType.AsHorizontal:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("AsHorizontal at position " + Start + " was executed with the wrong number of parameters!");
+                }
+                if (!values[0].IsVectorResult)
+                {
+                    return new ComputationResult("AsHorizontal at position " + Start + " was executed with a parameter that was not a vector!");
+                }
+                return new ComputationResult(values[0], ComputationResult.VectorDirection.Horizontal);
+            case FunctionType.AsVertical:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("AsVertical at position " + Start + " was executed with the wrong number of parameters!");
+                }
+                if (!values[0].IsVectorResult)
+                {
+                    return new ComputationResult("AsVertical at position " + Start + " was executed with a parameter that was not a vector!");
+                }
+                return new ComputationResult(values[0], ComputationResult.VectorDirection.Vertical);
+            case FunctionType.Transpose:
+                {
                     if (values.Length != 1)
                     {
-                        return new ComputationResult("AsVertical at position " + Start + " was executed with the wrong number of parameters!");
-                    }
-                    if (!values[0].IsVectorResult)
-                    {
-                        return new ComputationResult("AsVertical at position " + Start + " was executed with a parameter that was not a vector!");
+                        return new ComputationResult("Transpose at position " + Start + " was executed with the wrong number of parameters!");
                     }
-                    return new ComputationResult(values[0], ComputationResult.VectorDirection.Vertical);
-                case FunctionType.Transpose:
+                    if (values[0].IsVectorResult)
                     {
-                        if (values.Length != 1)
+                        switch (values[0].Direction)
                         {
-                            return new ComputationResult("Transpose at position " + Start + " was executed with the wrong number of parameters!");
+                            case ComputationResult.VectorDirection.Horizontal:
+                                return new ComputationResult(values[0], ComputationResult.VectorDirection.Vertical);
+                            case ComputationResult.VectorDirection.Vertical:
+                                return new ComputationResult(values[0], ComputationResult.VectorDirection.Horizontal);
+                            case ComputationResult.VectorDirection.Unassigned:
+                                return new ComputationResult("Unable to transpose an vector that does not have a directionality!");
                         }
-                        if (values[0].IsVectorResult)
-                        {
-                            switch (values[0].Direction)
-                            {
-                                case ComputationResult.VectorDirection.Horizontal:
-                                    return new ComputationResult(values[0], ComputationResult.VectorDirection.Vertical);
-                                case ComputationResult.VectorDirection.Vertical:
-                                    return new ComputationResult(values[0], ComputationResult.VectorDirection.Horizontal);
-                                case ComputationResult.VectorDirection.Unassigned:
-                                    return new ComputationResult("Unable to transpose an vector that does not have a directionality!");
-                            }
-                        }
-                        if (values[0].IsValue)
-                        {
-                            return new ComputationResult("The parameter to Transpose at position " + Start + " was executed against a scalar!");
-                        }
-                        if (values[0].IsOdResult)
-                        {
-                            return TransposeOd(values[0]);
-                        }
-                        return new ComputationResult("Unsupported data type for Transpose at position " + Start + ".");
-                    }
-                case FunctionType.SumRows:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("SumRows was executed with the wrong number of parameters!");
-                    }
-                    if (!values[0].IsOdResult)
-                    {
-                        return new ComputationResult("SumRows was executed with a parameter that was not a matrix!");
-                    }
-                    return SumRows(values[0]);
-                case FunctionType.SumColumns:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("SumColumns was executed with the wrong number of parameters!");
-                    }
-                    if (!values[0].IsOdResult)
-                    {
-                        return new ComputationResult("SumColumns was executed with a parameter that was not a matrix!");
-                    }
-                    return SumColumns(values[0]);
-                case FunctionType.AvgRows:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("AvgRows was executed with the wrong number of parameters!");
-                    }
-                    if (!values[0].IsOdResult)
-                    {
-                        return new ComputationResult("AvgRows was executed with a parameter that was not a matrix!");
-                    }
-                    return AvgRows(values[0]);
-                case FunctionType.AvgColumns:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("AvgColumns was executed with the wrong number of parameters!");
-                    }
-                    if (!values[0].IsOdResult)
-                    {
-                        return new ComputationResult("AvgColumns was executed with a parameter that was not a matrix!");
-                    }
-                    return AvgColumns(values[0]);
-                case FunctionType.Sum:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("Sum was executed with the wrong number of parameters!");
                     }
                     if (values[0].IsValue)
                     {
-                        return new ComputationResult("Sum was executed with a parameter that was already a scalar value!");
-                    }
-                    return Sum(values[0]);
-                case FunctionType.Abs:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("Abs was executed with the wrong number of parameters!");
-                    }
-                    return Abs(values[0]);
-                case FunctionType.Avg:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("Avg was executed with the wrong number of parameters!");
-                    }
-                    if (values[0].IsValue)
-                    {
-                        return new ComputationResult("Avg was executed with a parameter that was already a scalar value!");
-                    }
-                    return Avg(values[0]);
-                case FunctionType.E:
-                    return new ComputationResult((float)Math.E);
-                case FunctionType.Pi:
-                    return new ComputationResult((float)Math.PI);
-                case FunctionType.Length:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("Length was executed with the wrong number of parameters!");
-                    }
-                    if (values[0].IsValue)
-                    {
-                        return new ComputationResult("Length can not be applied to a scalar!");
-                    }
-                    return Length(values[0]);
-                case FunctionType.LengthColumns:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("LengthColumns was executed with the wrong number of parameters!");
-                    }
-                    if (values[0].IsOdResult)
-                    {
-                        return new ComputationResult("LengthColumns must be applied to a Matrix!");
-                    }
-                    return LengthColumns(values[0]);
-                case FunctionType.LengthRows:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("LengthRows was executed with the wrong number of parameters!");
+                        return new ComputationResult("The parameter to Transpose at position " + Start + " was executed against a scalar!");
                     }
                     if (values[0].IsOdResult)
                     {
-                        return new ComputationResult("LengthRows must be applied to a Matrix!");
-                    }
-                    return LengthRows(values[0]);
-                case FunctionType.ZeroMatrix:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("ZeroMatrix was executed with the wrong number of parameters!");
-                    }
-                    if (values[0].IsValue)
-                    {
-                        return new ComputationResult("ZeroMatrix must be applied to a vector, or a matrix!");
-                    }
-                    return ZeroMatrix(values);
-                case FunctionType.Matrix:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("Matrix was executed with the wrong number of parameters!");
-                    }
-                    if (!values[0].IsVectorResult)
-                    {
-                        return new ComputationResult("Matrix must be applied to a vector!");
-                    }
-                    return Matrix(values[0]);
-                case FunctionType.IdentityMatrix:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("IdentityMatrix was executed with the wrong number of parameters!");
-                    }
-                    if (values[0].IsValue)
-                    {
-                        return new ComputationResult("IdentityMatrix must be applied to a vector, or a matrix!");
-                    }
-                    return IdentityMatrix(values[0]);
-                case FunctionType.Log:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("Log must be executed with one parameter!");
-                    }
-                    return Log(values);
-                case FunctionType.Sqrt:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("Sqrt must be executed with one parameter!");
-                    }
-                    return Sqrt(values);
-                case FunctionType.If:
-                    if (values.Length != 3)
-                    {
-                        return new ComputationResult("If requires at 3 parameters (condition, valueIfTrue, valueIfFalse)!");
-                    }
-                    return ComputeIf(values);
-                case FunctionType.IfNaN:
-                    if (values.Length != 2)
-                    {
-                        return new ComputationResult("IfNaN requires 2 parameters (original,replacement)!");
-                    }
-                    return ComputeIfNaN(values);
-                case FunctionType.Normalize:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("Normalize requires 1 parameter, a matrix to be normalized.");
+                        return TransposeOd(values[0]);
                     }
-                    return ComputeNormalize(values);
-                case FunctionType.NormalizeColumns:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("NormalizeColumns requires 1 parameter, a matrix to be normalized.");
-                    }
-                    return ComputeNormalizeColumns(values);
-                case FunctionType.NormalizeRows:
-                    if (values.Length != 1)
-                    {
-                        return new ComputationResult("NormalizeRows requires 1 parameter, a matrix to be normalized.");
-                    }
-                    return ComputeNormalizeRows(values);
-
-            }
-            return new ComputationResult("An undefined function was executed!");
-        }
-
-        private ComputationResult ComputeNormalizeColumns(ComputationResult[] values)
-        {
-            var toNormalize = values[0];
-            if (toNormalize.IsValue)
-            {
-                return new ComputationResult($"{Start + 1}:Normalize requires its parameter to be of type Matrix, not a scalar.");
-            }
-            if (toNormalize.IsVectorResult)
-            {
-                return new ComputationResult($"{Start + 1}:Normalize requires its parameter to be of type Matrix, not a vector.");
-            }
-            var writeTo = toNormalize.Accumulator ? toNormalize.OdData : new Matrix(toNormalize.OdData);
-            var readFrom = toNormalize.OdData;
-            var rowLength = readFrom.RowCategories.Count;
-            // This could be executed in parallel if proved to be more efficient
-            var columnTotals = new float[readFrom.ColumnCategories.Count];
-            var columnSpan = columnTotals.AsSpan();
-            for (int i = 0; i < rowLength; i++)
-            {
-                var readRow = readFrom.GetRow(i);
-                VectorHelper.Add(columnSpan, 0, columnSpan, 0, readRow, 0, readRow.Length);
-            }
-            System.Threading.Tasks.Parallel.For(0, rowLength, (int i) =>
-            {
-                var writeRow = writeTo.GetRow(i);
-                var readRow = readFrom.GetRow(i);
-                for (int j = 0; j < writeRow.Length; j++)
+                    return new ComputationResult("Unsupported data type for Transpose at position " + Start + ".");
+                }
+            case FunctionType.SumRows:
+                if (values.Length != 1)
                 {
-                    writeRow[j] = columnTotals[j] != 0f ? readRow[j] / columnTotals[j] : 0f;
+                    return new ComputationResult("SumRows was executed with the wrong number of parameters!");
                 }
-            });
-            return new ComputationResult(writeTo, true);
-        }
-
-        private ComputationResult ComputeNormalizeRows(ComputationResult[] values)
-        {
-            var toNormalize = values[0];
-            if (toNormalize.IsValue)
-            {
-                return new ComputationResult($"{Start + 1}:Normalize requires its parameter to be of type Matrix, not a scalar.");
-            }
-            if (toNormalize.IsVectorResult)
-            {
-                return new ComputationResult($"{Start + 1}:Normalize requires its parameter to be of type Matrix, not a vector.");
-            }
-            var rowLength = toNormalize.OdData.RowCategories.Count;
-            var writeTo = toNormalize.Accumulator ? toNormalize.OdData : new Matrix(toNormalize.OdData);
-            var readFrom = toNormalize.OdData;
-            System.Threading.Tasks.Parallel.For(0, rowLength, (int i) =>
-            {
-                var flatWrite = writeTo.GetRow(i);
-                var flatRead = readFrom.GetRow(i);
-                var denominator = VectorHelper.Sum(flatRead);
-                if (denominator != 0f)
+                if (!values[0].IsOdResult)
                 {
-                    VectorHelper.Divide(flatWrite, flatRead, denominator);
+                    return new ComputationResult("SumRows was executed with a parameter that was not a matrix!");
                 }
-                else if (flatRead == flatWrite)
+                return SumRows(values[0]);
+            case FunctionType.SumColumns:
+                if (values.Length != 1)
                 {
-                    // we only need to accumulate if we are going to return a previously accumulated matrix.
-                    flatWrite.Fill(0f);
+                    return new ComputationResult("SumColumns was executed with the wrong number of parameters!");
                 }
-            });
-            return new ComputationResult(writeTo, true);
+                if (!values[0].IsOdResult)
+                {
+                    return new ComputationResult("SumColumns was executed with a parameter that was not a matrix!");
+                }
+                return SumColumns(values[0]);
+            case FunctionType.AvgRows:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("AvgRows was executed with the wrong number of parameters!");
+                }
+                if (!values[0].IsOdResult)
+                {
+                    return new ComputationResult("AvgRows was executed with a parameter that was not a matrix!");
+                }
+                return AvgRows(values[0]);
+            case FunctionType.AvgColumns:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("AvgColumns was executed with the wrong number of parameters!");
+                }
+                if (!values[0].IsOdResult)
+                {
+                    return new ComputationResult("AvgColumns was executed with a parameter that was not a matrix!");
+                }
+                return AvgColumns(values[0]);
+            case FunctionType.Sum:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("Sum was executed with the wrong number of parameters!");
+                }
+                if (values[0].IsValue)
+                {
+                    return new ComputationResult("Sum was executed with a parameter that was already a scalar value!");
+                }
+                return Sum(values[0]);
+            case FunctionType.Abs:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("Abs was executed with the wrong number of parameters!");
+                }
+                return Abs(values[0]);
+            case FunctionType.Avg:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("Avg was executed with the wrong number of parameters!");
+                }
+                if (values[0].IsValue)
+                {
+                    return new ComputationResult("Avg was executed with a parameter that was already a scalar value!");
+                }
+                return Avg(values[0]);
+            case FunctionType.E:
+                return new ComputationResult((float)Math.E);
+            case FunctionType.Pi:
+                return new ComputationResult((float)Math.PI);
+            case FunctionType.Length:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("Length was executed with the wrong number of parameters!");
+                }
+                if (values[0].IsValue)
+                {
+                    return new ComputationResult("Length can not be applied to a scalar!");
+                }
+                return Length(values[0]);
+            case FunctionType.LengthColumns:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("LengthColumns was executed with the wrong number of parameters!");
+                }
+                if (values[0].IsOdResult)
+                {
+                    return new ComputationResult("LengthColumns must be applied to a Matrix!");
+                }
+                return LengthColumns(values[0]);
+            case FunctionType.LengthRows:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("LengthRows was executed with the wrong number of parameters!");
+                }
+                if (values[0].IsOdResult)
+                {
+                    return new ComputationResult("LengthRows must be applied to a Matrix!");
+                }
+                return LengthRows(values[0]);
+            case FunctionType.ZeroMatrix:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("ZeroMatrix was executed with the wrong number of parameters!");
+                }
+                if (values[0].IsValue)
+                {
+                    return new ComputationResult("ZeroMatrix must be applied to a vector, or a matrix!");
+                }
+                return ZeroMatrix(values);
+            case FunctionType.Matrix:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("Matrix was executed with the wrong number of parameters!");
+                }
+                if (!values[0].IsVectorResult)
+                {
+                    return new ComputationResult("Matrix must be applied to a vector!");
+                }
+                return Matrix(values[0]);
+            case FunctionType.IdentityMatrix:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("IdentityMatrix was executed with the wrong number of parameters!");
+                }
+                if (values[0].IsValue)
+                {
+                    return new ComputationResult("IdentityMatrix must be applied to a vector, or a matrix!");
+                }
+                return IdentityMatrix(values[0]);
+            case FunctionType.Log:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("Log must be executed with one parameter!");
+                }
+                return Log(values);
+            case FunctionType.Sqrt:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("Sqrt must be executed with one parameter!");
+                }
+                return Sqrt(values);
+            case FunctionType.If:
+                if (values.Length != 3)
+                {
+                    return new ComputationResult("If requires at 3 parameters (condition, valueIfTrue, valueIfFalse)!");
+                }
+                return ComputeIf(values);
+            case FunctionType.IfNaN:
+                if (values.Length != 2)
+                {
+                    return new ComputationResult("IfNaN requires 2 parameters (original,replacement)!");
+                }
+                return ComputeIfNaN(values);
+            case FunctionType.Normalize:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("Normalize requires 1 parameter, a matrix to be normalized.");
+                }
+                return ComputeNormalize(values);
+            case FunctionType.NormalizeColumns:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("NormalizeColumns requires 1 parameter, a matrix to be normalized.");
+                }
+                return ComputeNormalizeColumns(values);
+            case FunctionType.NormalizeRows:
+                if (values.Length != 1)
+                {
+                    return new ComputationResult("NormalizeRows requires 1 parameter, a matrix to be normalized.");
+                }
+                return ComputeNormalizeRows(values);
+
         }
+        return new ComputationResult("An undefined function was executed!");
+    }
 
-        private ComputationResult ComputeNormalize(ComputationResult[] values)
+    private ComputationResult ComputeNormalizeColumns(ComputationResult[] values)
+    {
+        var toNormalize = values[0];
+        if (toNormalize.IsValue)
         {
-            var toNormalize = values[0];
-            if (toNormalize.IsValue)
-            {
-                return new ComputationResult($"{Start + 1}:Normalize requires its parameter to be of type Matrix, not a scalar.");
-            }
-            if (toNormalize.IsVectorResult)
+            return new ComputationResult($"{Start + 1}:Normalize requires its parameter to be of type Matrix, not a scalar.");
+        }
+        if (toNormalize.IsVectorResult)
+        {
+            return new ComputationResult($"{Start + 1}:Normalize requires its parameter to be of type Matrix, not a vector.");
+        }
+        var writeTo = toNormalize.Accumulator ? toNormalize.OdData : new Matrix(toNormalize.OdData);
+        var readFrom = toNormalize.OdData;
+        var rowLength = readFrom.RowCategories.Count;
+        // This could be executed in parallel if proved to be more efficient
+        var columnTotals = new float[readFrom.ColumnCategories.Count];
+        var columnSpan = columnTotals.AsSpan();
+        for (int i = 0; i < rowLength; i++)
+        {
+            var readRow = readFrom.GetRow(i);
+            VectorHelper.Add(columnSpan, 0, columnSpan, 0, readRow, 0, readRow.Length);
+        }
+        System.Threading.Tasks.Parallel.For(0, rowLength, (int i) =>
+        {
+            var writeRow = writeTo.GetRow(i);
+            var readRow = readFrom.GetRow(i);
+            for (int j = 0; j < writeRow.Length; j++)
             {
-                return new ComputationResult($"{Start + 1}:Normalize requires its parameter to be of type Matrix, not a vector.");
+                writeRow[j] = columnTotals[j] != 0f ? readRow[j] / columnTotals[j] : 0f;
             }
-            var writeTo = toNormalize.Accumulator ? toNormalize.OdData : new Matrix(toNormalize.OdData);
-            var flatWrite = writeTo.Data;
-            var flatRead = toNormalize.OdData.Data;
-            // sum the whole matrix in parallel using SIMD for each array
+        });
+        return new ComputationResult(writeTo, true);
+    }
+
+    private ComputationResult ComputeNormalizeRows(ComputationResult[] values)
+    {
+        var toNormalize = values[0];
+        if (toNormalize.IsValue)
+        {
+            return new ComputationResult($"{Start + 1}:Normalize requires its parameter to be of type Matrix, not a scalar.");
+        }
+        if (toNormalize.IsVectorResult)
+        {
+            return new ComputationResult($"{Start + 1}:Normalize requires its parameter to be of type Matrix, not a vector.");
+        }
+        var rowLength = toNormalize.OdData.RowCategories.Count;
+        var writeTo = toNormalize.Accumulator ? toNormalize.OdData : new Matrix(toNormalize.OdData);
+        var readFrom = toNormalize.OdData;
+        System.Threading.Tasks.Parallel.For(0, rowLength, (int i) =>
+        {
+            var flatWrite = writeTo.GetRow(i);
+            var flatRead = readFrom.GetRow(i);
             var denominator = VectorHelper.Sum(flatRead);
-            if (denominator == 0f)
+            if (denominator != 0f)
             {
-                // only clear the write array if it was an accumulator
-                if (flatRead == flatWrite)
-                {
-                    flatWrite.Clear();
-                }
+                VectorHelper.Divide(flatWrite, flatRead, denominator);
             }
-            else
+            else if (flatRead == flatWrite)
             {
-                VectorHelper.Divide(flatWrite, flatRead, denominator);
+                // we only need to accumulate if we are going to return a previously accumulated matrix.
+                flatWrite.Fill(0f);
             }
-            return new ComputationResult(writeTo, true);
-        }
+        });
+        return new ComputationResult(writeTo, true);
+    }
 
-        private ComputationResult ComputeIfNaN(ComputationResult[] values)
+    private ComputationResult ComputeNormalize(ComputationResult[] values)
+    {
+        var toNormalize = values[0];
+        if (toNormalize.IsValue)
         {
-            var condition = values[0];
-            var replacement = values[1];
-            // both must be the same size
-            if (condition.IsValue && replacement.IsValue)
-            {
-                return new ComputationResult(!float.IsNaN(condition.LiteralValue) ? condition.LiteralValue : replacement.LiteralValue);
-            }
-            else if (condition.IsVectorResult && replacement.IsVectorResult)
-            {
-                var saveTo = values[0].Accumulator ? values[0].VectorData : new Vector(values[0].VectorData);
-                VectorHelper.ReplaceIfNaN(saveTo.Data, condition.VectorData.Data, replacement.VectorData.Data);
-                return new ComputationResult(saveTo, true, condition.Direction);
-            }
-            else if (condition.IsOdResult && replacement.IsOdResult)
+            return new ComputationResult($"{Start + 1}:Normalize requires its parameter to be of type Matrix, not a scalar.");
+        }
+        if (toNormalize.IsVectorResult)
+        {
+            return new ComputationResult($"{Start + 1}:Normalize requires its parameter to be of type Matrix, not a vector.");
+        }
+        var writeTo = toNormalize.Accumulator ? toNormalize.OdData : new Matrix(toNormalize.OdData);
+        var flatWrite = writeTo.Data;
+        var flatRead = toNormalize.OdData.Data;
+        // sum the whole matrix in parallel using SIMD for each array
+        var denominator = VectorHelper.Sum(flatRead);
+        if (denominator == 0f)
+        {
+            // only clear the write array if it was an accumulator
+            if (flatRead == flatWrite)
             {
-                var saveTo = values[0].Accumulator ? values[0].OdData : new Matrix(values[0].OdData);
-                int rows = values[0].OdData.RowCategories.Count;
-                var flatSave = saveTo.Data;
-                var flatCond = condition.OdData.Data;
-                var flatRep = replacement.OdData.Data;
-                VectorHelper.ReplaceIfNaN(flatSave, flatCond, flatRep);
-                return new ComputationResult(saveTo, true);
+                flatWrite.Clear();
             }
-            return new ComputationResult($"{Start + 1}:The Condition and Replacement case of an IfNaN expression must be of the same dimensionality.");
         }
+        else
+        {
+            VectorHelper.Divide(flatWrite, flatRead, denominator);
+        }
+        return new ComputationResult(writeTo, true);
+    }
 
-        private ComputationResult ComputeIf(ComputationResult[] values)
+    private ComputationResult ComputeIfNaN(ComputationResult[] values)
+    {
+        var condition = values[0];
+        var replacement = values[1];
+        // both must be the same size
+        if (condition.IsValue && replacement.IsValue)
         {
-            var condition = values[0];
-            var ifTrue = values[1];
-            var ifFalse = values[2];
-            if ((ifTrue.IsValue & !ifFalse.IsValue)
-                || (ifTrue.IsVectorResult & !ifFalse.IsVectorResult)
-                || (ifTrue.IsOdResult & !ifFalse.IsOdResult))
-            {
-                return new ComputationResult($"{Start + 1}:The True and False case of an if expression must be of the same dimensionality.");
-            }
-            if (condition.IsValue)
+            return new ComputationResult(!float.IsNaN(condition.LiteralValue) ? condition.LiteralValue : replacement.LiteralValue);
+        }
+        else if (condition.IsVectorResult && replacement.IsVectorResult)
+        {
+            var saveTo = values[0].Accumulator ? values[0].VectorData : new Vector(values[0].VectorData);
+            VectorHelper.ReplaceIfNaN(saveTo.Data, condition.VectorData.Data, replacement.VectorData.Data);
+            return new ComputationResult(saveTo, true, condition.Direction);
+        }
+        else if (condition.IsOdResult && replacement.IsOdResult)
+        {
+            var saveTo = values[0].Accumulator ? values[0].OdData : new Matrix(values[0].OdData);
+            int rows = values[0].OdData.RowCategories.Count;
+            var flatSave = saveTo.Data;
+            var flatCond = condition.OdData.Data;
+            var flatRep = replacement.OdData.Data;
+            VectorHelper.ReplaceIfNaN(flatSave, flatCond, flatRep);
+            return new ComputationResult(saveTo, true);
+        }
+        return new ComputationResult($"{Start + 1}:The Condition and Replacement case of an IfNaN expression must be of the same dimensionality.");
+    }
+
+    private ComputationResult ComputeIf(ComputationResult[] values)
+    {
+        var condition = values[0];
+        var ifTrue = values[1];
+        var ifFalse = values[2];
+        if ((ifTrue.IsValue & !ifFalse.IsValue)
+            || (ifTrue.IsVectorResult & !ifFalse.IsVectorResult)
+            || (ifTrue.IsOdResult & !ifFalse.IsOdResult))
+        {
+            return new ComputationResult($"{Start + 1}:The True and False case of an if expression must be of the same dimensionality.");
+        }
+        if (condition.IsValue)
+        {
+            // in all cases we can just move the result to the next level
+            return condition.LiteralValue > 0f ? ifTrue : ifFalse;
+        }
+        else if (condition.IsVectorResult)
+        {
+            if (ifTrue.IsValue)
             {
-                // in all cases we can just move the result to the next level
-                return condition.LiteralValue > 0f ? ifTrue : ifFalse;
+                var saveTo = values[0].Accumulator ? values[0].VectorData : new Vector(values[0].VectorData);
+                var result = saveTo.Data;
+                var cond = condition.VectorData.Data;
+                var t = ifTrue.LiteralValue;
+                var f = ifFalse.LiteralValue;
+                for (int i = 0; i < result.Length; i++)
+                {
+                    result[i] = cond[i] > 0f ? t : f;
+                }
+                return new ComputationResult(saveTo, true, condition.Direction);
             }
-            else if (condition.IsVectorResult)
+            else if (ifTrue.IsVectorResult)
             {
-                if (ifTrue.IsValue)
-                {
-                    var saveTo = values[0].Accumulator ? values[0].VectorData : new Vector(values[0].VectorData);
-                    var result = saveTo.Data;
-                    var cond = condition.VectorData.Data;
-                    var t = ifTrue.LiteralValue;
-                    var f = ifFalse.LiteralValue;
-                    for (int i = 0; i < result.Length; i++)
-                    {
-                        result[i] = cond[i] > 0f ? t : f;
-                    }
-                    return new ComputationResult(saveTo, true, condition.Direction);
-                }
-                else if (ifTrue.IsVectorResult)
+                var saveTo = values[0].Accumulator ? values[0].VectorData : new Vector(values[0].VectorData);
+                var result = saveTo.Data;
+                var cond = condition.VectorData.Data;
+                var t = ifTrue.VectorData.Data;
+                var f = ifFalse.VectorData.Data;
+                for (int i = 0; i < result.Length; i++)
                 {
-                    var saveTo = values[0].Accumulator ? values[0].VectorData : new Vector(values[0].VectorData);
-                    var result = saveTo.Data;
-                    var cond = condition.VectorData.Data;
-                    var t = ifTrue.VectorData.Data;
-                    var f = ifFalse.VectorData.Data;
-                    for (int i = 0; i < result.Length; i++)
-                    {
-                        result[i] = cond[i] > 0f ? t[i] : f[i];
-                    }
-                    return new ComputationResult(saveTo, true, condition.Direction);
+                    result[i] = cond[i] > 0f ? t[i] : f[i];
                 }
-                else
+                return new ComputationResult(saveTo, true, condition.Direction);
+            }
+            else
+            {
+                switch (condition.Direction)
                 {
-                    switch (condition.Direction)
-                    {
-                        case ComputationResult.VectorDirection.Unassigned:
-                            return new ComputationResult($"{Start + 1}:The directionality of the condition vector is required when working with a matrix values.");
-                        case ComputationResult.VectorDirection.Vertical:
+                    case ComputationResult.VectorDirection.Unassigned:
+                        return new ComputationResult($"{Start + 1}:The directionality of the condition vector is required when working with a matrix values.");
+                    case ComputationResult.VectorDirection.Vertical:
+                        {
+                            var saveTo = values[1].Accumulator ? values[1].OdData : new Matrix(values[1].OdData);
+                            var result = saveTo.Data;
+                            var cond = condition.VectorData.Data;
+                            var t = ifTrue.OdData.Data;
+                            var f = ifFalse.OdData.Data;
+                            for (int i = 0; i < cond.Length; i++)
                             {
-                                var saveTo = values[1].Accumulator ? values[1].OdData : new Matrix(values[1].OdData);
-                                var result = saveTo.Data;
-                                var cond = condition.VectorData.Data;
-                                var t = ifTrue.OdData.Data;
-                                var f = ifFalse.OdData.Data;
-                                for (int i = 0; i < cond.Length; i++)
-                                {
-                                    var toAssign = cond[i] > 0 ? t : f;
-                                    var rowOffset = i * cond.Length;
-                                    toAssign.Slice(rowOffset, cond.Length).CopyTo(result.Slice(rowOffset, cond.Length));
-                                }
-                                return new ComputationResult(saveTo, true);
+                                var toAssign = cond[i] > 0 ? t : f;
+                                var rowOffset = i * cond.Length;
+                                toAssign.Slice(rowOffset, cond.Length).CopyTo(result.Slice(rowOffset, cond.Length));
                             }
-                        case ComputationResult.VectorDirection.Horizontal:
+                            return new ComputationResult(saveTo, true);
+                        }
+                    case ComputationResult.VectorDirection.Horizontal:
+                        {
+                            var saveTo = values[1].Accumulator ? values[1].OdData : new Matrix(values[1].OdData);
+                            var result = saveTo.Data;
+                            var cond = condition.VectorData.Data;
+                            var t = ifTrue.OdData.Data;
+                            var f = ifFalse.OdData.Data;
+                            for (int i = 0; i < cond.Length; i++)
                             {
-                                var saveTo = values[1].Accumulator ? values[1].OdData : new Matrix(values[1].OdData);
-                                var result = saveTo.Data;
-                                var cond = condition.VectorData.Data;
-                                var t = ifTrue.OdData.Data;
-                                var f = ifFalse.OdData.Data;
-                                for (int i = 0; i < cond.Length; i++)
+                                int rowOffset = i * cond.Length;
+                                for (int j = 0; j < cond.Length; j++)
                                 {
-                                    int rowOffset = i * cond.Length;
-                                    for (int j = 0; j < cond.Length; j++)
-                                    {
-                                        result[rowOffset + j] = cond[j] > 0 ? t[rowOffset + j] : f[rowOffset + j];
-                                    }
+                                    result[rowOffset + j] = cond[j] > 0 ? t[rowOffset + j] : f[rowOffset + j];
                                 }
-                                return new ComputationResult(saveTo, true);
                             }
-                    }
+                            return new ComputationResult(saveTo, true);
+                        }
                 }
             }
-            if (condition.IsOdResult)
-            {
-                if (!ifTrue.IsOdResult)
-                {
-                    return new ComputationResult($"{Start + 1}:The True and False cases must be a Matrix when the condition is a matrix.");
-                }
-                var saveTo = values[0].Accumulator ? values[0].OdData : new Matrix(values[0].OdData);
-                // this will never have a remainder
-                System.Threading.Tasks.Parallel.For(0, condition.OdData.NumberOfRows, (int row) =>
-                {
-                    var cond = condition.OdData.Data;
-                    var tr = ifTrue.OdData.Data;
-                    var fa = ifFalse.OdData.Data;
-                    var sa = saveTo.Data;
-                    var columnSize = condition.OdData.NumberOfColumns;
-                    var start = columnSize * row;
-                    var end = columnSize * (row + 1);
-                    for (int i = start; i < end; i++)
-                    {
-                        sa[i] = cond[i] > 0f ? tr[i] : fa[i];
-                    }
-                });
+        }
+        if (condition.IsOdResult)
+        {
+            if (!ifTrue.IsOdResult)
+            {
+                return new ComputationResult($"{Start + 1}:The True and False cases must be a Matrix when the condition is a matrix.");
+            }
+            var saveTo = values[0].Accumulator ? values[0].OdData : new Matrix(values[0].OdData);
+            // this will never have a remainder
+            System.Threading.Tasks.Parallel.For(0, condition.OdData.NumberOfRows, (int row) =>
+            {
+                var cond = condition.OdData.Data;
+                var tr = ifTrue.OdData.Data;
+                var fa = ifFalse.OdData.Data;
+                var sa = saveTo.Data;
+                var columnSize = condition.OdData.NumberOfColumns;
+                var start = columnSize * row;
+                var end = columnSize * (row + 1);
+                for (int i = start; i < end; i++)
+                {
+                    sa[i] = cond[i] > 0f ? tr[i] : fa[i];
+                }
+            });
 
-                return new ComputationResult(saveTo, true);
-            }
-            return new ComputationResult($"{Start + 1}:This combination of parameter types has not been implemented for if!");
+            return new ComputationResult(saveTo, true);
         }
+        return new ComputationResult($"{Start + 1}:This combination of parameter types has not been implemented for if!");
+    }
 
-        private ComputationResult Log(ComputationResult[] values)
+    private ComputationResult Log(ComputationResult[] values)
+    {
+        if (values[0].IsValue)
         {
-            if (values[0].IsValue)
-            {
-                return new ComputationResult((float)Math.Log(values[0].LiteralValue));
-            }
-            else if (values[0].IsVectorResult)
-            {
-                var saveTo = values[0].Accumulator ? values[0].VectorData : new Vector(values[0].VectorData);
-                var flat = saveTo.Data;
-                var source = values[0].VectorData.Data;
-                VectorHelper.Log(flat, source);
-                return new ComputationResult(saveTo, true);
-            }
-            else
-            {
-                var saveTo = values[0].Accumulator ? values[0].OdData : new Matrix(values[0].OdData);
-                var flat = saveTo.Data;
-                var source = values[0].OdData.Data;
-                VectorHelper.Log(flat, source);
-                return new ComputationResult(saveTo, true);
-            }
+            return new ComputationResult((float)Math.Log(values[0].LiteralValue));
         }
+        else if (values[0].IsVectorResult)
+        {
+            var saveTo = values[0].Accumulator ? values[0].VectorData : new Vector(values[0].VectorData);
+            var flat = saveTo.Data;
+            var source = values[0].VectorData.Data;
+            VectorHelper.Log(flat, source);
+            return new ComputationResult(saveTo, true);
+        }
+        else
+        {
+            var saveTo = values[0].Accumulator ? values[0].OdData : new Matrix(values[0].OdData);
+            var flat = saveTo.Data;
+            var source = values[0].OdData.Data;
+            VectorHelper.Log(flat, source);
+            return new ComputationResult(saveTo, true);
+        }
+    }
 
-        private ComputationResult Sqrt(ComputationResult[] values)
+    private ComputationResult Sqrt(ComputationResult[] values)
+    {
+        if (values[0].IsValue)
         {
-            if (values[0].IsValue)
-            {
-                return new ComputationResult((float)Math.Sqrt(values[0].LiteralValue));
-            }
-            else if (values[0].IsVectorResult)
-            {
-                var saveTo = values[0].Accumulator ? values[0].VectorData : new Vector(values[0].VectorData);
-                var source = values[0].VectorData.Data;
-                var flat = saveTo.Data;
-                // x^0.5 is sqrt
-                VectorHelper.Pow(flat, source, 0.5f);
-                return new ComputationResult(saveTo, true);
-            }
-            else
-            {
-                var saveTo = values[0].Accumulator ? values[0].OdData : new Matrix(values[0].OdData);
-                var source = values[0].OdData.Data;
-                var flat = saveTo.Data;
-                // x^0.5 is sqrt
-                VectorHelper.Pow(flat, source, 0.5f);
-                return new ComputationResult(saveTo, true);
-            }
+            return new ComputationResult((float)Math.Sqrt(values[0].LiteralValue));
+        }
+        else if (values[0].IsVectorResult)
+        {
+            var saveTo = values[0].Accumulator ? values[0].VectorData : new Vector(values[0].VectorData);
+            var source = values[0].VectorData.Data;
+            var flat = saveTo.Data;
+            // x^0.5 is sqrt
+            VectorHelper.Pow(flat, source, 0.5f);
+            return new ComputationResult(saveTo, true);
         }
+        else
+        {
+            var saveTo = values[0].Accumulator ? values[0].OdData : new Matrix(values[0].OdData);
+            var source = values[0].OdData.Data;
+            var flat = saveTo.Data;
+            // x^0.5 is sqrt
+            VectorHelper.Pow(flat, source, 0.5f);
+            return new ComputationResult(saveTo, true);
+        }
+    }
 
-        private ComputationResult IdentityMatrix(ComputationResult computationResult)
+    private ComputationResult IdentityMatrix(ComputationResult computationResult)
+    {
+        Matrix ret;
+        if (computationResult.IsVectorResult)
         {
-            Matrix ret;
-            if (computationResult.IsVectorResult)
-            {
-                var vector = computationResult.VectorData;
-                ret = new Matrix(vector);
-            }
-            else
-            {
-                var matrix = computationResult.OdData;
-                ret = new Matrix(matrix);
-            }
-            var step = ret.RowCategories.Count + 1;
-            var flatRet = ret.Data;
-            for (int i = 0; i < flatRet.Length; i += step)
-            {
-                flatRet[i] = 1.0f;
-            }
-            return new ComputationResult(ret, true);
+            var vector = computationResult.VectorData;
+            ret = new Matrix(vector);
+        }
+        else
+        {
+            var matrix = computationResult.OdData;
+            ret = new Matrix(matrix);
         }
+        var step = ret.RowCategories.Count + 1;
+        var flatRet = ret.Data;
+        for (int i = 0; i < flatRet.Length; i += step)
+        {
+            flatRet[i] = 1.0f;
+        }
+        return new ComputationResult(ret, true);
+    }
 
-        private ComputationResult Matrix(ComputationResult computationResult)
+    private ComputationResult Matrix(ComputationResult computationResult)
+    {
+        var vectorData = computationResult.VectorData;
+        var newMatrix = new Matrix(vectorData);
+        var rowSize = newMatrix.RowCategories.Count;
+        var flatVector = vectorData.Data;
+        var flatMatrix = newMatrix.Data;
+        switch (computationResult.Direction)
         {
-            var vectorData = computationResult.VectorData;
-            var newMatrix = new Matrix(vectorData);
-            var rowSize = newMatrix.RowCategories.Count;
-            var flatVector = vectorData.Data;
-            var flatMatrix = newMatrix.Data;
-            switch (computationResult.Direction)
-            {
-                case ComputationResult.VectorDirection.Unassigned:
-                    return new ComputationResult("Matrix was executed with an unassigned orientation vector!");
-                case ComputationResult.VectorDirection.Vertical:
-                    // each row is the single value
-                    for (int i = 0; i < flatVector.Length; i++)
-                    {
-                        VectorHelper.Set(flatMatrix.Slice(i * rowSize, rowSize), flatVector[i]);
-                    }
-                    break;
-                case ComputationResult.VectorDirection.Horizontal:
-                    // each column is the single value
-                    for (int i = 0; i < newMatrix.NumberOfRows; i++)
-                    {
-                        flatVector.CopyTo(newMatrix.GetRow(i));
-                    }
-                    break;
-            }
-            return new ComputationResult(newMatrix, true);
+            case ComputationResult.VectorDirection.Unassigned:
+                return new ComputationResult("Matrix was executed with an unassigned orientation vector!");
+            case ComputationResult.VectorDirection.Vertical:
+                // each row is the single value
+                for (int i = 0; i < flatVector.Length; i++)
+                {
+                    VectorHelper.Set(flatMatrix.Slice(i * rowSize, rowSize), flatVector[i]);
+                }
+                break;
+            case ComputationResult.VectorDirection.Horizontal:
+                // each column is the single value
+                for (int i = 0; i < newMatrix.NumberOfRows; i++)
+                {
+                    flatVector.CopyTo(newMatrix.GetRow(i));
+                }
+                break;
         }
+        return new ComputationResult(newMatrix, true);
+    }
 
-        private ComputationResult ZeroMatrix(ComputationResult[] values)
+    private ComputationResult ZeroMatrix(ComputationResult[] values)
+    {
+        if (values[0].VectorData != null)
         {
-            if (values[0].VectorData != null)
-            {
-                return new ComputationResult(new Matrix(values[0].VectorData), true);
-            }
-            else
-            {
-                return new ComputationResult(new Matrix(values[0].OdData), true);
-            }
+            return new ComputationResult(new Matrix(values[0].VectorData), true);
+        }
+        else
+        {
+            return new ComputationResult(new Matrix(values[0].OdData), true);
         }
+    }
 
-        private ComputationResult Avg(ComputationResult computationResult)
+    private ComputationResult Avg(ComputationResult computationResult)
+    {
+        if (computationResult.IsVectorResult)
         {
-            if (computationResult.IsVectorResult)
-            {
-                var flat = computationResult.VectorData.Data;
-                return new ComputationResult(VectorHelper.Sum(flat) / flat.Length);
-            }
-            else
-            {
-                var flat = computationResult.OdData.Data;
-                return new ComputationResult(VectorHelper.Sum(flat) / flat.Length);
-            }
+            var flat = computationResult.VectorData.Data;
+            return new ComputationResult(VectorHelper.Sum(flat) / flat.Length);
         }
+        else
+        {
+            var flat = computationResult.OdData.Data;
+            return new ComputationResult(VectorHelper.Sum(flat) / flat.Length);
+        }
+    }
 
-        private ComputationResult Abs(ComputationResult computationResult)
+    private ComputationResult Abs(ComputationResult computationResult)
+    {
+        if (computationResult.IsValue)
         {
-            if (computationResult.IsValue)
-            {
-                return new ComputationResult(Math.Abs(computationResult.LiteralValue));
-            }
-            else if (computationResult.IsVectorResult)
-            {
-                var retVector = computationResult.Accumulator ? computationResult.VectorData : new Vector(computationResult.VectorData);
-                var flat = retVector.Data;
-                VectorHelper.Abs(flat, computationResult.VectorData.Data);
-                return new ComputationResult(retVector, true);
-            }
-            else
-            {
-                var retMatrix = computationResult.Accumulator ? computationResult.OdData : new Matrix(computationResult.OdData);
-                var flat = retMatrix.Data;
-                VectorHelper.Abs(flat, computationResult.OdData.Data);
-                return new ComputationResult(retMatrix, true);
-            }
+            return new ComputationResult(Math.Abs(computationResult.LiteralValue));
+        }
+        else if (computationResult.IsVectorResult)
+        {
+            var retVector = computationResult.Accumulator ? computationResult.VectorData : new Vector(computationResult.VectorData);
+            var flat = retVector.Data;
+            VectorHelper.Abs(flat, computationResult.VectorData.Data);
+            return new ComputationResult(retVector, true);
+        }
+        else
+        {
+            var retMatrix = computationResult.Accumulator ? computationResult.OdData : new Matrix(computationResult.OdData);
+            var flat = retMatrix.Data;
+            VectorHelper.Abs(flat, computationResult.OdData.Data);
+            return new ComputationResult(retMatrix, true);
         }
+    }
 
-        private ComputationResult Sum(ComputationResult computationResult)
+    private ComputationResult Sum(ComputationResult computationResult)
+    {
+        if (computationResult.IsVectorResult)
         {
-            if (computationResult.IsVectorResult)
-            {
-                return new ComputationResult(VectorHelper.Sum(computationResult.VectorData.Data));
-            }
-            else if (computationResult.IsOdResult)
-            {
-                var data = computationResult.OdData.Data;
-                var total = VectorHelper.Sum(data);
-                return new ComputationResult(total);
-            }
-            return new ComputationResult("Unknown data type to sum!");
+            return new ComputationResult(VectorHelper.Sum(computationResult.VectorData.Data));
+        }
+        else if (computationResult.IsOdResult)
+        {
+            var data = computationResult.OdData.Data;
+            var total = VectorHelper.Sum(data);
+            return new ComputationResult(total);
         }
+        return new ComputationResult("Unknown data type to sum!");
+    }
 
-        private ComputationResult TransposeOd(ComputationResult computationResult)
+    private ComputationResult TransposeOd(ComputationResult computationResult)
+    {
+        var ret = computationResult.Accumulator ? computationResult.OdData : new Matrix(computationResult.OdData);
+        var flatRet = ret.Data;
+        var flatOrigin = computationResult.OdData.Data;
+        var rowLength = ret.RowCategories.Count;
+        for (int i = 0; i < rowLength; i++)
         {
-            var ret = computationResult.Accumulator ? computationResult.OdData : new Matrix(computationResult.OdData);
-            var flatRet = ret.Data;
-            var flatOrigin = computationResult.OdData.Data;
-            var rowLength = ret.RowCategories.Count;
-            for (int i = 0; i < rowLength; i++)
+            for (int j = i + 1; j < rowLength; j++)
             {
-                for (int j = i + 1; j < rowLength; j++)
-                {
-                    var temp = flatOrigin[i * rowLength + j];
-                    flatRet[i * rowLength + j] = flatOrigin[j * rowLength + i];
-                    flatRet[j * rowLength + i] = temp;
-                }
+                var temp = flatOrigin[i * rowLength + j];
+                flatRet[i * rowLength + j] = flatOrigin[j * rowLength + i];
+                flatRet[j * rowLength + i] = temp;
             }
-            // if this is a new matrix copy the diagonal
-            if (!computationResult.Accumulator)
+        }
+        // if this is a new matrix copy the diagonal
+        if (!computationResult.Accumulator)
+        {
+            for (int i = 0; i < rowLength; i++)
             {
-                for (int i = 0; i < rowLength; i++)
-                {
-                    flatRet[i * rowLength] = flatOrigin[i * rowLength];
-                }
+                flatRet[i * rowLength] = flatOrigin[i * rowLength];
             }
-            return new ComputationResult(ret, true);
         }
+        return new ComputationResult(ret, true);
+    }
 
-        private ComputationResult SumColumns(ComputationResult computationResult)
+    private ComputationResult SumColumns(ComputationResult computationResult)
+    {
+        var ret = new Vector(computationResult.OdData.RowCategories);
+        var flatRet = ret.Data;
+        var flatData = computationResult.OdData.Data;
+        var rowSize = ret.Categories.Count;
+        for (int i = 0; i < flatRet.Length; i++)
         {
-            var ret = new Vector(computationResult.OdData.RowCategories);
-            var flatRet = ret.Data;
-            var flatData = computationResult.OdData.Data;
-            var rowSize = ret.Categories.Count;
-            for (int i = 0; i < flatRet.Length; i++)
-            {
-                VectorHelper.Add(flatRet, 0, flatRet, 0, flatData, i * rowSize, rowSize);
-            }
-            return new ComputationResult(ret, true, ComputationResult.VectorDirection.Horizontal);
+            VectorHelper.Add(flatRet, 0, flatRet, 0, flatData, i * rowSize, rowSize);
         }
+        return new ComputationResult(ret, true, ComputationResult.VectorDirection.Horizontal);
+    }
 
-        private ComputationResult SumRows(ComputationResult computationResult)
+    private ComputationResult SumRows(ComputationResult computationResult)
+    {
+        var ret = new Vector(computationResult.OdData.RowCategories);
+        var flatRet = ret.Data;
+        var flatData = computationResult.OdData;
+        var rowSize = ret.Categories.Count;
+        for (int i = 0; i < flatRet.Length; i++)
         {
-            var ret = new Vector(computationResult.OdData.RowCategories);
-            var flatRet = ret.Data;
-            var flatData = computationResult.OdData;
-            var rowSize = ret.Categories.Count;
-            for (int i = 0; i < flatRet.Length; i++)
-            {
-                flatRet[i] = VectorHelper.Sum(flatData.GetRow(i));
-            }
-            return new ComputationResult(ret, true, ComputationResult.VectorDirection.Vertical);
+            flatRet[i] = VectorHelper.Sum(flatData.GetRow(i));
         }
+        return new ComputationResult(ret, true, ComputationResult.VectorDirection.Vertical);
+    }
 
-        private ComputationResult AvgColumns(ComputationResult computationResult)
+    private ComputationResult AvgColumns(ComputationResult computationResult)
+    {
+        var data = computationResult.OdData;
+        var ret = new Vector(data.RowCategories);
+        var flatRet = ret.Data;
+        var flatData = data.Data;
+        var rowSize = ret.Categories.Count;
+        for (int i = 0; i < flatRet.Length; i++)
         {
-            var data = computationResult.OdData;
-            var ret = new Vector(data.RowCategories);
-            var flatRet = ret.Data;
-            var flatData = data.Data;
-            var rowSize = ret.Categories.Count;
-            for (int i = 0; i < flatRet.Length; i++)
-            {
-                VectorHelper.Add(flatRet, 0, flatRet, 0, flatData, i * rowSize, rowSize);
-            }
-            VectorHelper.Multiply(flatRet, flatRet, 1.0f / flatRet.Length);
-            return new ComputationResult(ret, true, ComputationResult.VectorDirection.Horizontal);
+            VectorHelper.Add(flatRet, 0, flatRet, 0, flatData, i * rowSize, rowSize);
         }
+        VectorHelper.Multiply(flatRet, flatRet, 1.0f / flatRet.Length);
+        return new ComputationResult(ret, true, ComputationResult.VectorDirection.Horizontal);
+    }
 
-        private ComputationResult AvgRows(ComputationResult computationResult)
+    private ComputationResult AvgRows(ComputationResult computationResult)
+    {
+        var data = computationResult.OdData;
+        var ret = new Vector(data.RowCategories);
+        var flatRet = ret.Data;
+        var rowSize = ret.Categories.Count;
+        for (int i = 0; i < flatRet.Length; i++)
         {
-            var data = computationResult.OdData;
-            var ret = new Vector(data.RowCategories);
-            var flatRet = ret.Data;
-            var rowSize = ret.Categories.Count;
-            for (int i = 0; i < flatRet.Length; i++)
-            {
-                flatRet[i] = VectorHelper.Sum(data.GetRow(i));
-            }
-            VectorHelper.Multiply(flatRet, flatRet, 1.0f / flatRet.Length);
-            return new ComputationResult(ret, true, ComputationResult.VectorDirection.Vertical);
+            flatRet[i] = VectorHelper.Sum(data.GetRow(i));
         }
+        VectorHelper.Multiply(flatRet, flatRet, 1.0f / flatRet.Length);
+        return new ComputationResult(ret, true, ComputationResult.VectorDirection.Vertical);
+    }
 
-        private ComputationResult Length(ComputationResult computationResult)
+    private ComputationResult Length(ComputationResult computationResult)
+    {
+        if (computationResult.IsOdResult)
         {
-            if (computationResult.IsOdResult)
-            {
-                return new ComputationResult(computationResult.OdData.Data.Length);
-            }
-            if (computationResult.IsVectorResult)
-            {
-                return new ComputationResult(computationResult.VectorData.Data.Length);
-            }
-            return new ComputationResult("An unknown data type was processed through Length!");
+            return new ComputationResult(computationResult.OdData.Data.Length);
+        }
+        if (computationResult.IsVectorResult)
+        {
+            return new ComputationResult(computationResult.VectorData.Data.Length);
         }
+        return new ComputationResult("An unknown data type was processed through Length!");
+    }
 
-        private ComputationResult LengthRows(ComputationResult computationResult)
+    private ComputationResult LengthRows(ComputationResult computationResult)
+    {
+        if (computationResult.IsOdResult)
         {
-            if (computationResult.IsOdResult)
-            {
-                var data = computationResult.OdData;
-                var ret = new Vector(data.RowCategories);
-                var flatRet = ret.Data;
-                var flatData = data.Data;
-                VectorHelper.Set(flatData, flatRet.Length);
-                return new ComputationResult(ret, true, ComputationResult.VectorDirection.Vertical);
-            }
-            return new ComputationResult("An unknown data type was processed through LengthRows!");
+            var data = computationResult.OdData;
+            var ret = new Vector(data.RowCategories);
+            var flatRet = ret.Data;
+            var flatData = data.Data;
+            VectorHelper.Set(flatData, flatRet.Length);
+            return new ComputationResult(ret, true, ComputationResult.VectorDirection.Vertical);
         }
+        return new ComputationResult("An unknown data type was processed through LengthRows!");
+    }
 
-        private ComputationResult LengthColumns(ComputationResult computationResult)
+    private ComputationResult LengthColumns(ComputationResult computationResult)
+    {
+        if (computationResult.IsOdResult)
         {
-            if (computationResult.IsOdResult)
-            {
-                var data = computationResult.OdData;
-                var ret = new Vector(data.RowCategories);
-                var flatRet = ret.Data;
-                var flatData = data.Data;
-                VectorHelper.Set(flatData, flatRet.Length);
-                return new ComputationResult(ret, true, ComputationResult.VectorDirection.Horizontal);
-            }
-            return new ComputationResult("An unknown data type was processed through LengthColumns!");
+            var data = computationResult.OdData;
+            var ret = new Vector(data.RowCategories);
+            var flatRet = ret.Data;
+            var flatData = data.Data;
+            VectorHelper.Set(flatData, flatRet.Length);
+            return new ComputationResult(ret, true, ComputationResult.VectorDirection.Horizontal);
         }
+        return new ComputationResult("An unknown data type was processed through LengthColumns!");
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/FusedMultiplyAdd.cs b/src/TMG-Framework/Processing/AST/FusedMultiplyAdd.cs
index ecd19e7..335acc3 100644
--- a/src/TMG-Framework/Processing/AST/FusedMultiplyAdd.cs
+++ b/src/TMG-Framework/Processing/AST/FusedMultiplyAdd.cs
@@ -17,436 +17,289 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using XTMF2;
 using TMG.Utilities;
-using System;
-using System.Threading.Tasks;
-using System.Security.Cryptography;
-using System.Diagnostics.CodeAnalysis;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class FusedMultiplyAdd : Expression
 {
-    public sealed class FusedMultiplyAdd : Expression
-    {
 
-        public Expression? MulLhs;
-        public Expression? MulRhs;
-        public Expression? Add;
-        private int AddStart;
+    public Expression? MulLhs;
+    public Expression? MulRhs;
+    public Expression? Add;
+    private int AddStart;
 
-        public FusedMultiplyAdd(int mulStart, int addStart) : base(mulStart)
-        {
-            AddStart = addStart;
-        }
+    public FusedMultiplyAdd(int mulStart, int addStart) : base(mulStart)
+    {
+        AddStart = addStart;
+    }
 
-        public override ComputationResult Evaluate(IModule[] dataSources)
+    public override ComputationResult Evaluate(IModule[] dataSources)
+    {
+        ComputationResult mulLhs = null!;
+        ComputationResult mulRhs = null!;
+        ComputationResult add = null!;
+        if (MulLhs is null || MulRhs is null || Add is null)
         {
-            ComputationResult mulLhs = null!;
-            ComputationResult mulRhs = null!;
-            ComputationResult add = null!;
-            if (MulLhs is null || MulRhs is null || Add is null)
-            {
-                return new ComputationResult("Unable to evaluate FusedMultiplyAdd with null operands starting at position " + Start + "!");
-            }
-            Parallel.Invoke(
-                () => mulLhs = MulLhs.Evaluate(dataSources),
-                () => mulRhs = MulRhs.Evaluate(dataSources),
-                () => add = Add.Evaluate(dataSources));
+            return new ComputationResult("Unable to evaluate FusedMultiplyAdd with null operands starting at position " + Start + "!");
+        }
+        Parallel.Invoke(
+            () => mulLhs = MulLhs.Evaluate(dataSources),
+            () => mulRhs = MulRhs.Evaluate(dataSources),
+            () => add = Add.Evaluate(dataSources));
 
-            // mulLhs = MulLhs.Evaluate(dataSources);
-            // mulRhs = MulRhs.Evaluate(dataSources);
-            // add = Add.Evaluate(dataSources);
+        // mulLhs = MulLhs.Evaluate(dataSources);
+        // mulRhs = MulRhs.Evaluate(dataSources);
+        // add = Add.Evaluate(dataSources);
 
-            if (mulLhs.Error)
-            {
-                return mulLhs;
-            }
-            else if (mulRhs.Error)
-            {
-                return mulRhs;
-            }
-            else if (add.Error)
-            {
-                return add;
-            }
-            if (!ValidateSizes(mulLhs, mulRhs, Start, out var error))
-            {
-                return error;
-            }
-            if (!ValidateSizes(mulRhs, add, AddStart, out var error2))
-            {
-                return error2;
-            }
-            return Evaluate(mulLhs, mulRhs, add);
+        if (mulLhs.Error)
+        {
+            return mulLhs;
+        }
+        else if (mulRhs.Error)
+        {
+            return mulRhs;
+        }
+        else if (add.Error)
+        {
+            return add;
         }
+        if (!ValidateSizes(mulLhs, mulRhs, Start, out var error))
+        {
+            return error;
+        }
+        if (!ValidateSizes(mulRhs, add, AddStart, out var error2))
+        {
+            return error2;
+        }
+        return Evaluate(mulLhs, mulRhs, add);
+    }
 
-        private ComputationResult Evaluate(ComputationResult mulLhs, ComputationResult mulRhs, ComputationResult add)
+    private ComputationResult Evaluate(ComputationResult mulLhs, ComputationResult mulRhs, ComputationResult add)
+    {
+        if (add.IsValue)
         {
-            if (add.IsValue)
-            {
-                return EvaluateAddIsValue(mulLhs, mulRhs, add);
-            }
-            else if (add.IsVectorResult)
-            {
-                return EvaluateAddIsVector(mulLhs, mulRhs, add);
-            }
-            else
-            {
-                return EvaluateAddIsMatrix(mulLhs, mulRhs, add);
-            }
+            return EvaluateAddIsValue(mulLhs, mulRhs, add);
+        }
+        else if (add.IsVectorResult)
+        {
+            return EvaluateAddIsVector(mulLhs, mulRhs, add);
+        }
+        else
+        {
+            return EvaluateAddIsMatrix(mulLhs, mulRhs, add);
         }
+    }
 
-        private ComputationResult EvaluateAddIsValue(ComputationResult lhs, ComputationResult rhs, ComputationResult add)
+    private ComputationResult EvaluateAddIsValue(ComputationResult lhs, ComputationResult rhs, ComputationResult add)
+    {
+        if (add.IsValue && lhs.IsValue && rhs.IsValue)
+        {
+            return new ComputationResult(lhs.LiteralValue * rhs.LiteralValue + add.LiteralValue);
+        }
+        // float / matrix
+        if (lhs.IsValue)
         {
-            if (add.IsValue && lhs.IsValue && rhs.IsValue)
+            if (rhs.IsVectorResult)
             {
-                return new ComputationResult(lhs.LiteralValue * rhs.LiteralValue + add.LiteralValue);
+                var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FusedMultiplyAdd(flat, rhs.VectorData.Data, lhs.LiteralValue, add.LiteralValue);
+                return new ComputationResult(retVector, true);
             }
-            // float / matrix
-            if (lhs.IsValue)
+            else
             {
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FusedMultiplyAdd(flat, rhs.VectorData.Data, lhs.LiteralValue, add.LiteralValue);
-                    return new ComputationResult(retVector, true);
-                }
-                else
+                var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                // inverted lhs, rhs since order does not matter
+                var flatRet = retMatrix.Data;
+                var flatLhs = lhs.LiteralValue;
+                var flatRhs = rhs.OdData.Data;
+                var flatAdd = add.LiteralValue;
+                var rowSize = retMatrix.RowCategories.Count;
+                for (int i = 0; i < rowSize; i++)
                 {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                    // inverted lhs, rhs since order does not matter
-                    var flatRet = retMatrix.Data;
-                    var flatLhs = lhs.LiteralValue;
-                    var flatRhs = rhs.OdData.Data;
-                    var flatAdd = add.LiteralValue;
-                    var rowSize = retMatrix.RowCategories.Count;
-                    for (int i = 0; i < rowSize; i++)
-                    {
-                        VectorHelper.FusedMultiplyAdd(flatRet, flatRhs,
-                            flatLhs, flatAdd);
-                    }
-                    return new ComputationResult(retMatrix, true);
+                    VectorHelper.FusedMultiplyAdd(flatRet, flatRhs,
+                        flatLhs, flatAdd);
                 }
+                return new ComputationResult(retMatrix, true);
             }
-            else if (rhs.IsValue)
+        }
+        else if (rhs.IsValue)
+        {
+            if (lhs.IsVectorResult)
             {
-                if (lhs.IsVectorResult)
-                {
-                    var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.FusedMultiplyAdd(flat, lhs.VectorData.Data, lhs.LiteralValue, add.LiteralValue);
-                    return new ComputationResult(retVector, true);
-                }
-                else
-                {
-                    // matrix / float
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    VectorHelper.FusedMultiplyAdd(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue, add.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
-                }
+                var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.FusedMultiplyAdd(flat, lhs.VectorData.Data, lhs.LiteralValue, add.LiteralValue);
+                return new ComputationResult(retVector, true);
             }
             else
             {
-                if (lhs.IsVectorResult || rhs.IsVectorResult)
-                {
-                    if (lhs.IsVectorResult && rhs.IsVectorResult)
-                    {
-                        var retVector = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FusedMultiplyAdd(retVector.Data, lhs.VectorData.Data, rhs.VectorData.Data, add.LiteralValue);
-                        return new ComputationResult(retVector, true, lhs.Direction);
-                    }
-                    else if (lhs.IsVectorResult)
-                    {
-                        var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                        var flatLhs = lhs.VectorData.Data;
-                        var rowSize = flatLhs.Length;
-                        if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var rhsRow = rhs.OdData.GetRow(i);
-                                VectorHelper.FusedMultiplyAdd(retRow, rhsRow, flatLhs[i], add.LiteralValue);
-                            }
-                        }
-                        else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var rhsRow = rhs.OdData.GetRow(i);
-                                VectorHelper.FusedMultiplyAdd(retRow, rhsRow, flatLhs, add.LiteralValue);
-                            }
-                        }
-                        else
-                        {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
-                        }
-                        return new ComputationResult(retMatrix, true);
-                    }
-                    else
-                    {
-                        var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                        var flatRhs = rhs.VectorData.Data;
-                        var rowSize = flatRhs.Length;
-                        if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var lhsRow = lhs.OdData.GetRow(i);
-                                VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs[i], add.LiteralValue);
-                            }
-                        }
-                        else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var lhsRow = lhs.OdData.GetRow(i);
-                                VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs, add.LiteralValue);
-                            }
-                        }
-                        else
-                        {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
-                        }
-                        return new ComputationResult(retMatrix, true);
-                    }
-                }
-                else
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    var flatAdd = add.LiteralValue;
-                    var rowSize = retMatrix.RowCategories.Count;
-
-                    VectorHelper.FusedMultiplyAdd(retMatrix.Data, lhs.OdData.Data,
-                        rhs.OdData.Data, flatAdd);
-
-                    return new ComputationResult(retMatrix, true);
-                }
+                // matrix / float
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                VectorHelper.FusedMultiplyAdd(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue, add.LiteralValue);
+                return new ComputationResult(retMatrix, true);
             }
         }
-
-        private static void Swap<T>(ref T first, ref T second) where T : class
-        {
-            var temp = first;
-            first = second;
-            second = temp;
-        }
-
-        private ComputationResult EvaluateAddIsVector(ComputationResult lhs, ComputationResult rhs, ComputationResult add)
+        else
         {
-            // Test the simple case of this really just being an add with a constant multiply
-            if (lhs.IsValue && rhs.IsValue)
+            if (lhs.IsVectorResult || rhs.IsVectorResult)
             {
-                var retVector = add.Accumulator ? add.VectorData : new Vector(add.VectorData);
-                VectorHelper.Add(retVector.Data, add.VectorData.Data, lhs.LiteralValue * rhs.LiteralValue);
-                return new ComputationResult(retVector, true, add.Direction);
-            }
-            if (lhs.IsOdResult || rhs.IsOdResult)
-            {
-                if (lhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
+                if (lhs.IsVectorResult && rhs.IsVectorResult)
                 {
-                    return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
+                    var retVector = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+                    VectorHelper.FusedMultiplyAdd(retVector.Data, lhs.VectorData.Data, rhs.VectorData.Data, add.LiteralValue);
+                    return new ComputationResult(retVector, true, lhs.Direction);
                 }
-                if (rhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
+                else if (lhs.IsVectorResult)
                 {
-                    return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulRhs?.Start ?? -1) + "!");
-                }
-                if (add.Direction == ComputationResult.VectorDirection.Unassigned)
-                {
-                    return new ComputationResult("Unable to add vector without directionality starting at position " + (Add?.Start ?? -1) + "!");
-                }
-                // if the lhs is a value just swap the two around
-                if (!lhs.IsOdResult)
-                {
-                    Swap(ref lhs, ref rhs);
-                }
-                //LHS is a matrix
-                if (rhs.IsOdResult)
-                {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData :
-                        (lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData));
-                    var rowSize = add.VectorData.Data.Length;
-                    if (add.Direction == ComputationResult.VectorDirection.Vertical)
+                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                    var flatLhs = lhs.VectorData.Data;
+                    var rowSize = flatLhs.Length;
+                    if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
                         for (int i = 0; i < rowSize; i++)
                         {
                             var retRow = retMatrix.GetRow(i);
-                            var lhsRow = lhs.OdData.GetRow(i);
                             var rhsRow = rhs.OdData.GetRow(i);
-                            VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhsRow, add.VectorData[i]);
+                            VectorHelper.FusedMultiplyAdd(retRow, rhsRow, flatLhs[i], add.LiteralValue);
                         }
                     }
-                    else
+                    else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
                     {
                         for (int i = 0; i < rowSize; i++)
                         {
                             var retRow = retMatrix.GetRow(i);
-                            var lhsRow = lhs.OdData.GetRow(i);
                             var rhsRow = rhs.OdData.GetRow(i);
-                            VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhsRow, add.VectorData.Data);
-                        }
-                    }
-                    return new ComputationResult(retMatrix, true);
-                }
-                else if (rhs.IsVectorResult)
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    var rowSize = add.VectorData.Data.Length;
-                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                    {
-                        if (add.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var lhsRow = lhs.OdData.GetRow(i);
-                                VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data[i], add.VectorData.Data[i]);
-                            }
-                        }
-                        else
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var lhsRow = lhs.OdData.GetRow(i);
-                                VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data[i], add.VectorData.Data);
-                            }
+                            VectorHelper.FusedMultiplyAdd(retRow, rhsRow, flatLhs, add.LiteralValue);
                         }
                     }
                     else
                     {
-                        if (add.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var lhsRow = lhs.OdData.GetRow(i);
-                                VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data, add.VectorData.Data[i]);
-                            }
-                        }
-                        else
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var lhsRow = lhs.OdData.GetRow(i);
-                                VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data, add.VectorData.Data);
-                            }
-                        }
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
                     }
                     return new ComputationResult(retMatrix, true);
                 }
                 else
                 {
-                    //RHS is a scalar
                     var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    var rowSize = add.VectorData.Data.Length;
-                    if (add.Direction == ComputationResult.VectorDirection.Vertical)
+                    var flatRhs = rhs.VectorData.Data;
+                    var rowSize = flatRhs.Length;
+                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
                         for (int i = 0; i < rowSize; i++)
                         {
                             var retRow = retMatrix.GetRow(i);
                             var lhsRow = lhs.OdData.GetRow(i);
-                            VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.LiteralValue, add.VectorData.Data[i]);
+                            VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs[i], add.LiteralValue);
                         }
                     }
-                    else
+                    else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
                     {
                         for (int i = 0; i < rowSize; i++)
                         {
                             var retRow = retMatrix.GetRow(i);
                             var lhsRow = lhs.OdData.GetRow(i);
-                            VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.LiteralValue, add.VectorData.Data);
+                            VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs, add.LiteralValue);
                         }
                     }
+                    else
+                    {
+                        return new ComputationResult("Unable to add vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
+                    }
                     return new ComputationResult(retMatrix, true);
                 }
             }
-            // vector cases
             else
             {
-                // if the lhs is a value just swap the two around
-                if (lhs.IsValue)
-                {
-                    Swap(ref lhs, ref rhs);
-                }
-                // vector * vector + vector
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = add.Accumulator ? add.VectorData :
-                        (rhs.Accumulator ? rhs.VectorData :
-                        (lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData)));
-                    VectorHelper.FusedMultiplyAdd(retVector.Data, lhs.VectorData.Data, rhs.VectorData.Data, add.VectorData.Data);
-                    return new ComputationResult(retVector, true, add.Direction == lhs.Direction && add.Direction == rhs.Direction ? add.Direction : ComputationResult.VectorDirection.Unassigned);
-                }
-                // vector * lit + vector
-                else
-                {
-                    var retVector = add.Accumulator ? add.VectorData :
-                        (lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData));
-                    VectorHelper.FusedMultiplyAdd(retVector.Data, lhs.VectorData.Data, rhs.LiteralValue,
-                        add.VectorData.Data);
-                    return new ComputationResult(retVector, true, add.Direction == lhs.Direction && add.Direction == rhs.Direction ? add.Direction : ComputationResult.VectorDirection.Unassigned);
-                }
+                var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+                var flatAdd = add.LiteralValue;
+                var rowSize = retMatrix.RowCategories.Count;
+
+                VectorHelper.FusedMultiplyAdd(retMatrix.Data, lhs.OdData.Data,
+                    rhs.OdData.Data, flatAdd);
+
+                return new ComputationResult(retMatrix, true);
             }
         }
+    }
 
-        private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, ComputationResult rhs, ComputationResult add)
+    private static void Swap<T>(ref T first, ref T second) where T : class
+    {
+        var temp = first;
+        first = second;
+        second = temp;
+    }
+
+    private ComputationResult EvaluateAddIsVector(ComputationResult lhs, ComputationResult rhs, ComputationResult add)
+    {
+        // Test the simple case of this really just being an add with a constant multiply
+        if (lhs.IsValue && rhs.IsValue)
+        {
+            var retVector = add.Accumulator ? add.VectorData : new Vector(add.VectorData);
+            VectorHelper.Add(retVector.Data, add.VectorData.Data, lhs.LiteralValue * rhs.LiteralValue);
+            return new ComputationResult(retVector, true, add.Direction);
+        }
+        if (lhs.IsOdResult || rhs.IsOdResult)
         {
             if (lhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
             {
                 return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
             }
-            if (rhs.IsVectorResult && rhs.Direction == ComputationResult.VectorDirection.Unassigned)
+            if (rhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
             {
                 return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulRhs?.Start ?? -1) + "!");
             }
-            // Ensure that the LHS is a higher or equal order to the RHS (Matrix > Vector > Scalar)
-            if (!lhs.IsOdResult)
+            if (add.Direction == ComputationResult.VectorDirection.Unassigned)
             {
-                Swap(ref lhs, ref rhs);
+                return new ComputationResult("Unable to add vector without directionality starting at position " + (Add?.Start ?? -1) + "!");
             }
-            if (lhs.IsValue)
+            // if the lhs is a value just swap the two around
+            if (!lhs.IsOdResult)
             {
                 Swap(ref lhs, ref rhs);
             }
-            // LHS is now a higher or equal to the order of RHS
-            if (lhs.IsOdResult)
+            //LHS is a matrix
+            if (rhs.IsOdResult)
             {
-                if (rhs.IsOdResult)
+                var retMatrix = rhs.Accumulator ? rhs.OdData :
+                    (lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData));
+                var rowSize = add.VectorData.Data.Length;
+                if (add.Direction == ComputationResult.VectorDirection.Vertical)
                 {
-                    var retMatrix = add.Accumulator ? add.OdData :
-                        (lhs.Accumulator ? lhs.OdData :
-                        (rhs.Accumulator ? rhs.OdData : new Matrix(add.OdData)));
-                    var flatRet = retMatrix.Data;
-                    var flatLhs = lhs.OdData.Data;
-                    var flatRhs = rhs.OdData.Data;
-                    var flatAdd = add.OdData.Data;
-                    var rowSize = retMatrix.RowCategories.Count;
-                    VectorHelper.FusedMultiplyAdd(flatRet, flatLhs, flatRhs, flatAdd);                   
-                    return new ComputationResult(retMatrix, true);
+                    for (int i = 0; i < rowSize; i++)
+                    {
+                        var retRow = retMatrix.GetRow(i);
+                        var lhsRow = lhs.OdData.GetRow(i);
+                        var rhsRow = rhs.OdData.GetRow(i);
+                        VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhsRow, add.VectorData[i]);
+                    }
                 }
-                else if (rhs.IsVectorResult)
+                else
                 {
-                    var retMatrix = add.Accumulator ? add.OdData :
-                        (lhs.Accumulator ? lhs.OdData : new Matrix(add.OdData));
-                    var flatRet = retMatrix.Data;
-                    var flatLhs = lhs.OdData.Data;
-                    var flatRhs = rhs.VectorData.Data;
-                    var flatAdd = add.OdData.Data;
-                    var rowSize = retMatrix.RowCategories.Count;
-                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                    for (int i = 0; i < rowSize; i++)
+                    {
+                        var retRow = retMatrix.GetRow(i);
+                        var lhsRow = lhs.OdData.GetRow(i);
+                        var rhsRow = rhs.OdData.GetRow(i);
+                        VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhsRow, add.VectorData.Data);
+                    }
+                }
+                return new ComputationResult(retMatrix, true);
+            }
+            else if (rhs.IsVectorResult)
+            {
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                var rowSize = add.VectorData.Data.Length;
+                if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                {
+                    if (add.Direction == ComputationResult.VectorDirection.Vertical)
                     {
                         for (int i = 0; i < rowSize; i++)
                         {
                             var retRow = retMatrix.GetRow(i);
                             var lhsRow = lhs.OdData.GetRow(i);
-                            var addRow = add.OdData.GetRow(i);
-                            VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs[i], addRow);
+                            VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data[i], add.VectorData.Data[i]);
                         }
                     }
                     else
@@ -455,85 +308,227 @@ private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, Computation
                         {
                             var retRow = retMatrix.GetRow(i);
                             var lhsRow = lhs.OdData.GetRow(i);
-                            var addRow = add.OdData.GetRow(i);
-                            VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs, addRow);
+                            VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data[i], add.VectorData.Data);
                         }
                     }
-                    return new ComputationResult(retMatrix, true);
                 }
                 else
                 {
-                    //RHS is scalar
-                    var retMatrix = add.Accumulator ? add.OdData :
-                        (lhs.Accumulator ? lhs.OdData : new Matrix(add.OdData));
-                    VectorHelper.FusedMultiplyAdd(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue, add.OdData.Data);
-                    return new ComputationResult(retMatrix, true);
+                    if (add.Direction == ComputationResult.VectorDirection.Vertical)
+                    {
+                        for (int i = 0; i < rowSize; i++)
+                        {
+                            var retRow = retMatrix.GetRow(i);
+                            var lhsRow = lhs.OdData.GetRow(i);
+                            VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data, add.VectorData.Data[i]);
+                        }
+                    }
+                    else
+                    {
+                        for (int i = 0; i < rowSize; i++)
+                        {
+                            var retRow = retMatrix.GetRow(i);
+                            var lhsRow = lhs.OdData.GetRow(i);
+                            VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.VectorData.Data, add.VectorData.Data);
+                        }
+                    }
                 }
+                return new ComputationResult(retMatrix, true);
             }
-            else if (lhs.IsVectorResult)
+            else
             {
-                var retMatrix = add.Accumulator ? add.OdData : new Matrix(add.OdData);
-                var tempVector = lhs.Accumulator ? lhs.VectorData : (rhs.IsVectorResult && rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                var flatRet = retMatrix.Data;
-                var flatAdd = add.OdData.Data;
-                var rowSize = tempVector.Data.Length;
-                // compute the multiplication separately in this case for better performance (n multiplies instead of n^2)
-                if (rhs.IsVectorResult)
+                //RHS is a scalar
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                var rowSize = add.VectorData.Data.Length;
+                if (add.Direction == ComputationResult.VectorDirection.Vertical)
                 {
-                    if (lhs.Direction != rhs.Direction)
+                    for (int i = 0; i < rowSize; i++)
                     {
-                        // if the directions don't add up then the sum operation would be undefined!
-                        return new ComputationResult("Unable to add vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
+                        var retRow = retMatrix.GetRow(i);
+                        var lhsRow = lhs.OdData.GetRow(i);
+                        VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.LiteralValue, add.VectorData.Data[i]);
                     }
-                    VectorHelper.Multiply(tempVector.Data, lhs.VectorData.Data, rhs.VectorData.Data);
                 }
                 else
                 {
-                    VectorHelper.Multiply(tempVector.Data, lhs.VectorData.Data, rhs.LiteralValue);
+                    for (int i = 0; i < rowSize; i++)
+                    {
+                        var retRow = retMatrix.GetRow(i);
+                        var lhsRow = lhs.OdData.GetRow(i);
+                        VectorHelper.FusedMultiplyAdd(retRow, lhsRow, rhs.LiteralValue, add.VectorData.Data);
+                    }
                 }
-                
-                if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
+                return new ComputationResult(retMatrix, true);
+            }
+        }
+        // vector cases
+        else
+        {
+            // if the lhs is a value just swap the two around
+            if (lhs.IsValue)
+            {
+                Swap(ref lhs, ref rhs);
+            }
+            // vector * vector + vector
+            if (rhs.IsVectorResult)
+            {
+                var retVector = add.Accumulator ? add.VectorData :
+                    (rhs.Accumulator ? rhs.VectorData :
+                    (lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData)));
+                VectorHelper.FusedMultiplyAdd(retVector.Data, lhs.VectorData.Data, rhs.VectorData.Data, add.VectorData.Data);
+                return new ComputationResult(retVector, true, add.Direction == lhs.Direction && add.Direction == rhs.Direction ? add.Direction : ComputationResult.VectorDirection.Unassigned);
+            }
+            // vector * lit + vector
+            else
+            {
+                var retVector = add.Accumulator ? add.VectorData :
+                    (lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData));
+                VectorHelper.FusedMultiplyAdd(retVector.Data, lhs.VectorData.Data, rhs.LiteralValue,
+                    add.VectorData.Data);
+                return new ComputationResult(retVector, true, add.Direction == lhs.Direction && add.Direction == rhs.Direction ? add.Direction : ComputationResult.VectorDirection.Unassigned);
+            }
+        }
+    }
+
+    private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, ComputationResult rhs, ComputationResult add)
+    {
+        if (lhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
+        {
+            return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
+        }
+        if (rhs.IsVectorResult && rhs.Direction == ComputationResult.VectorDirection.Unassigned)
+        {
+            return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulRhs?.Start ?? -1) + "!");
+        }
+        // Ensure that the LHS is a higher or equal order to the RHS (Matrix > Vector > Scalar)
+        if (!lhs.IsOdResult)
+        {
+            Swap(ref lhs, ref rhs);
+        }
+        if (lhs.IsValue)
+        {
+            Swap(ref lhs, ref rhs);
+        }
+        // LHS is now a higher or equal to the order of RHS
+        if (lhs.IsOdResult)
+        {
+            if (rhs.IsOdResult)
+            {
+                var retMatrix = add.Accumulator ? add.OdData :
+                    (lhs.Accumulator ? lhs.OdData :
+                    (rhs.Accumulator ? rhs.OdData : new Matrix(add.OdData)));
+                var flatRet = retMatrix.Data;
+                var flatLhs = lhs.OdData.Data;
+                var flatRhs = rhs.OdData.Data;
+                var flatAdd = add.OdData.Data;
+                var rowSize = retMatrix.RowCategories.Count;
+                VectorHelper.FusedMultiplyAdd(flatRet, flatLhs, flatRhs, flatAdd);
+                return new ComputationResult(retMatrix, true);
+            }
+            else if (rhs.IsVectorResult)
+            {
+                var retMatrix = add.Accumulator ? add.OdData :
+                    (lhs.Accumulator ? lhs.OdData : new Matrix(add.OdData));
+                var flatRet = retMatrix.Data;
+                var flatLhs = lhs.OdData.Data;
+                var flatRhs = rhs.VectorData.Data;
+                var flatAdd = add.OdData.Data;
+                var rowSize = retMatrix.RowCategories.Count;
+                if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
                 {
-                    Parallel.For(0, rowSize, (int i) =>
+                    for (int i = 0; i < rowSize; i++)
                     {
-                        var flatTemp = tempVector.Data;
                         var retRow = retMatrix.GetRow(i);
+                        var lhsRow = lhs.OdData.GetRow(i);
                         var addRow = add.OdData.GetRow(i);
-                        VectorHelper.Add(retRow, addRow, flatTemp[i]);
-                    });
+                        VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs[i], addRow);
+                    }
                 }
                 else
                 {
-                    Parallel.For(0, rowSize, (int i) =>
+                    for (int i = 0; i < rowSize; i++)
                     {
-                        var flatTemp = tempVector.Data;
                         var retRow = retMatrix.GetRow(i);
+                        var lhsRow = lhs.OdData.GetRow(i);
                         var addRow = add.OdData.GetRow(i);
-                        VectorHelper.Add(retRow, flatTemp, addRow);
-                    });
+                        VectorHelper.FusedMultiplyAdd(retRow, lhsRow, flatRhs, addRow);
+                    }
                 }
                 return new ComputationResult(retMatrix, true);
             }
             else
             {
-                // in this case LHS is a scalar, and therefore RHS is also a scalar
-                var retMatrix = add.Accumulator ? add.OdData : new Matrix(add.OdData);
-                VectorHelper.Add(retMatrix.Data, add.OdData.Data, lhs.LiteralValue * rhs.LiteralValue);
+                //RHS is scalar
+                var retMatrix = add.Accumulator ? add.OdData :
+                    (lhs.Accumulator ? lhs.OdData : new Matrix(add.OdData));
+                VectorHelper.FusedMultiplyAdd(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue, add.OdData.Data);
                 return new ComputationResult(retMatrix, true);
             }
         }
-
-        internal override bool OptimizeAst(ref Expression ex, 
-            [NotNullWhen(false)] ref string? error)
+        else if (lhs.IsVectorResult)
         {
-            if (MulLhs is null || MulRhs is null || Add is null)
+            var retMatrix = add.Accumulator ? add.OdData : new Matrix(add.OdData);
+            var tempVector = lhs.Accumulator ? lhs.VectorData : (rhs.IsVectorResult && rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+            var flatRet = retMatrix.Data;
+            var flatAdd = add.OdData.Data;
+            var rowSize = tempVector.Data.Length;
+            // compute the multiplication separately in this case for better performance (n multiplies instead of n^2)
+            if (rhs.IsVectorResult)
+            {
+                if (lhs.Direction != rhs.Direction)
+                {
+                    // if the directions don't add up then the sum operation would be undefined!
+                    return new ComputationResult("Unable to add vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
+                }
+                VectorHelper.Multiply(tempVector.Data, lhs.VectorData.Data, rhs.VectorData.Data);
+            }
+            else
             {
-                error = "Unable to optimize FusedMultiplyAdd with null operands starting at position " + Start + "!";
-                return false;
+                VectorHelper.Multiply(tempVector.Data, lhs.VectorData.Data, rhs.LiteralValue);
             }
-            return !(!MulLhs.OptimizeAst(ref MulLhs, ref error)
-                    || !MulLhs.OptimizeAst(ref MulRhs, ref error)
-                    || !MulLhs.OptimizeAst(ref Add, ref error));
+
+            if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
+            {
+                Parallel.For(0, rowSize, (int i) =>
+                {
+                    var flatTemp = tempVector.Data;
+                    var retRow = retMatrix.GetRow(i);
+                    var addRow = add.OdData.GetRow(i);
+                    VectorHelper.Add(retRow, addRow, flatTemp[i]);
+                });
+            }
+            else
+            {
+                Parallel.For(0, rowSize, (int i) =>
+                {
+                    var flatTemp = tempVector.Data;
+                    var retRow = retMatrix.GetRow(i);
+                    var addRow = add.OdData.GetRow(i);
+                    VectorHelper.Add(retRow, flatTemp, addRow);
+                });
+            }
+            return new ComputationResult(retMatrix, true);
         }
+        else
+        {
+            // in this case LHS is a scalar, and therefore RHS is also a scalar
+            var retMatrix = add.Accumulator ? add.OdData : new Matrix(add.OdData);
+            VectorHelper.Add(retMatrix.Data, add.OdData.Data, lhs.LiteralValue * rhs.LiteralValue);
+            return new ComputationResult(retMatrix, true);
+        }
+    }
+
+    internal override bool OptimizeAst(ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        if (MulLhs is null || MulRhs is null || Add is null)
+        {
+            error = "Unable to optimize FusedMultiplyAdd with null operands starting at position " + Start + "!";
+            return false;
+        }
+        return !(!MulLhs.OptimizeAst(ref MulLhs, ref error)
+                || !MulLhs.OptimizeAst(ref MulRhs, ref error)
+                || !MulLhs.OptimizeAst(ref Add, ref error));
     }
 }
+
diff --git a/src/TMG-Framework/Processing/AST/Multiply.cs b/src/TMG-Framework/Processing/AST/Multiply.cs
index 6da478d..239acb7 100644
--- a/src/TMG-Framework/Processing/AST/Multiply.cs
+++ b/src/TMG-Framework/Processing/AST/Multiply.cs
@@ -17,151 +17,149 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
-using System.Diagnostics.CodeAnalysis;
 using TMG.Utilities;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class Multiply : BinaryExpression
 {
-    public sealed class Multiply : BinaryExpression
+    public Multiply(int start) : base(start)
     {
-        public Multiply(int start) : base(start)
-        {
 
+    }
+
+    internal override bool OptimizeAst(ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        if (!base.OptimizeAst(ref ex, ref error))
+        {
+            return false;
+        }
+        var lhs = Lhs as Literal;
+        var rhs = Rhs as Literal;
+        if (lhs is not null && rhs is not null)
+        {
+            ex = new Literal(Start, lhs.Value * rhs.Value);
         }
+        return true;
+    }
 
-        internal override bool OptimizeAst(ref Expression ex, 
-            [NotNullWhen(false)] ref string? error)
+    public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    {
+        // see if we have two values, in this case we can skip doing the matrix operation
+        if (lhs.IsValue && rhs.IsValue)
+        {
+            return new ComputationResult(lhs.LiteralValue * rhs.LiteralValue);
+        }
+        // float / matrix
+        if (lhs.IsValue)
         {
-            if (!base.OptimizeAst(ref ex, ref error))
+            if (rhs.IsVectorResult)
             {
-                return false;
+                var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.Multiply(flat, rhs.VectorData.Data, lhs.LiteralValue);
+                return new ComputationResult(retVector, true);
             }
-            var lhs = Lhs as Literal;
-            var rhs = Rhs as Literal;
-            if (lhs is not null && rhs is not null)
+            else
             {
-                ex = new Literal(Start, lhs.Value * rhs.Value);
+                var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                VectorHelper.Multiply(retMatrix.Data, rhs.OdData.Data, lhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
             }
-            return true;
         }
-
-        public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+        else if (rhs.IsValue)
         {
-            // see if we have two values, in this case we can skip doing the matrix operation
-            if (lhs.IsValue && rhs.IsValue)
+            if (lhs.IsVectorResult)
             {
-                return new ComputationResult(lhs.LiteralValue * rhs.LiteralValue);
+                var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.Multiply(flat, lhs.VectorData.Data, rhs.LiteralValue);
+                return new ComputationResult(retVector, true);
             }
-            // float / matrix
-            if (lhs.IsValue)
+            else
             {
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.Multiply(flat, rhs.VectorData.Data, lhs.LiteralValue);
-                    return new ComputationResult(retVector, true);
-                }
-                else
-                {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                    VectorHelper.Multiply(retMatrix.Data, rhs.OdData.Data, lhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
-                }
+                // matrix / float
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                VectorHelper.Multiply(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
             }
-            else if (rhs.IsValue)
+        }
+        else
+        {
+            if (lhs.IsVectorResult || rhs.IsVectorResult)
             {
-                if (lhs.IsVectorResult)
+                if (lhs.IsVectorResult && rhs.IsVectorResult)
                 {
-                    var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.Multiply(flat, lhs.VectorData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retVector, true);
+                    var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+                    VectorHelper.Multiply(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
+                    return new ComputationResult(retMatrix, true, lhs.Direction);
                 }
-                else
-                {
-                    // matrix / float
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    VectorHelper.Multiply(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
-                }
-            }
-            else
-            {
-                if (lhs.IsVectorResult || rhs.IsVectorResult)
+                else if (lhs.IsVectorResult)
                 {
-                    if (lhs.IsVectorResult && rhs.IsVectorResult)
-                    {
-                        var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.Multiply(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
-                        return new ComputationResult(retMatrix, true, lhs.Direction);
-                    }
-                    else if (lhs.IsVectorResult)
+                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                    var flatLhs = lhs.VectorData.Data;
+                    if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
-                        var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                        var flatLhs = lhs.VectorData.Data;
-                        if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < flatLhs.Length; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var retRight = rhs.OdData.GetRow(i);
-                                VectorHelper.Multiply(retRow, retRight, flatLhs[i]);
-                            }
-                        }
-                        else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        for (int i = 0; i < flatLhs.Length; i++)
                         {
-                            for (int i = 0; i < flatLhs.Length; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var retRight = rhs.OdData.GetRow(i);
-                                VectorHelper.Multiply(retRow, retRight, flatLhs);
-                            }
+                            var retRow = retMatrix.GetRow(i);
+                            var retRight = rhs.OdData.GetRow(i);
+                            VectorHelper.Multiply(retRow, retRight, flatLhs[i]);
                         }
-                        else
+                    }
+                    else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < flatLhs.Length; i++)
                         {
-                            return new ComputationResult("Unable to multiply vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            var retRow = retMatrix.GetRow(i);
+                            var retRight = rhs.OdData.GetRow(i);
+                            VectorHelper.Multiply(retRow, retRight, flatLhs);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
                     else
                     {
-                        var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                        var flatLhs = lhs.OdData.Data;
-                        var flatRhs = rhs.VectorData.Data;
-                        if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < flatRhs.Length; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var leftRow = lhs.OdData.GetRow(i);
-                                VectorHelper.Multiply(retRow, leftRow, flatRhs[i]);
-                            }
-                        }
-                        else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        return new ComputationResult("Unable to multiply vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
+                    return new ComputationResult(retMatrix, true);
+                }
+                else
+                {
+                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                    var flatLhs = lhs.OdData.Data;
+                    var flatRhs = rhs.VectorData.Data;
+                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                    {
+                        for (int i = 0; i < flatRhs.Length; i++)
                         {
-                            for (int i = 0; i < flatRhs.Length; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var leftRow = lhs.OdData.GetRow(i);
-                                VectorHelper.Multiply(retRow, leftRow, flatRhs);
-                            }
+                            var retRow = retMatrix.GetRow(i);
+                            var leftRow = lhs.OdData.GetRow(i);
+                            VectorHelper.Multiply(retRow, leftRow, flatRhs[i]);
                         }
-                        else
+                    }
+                    else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < flatRhs.Length; i++)
                         {
-                            return new ComputationResult("Unable to multiply vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            var retRow = retMatrix.GetRow(i);
+                            var leftRow = lhs.OdData.GetRow(i);
+                            VectorHelper.Multiply(retRow, leftRow, flatRhs);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
-                }
-                else
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.Multiply(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                    else
+                    {
+                        return new ComputationResult("Unable to multiply vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
                     return new ComputationResult(retMatrix, true);
                 }
             }
+            else
+            {
+                var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+                VectorHelper.Multiply(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
+            }
         }
     }
 }
+
diff --git a/src/TMG-Framework/Processing/AST/Negate.cs b/src/TMG-Framework/Processing/AST/Negate.cs
index 7b38df5..7959783 100644
--- a/src/TMG-Framework/Processing/AST/Negate.cs
+++ b/src/TMG-Framework/Processing/AST/Negate.cs
@@ -16,71 +16,64 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Diagnostics.CodeAnalysis;
+
 using TMG.Utilities;
-using XTMF2;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class Negate : MonoExpression
 {
-    public sealed class Negate : MonoExpression
+    public Negate(int start) : base(start)
+    {
+    }
+
+    internal override bool OptimizeAst(ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
     {
-        public Negate(int start) : base(start)
+        if (InnerExpression is null)
         {
+            error = "Unable to optimize Negate with null operand starting at position " + Start + "!";
+            return false;
         }
 
-        internal override bool OptimizeAst(ref Expression ex, 
-            [NotNullWhen(false)] ref string? error)
+        // Optimize our children first
+        if (!InnerExpression.OptimizeAst(ref InnerExpression, ref error))
         {
-            if (InnerExpression is null)
-            {
-                error = "Unable to optimize Negate with null operand starting at position " + Start + "!";
-                return false;
-            }
-
-            // Optimize our children first
-            if (!InnerExpression.OptimizeAst(ref InnerExpression, ref error))
-            {
-                return false;
-            }
-            // optimize the case that we are a negative literal
-            if (ex is Literal l)
-            {
-                ex = new Literal(Start, -l.Value);
-            }
-            return true;
+            return false;
+        }
+        // optimize the case that we are a negative literal
+        if (ex is Literal l)
+        {
+            ex = new Literal(Start, -l.Value);
         }
+        return true;
+    }
 
-        public override ComputationResult Evaluate(IModule[] dataSources)
+    public override ComputationResult Evaluate(IModule[] dataSources)
+    {
+        if (InnerExpression is null)
         {
-            if (InnerExpression is null)
-            {
-                return new ComputationResult("Unable to evaluate Negate with null operand starting at position " + Start + "!");
-            }
+            return new ComputationResult("Unable to evaluate Negate with null operand starting at position " + Start + "!");
+        }
 
-            var inner = InnerExpression.Evaluate(dataSources);
-            if (inner.IsValue)
-            {
-                return new ComputationResult(-inner.LiteralValue);
-            }
-            else if (inner.IsVectorResult)
-            {
-                var ret = inner.Accumulator ? inner.VectorData : new Vector(inner.VectorData);
-                VectorHelper.Negate(ret.Data, inner.VectorData.Data);
-                return new ComputationResult(ret, true, inner.Direction);
-            }
-            else
-            {
-                var ret = inner.Accumulator ? inner.OdData : new Matrix(inner.OdData);
-                var flatRet = ret.Data;
-                var flatInner = inner.OdData.Data;
-                VectorHelper.Negate(flatRet, flatInner);
-                return new ComputationResult(ret, true);
-            }
+        var inner = InnerExpression.Evaluate(dataSources);
+        if (inner.IsValue)
+        {
+            return new ComputationResult(-inner.LiteralValue);
+        }
+        else if (inner.IsVectorResult)
+        {
+            var ret = inner.Accumulator ? inner.VectorData : new Vector(inner.VectorData);
+            VectorHelper.Negate(ret.Data, inner.VectorData.Data);
+            return new ComputationResult(ret, true, inner.Direction);
+        }
+        else
+        {
+            var ret = inner.Accumulator ? inner.OdData : new Matrix(inner.OdData);
+            var flatRet = ret.Data;
+            var flatInner = inner.OdData.Data;
+            VectorHelper.Negate(flatRet, flatInner);
+            return new ComputationResult(ret, true);
         }
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/Subtract.cs b/src/TMG-Framework/Processing/AST/Subtract.cs
index 5b3328b..85dfa6d 100644
--- a/src/TMG-Framework/Processing/AST/Subtract.cs
+++ b/src/TMG-Framework/Processing/AST/Subtract.cs
@@ -17,152 +17,149 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
-using System.Diagnostics.CodeAnalysis;
 using TMG.Utilities;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class Subtract : BinaryExpression
 {
-    public sealed class Subtract : BinaryExpression
+    public Subtract(int start) : base(start)
     {
-        public Subtract(int start) : base(start)
-        {
 
+    }
+
+    internal override bool OptimizeAst(ref Expression ex,
+        [NotNullWhen(false)] ref string? error)
+    {
+        if (!base.OptimizeAst(ref ex, ref error))
+        {
+            return false;
+        }
+        var lhs = Lhs as Literal;
+        var rhs = Rhs as Literal;
+        if (lhs != null && rhs != null)
+        {
+            ex = new Literal(Start, lhs.Value - rhs.Value);
         }
+        return true;
+    }
 
-        internal override bool OptimizeAst(ref Expression ex, 
-            [NotNullWhen(false)] ref string? error)
+    public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+    {
+        // see if we have two values, in this case we can skip doing the matrix operation
+        if (lhs.IsValue && rhs.IsValue)
+        {
+            return new ComputationResult(lhs.LiteralValue - rhs.LiteralValue);
+        }
+        // float / matrix
+        if (lhs.IsValue)
         {
-            if(!base.OptimizeAst(ref ex, ref error))
+            if (rhs.IsVectorResult)
             {
-                return false;
+                var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.Subtract(flat, lhs.LiteralValue, rhs.VectorData.Data);
+                return new ComputationResult(retVector, true);
             }
-            var lhs = Lhs as Literal;
-            var rhs = Rhs as Literal;
-            if (lhs != null && rhs != null)
+            else
             {
-                ex = new Literal(Start, lhs.Value - rhs.Value);
+                var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                VectorHelper.Subtract(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
             }
-            return true;
         }
-
-        public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs)
+        else if (rhs.IsValue)
         {
-            // see if we have two values, in this case we can skip doing the matrix operation
-            if (lhs.IsValue && rhs.IsValue)
+            if (lhs.IsVectorResult)
             {
-                return new ComputationResult(lhs.LiteralValue - rhs.LiteralValue);
+                var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
+                var flat = retVector.Data;
+                VectorHelper.Subtract(flat, lhs.VectorData.Data, rhs.LiteralValue);
+                return new ComputationResult(retVector, true);
             }
-            // float / matrix
-            if (lhs.IsValue)
+            else
             {
-                if (rhs.IsVectorResult)
-                {
-                    var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.Subtract(flat, lhs.LiteralValue, rhs.VectorData.Data);
-                    return new ComputationResult(retVector, true);
-                }
-                else
-                {
-                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                    VectorHelper.Subtract(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
-                    return new ComputationResult(retMatrix, true);
-                }
+                // matrix / float
+                var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                VectorHelper.Subtract(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
+                return new ComputationResult(retMatrix, true);
             }
-            else if (rhs.IsValue)
+        }
+        else
+        {
+            if (lhs.IsVectorResult || rhs.IsVectorResult)
             {
-                if (lhs.IsVectorResult)
+                if (lhs.IsVectorResult && rhs.IsVectorResult)
                 {
-                    var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
-                    var flat = retVector.Data;
-                    VectorHelper.Subtract(flat, lhs.VectorData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retVector, true);
+                    var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
+                    VectorHelper.Subtract(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
+                    return new ComputationResult(retMatrix, true, lhs.Direction);
                 }
-                else
+                else if (lhs.IsVectorResult)
                 {
-                    // matrix / float
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                    VectorHelper.Subtract(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
-                    return new ComputationResult(retMatrix, true);
-                }
-            }
-            else
-            {
-                if (lhs.IsVectorResult || rhs.IsVectorResult)
-                {
-                    if (lhs.IsVectorResult && rhs.IsVectorResult)
-                    {
-                        var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.Subtract(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
-                        return new ComputationResult(retMatrix, true, lhs.Direction);
-                    }
-                    else if (lhs.IsVectorResult)
+                    var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
+                    var flatLhs = lhs.VectorData.Data;
+                    var rowSize = flatLhs.Length;
+                    if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
                     {
-                        var retMatrix = rhs.Accumulator ? rhs.OdData : new Matrix(rhs.OdData);
-                        var flatLhs = lhs.VectorData.Data;
-                        var rowSize = flatLhs.Length;
-                        if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var rhsRow = rhs.OdData.GetRow(i);
-                                VectorHelper.Subtract(retRow, flatLhs[i], rhsRow);
-                            }
-                        }
-                        else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            for (int i = 0; i < rowSize; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var rhsRow = rhs.OdData.GetRow(i);
-                                VectorHelper.Subtract(retRow, flatLhs, rhsRow);
-                            }
+                            var retRow = retMatrix.GetRow(i);
+                            var rhsRow = rhs.OdData.GetRow(i);
+                            VectorHelper.Subtract(retRow, flatLhs[i], rhsRow);
                         }
-                        else
+                    }
+                    else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < rowSize; i++)
                         {
-                            return new ComputationResult("Unable to subtract vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            var retRow = retMatrix.GetRow(i);
+                            var rhsRow = rhs.OdData.GetRow(i);
+                            VectorHelper.Subtract(retRow, flatLhs, rhsRow);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
                     else
                     {
-                        var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
-                        var flatRhs = rhs.VectorData.Data;
-                        var rowSize = retMatrix.RowCategories.Count;
-                        if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
-                        {
-                            for (int i = 0; i < flatRhs.Length; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var lhsRow = lhs.OdData.GetRow(i);
-                                VectorHelper.Subtract(retRow, lhsRow, flatRhs[i]);
-                            }
-                        }
-                        else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                        return new ComputationResult("Unable to subtract vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
+                    return new ComputationResult(retMatrix, true);
+                }
+                else
+                {
+                    var retMatrix = lhs.Accumulator ? lhs.OdData : new Matrix(lhs.OdData);
+                    var flatRhs = rhs.VectorData.Data;
+                    var rowSize = retMatrix.RowCategories.Count;
+                    if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
+                    {
+                        for (int i = 0; i < flatRhs.Length; i++)
                         {
-                            for (int i = 0; i < flatRhs.Length; i++)
-                            {
-                                var retRow = retMatrix.GetRow(i);
-                                var lhsRow = lhs.OdData.GetRow(i);
-                                VectorHelper.Subtract(retRow, lhsRow, flatRhs);
-                            }
+                            var retRow = retMatrix.GetRow(i);
+                            var lhsRow = lhs.OdData.GetRow(i);
+                            VectorHelper.Subtract(retRow, lhsRow, flatRhs[i]);
                         }
-                        else
+                    }
+                    else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
+                    {
+                        for (int i = 0; i < flatRhs.Length; i++)
                         {
-                            return new ComputationResult("Unable to subtract vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                            var retRow = retMatrix.GetRow(i);
+                            var lhsRow = lhs.OdData.GetRow(i);
+                            VectorHelper.Subtract(retRow, lhsRow, flatRhs);
                         }
-                        return new ComputationResult(retMatrix, true);
                     }
-                }
-                else
-                {
-                    var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.Subtract(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                    else
+                    {
+                        return new ComputationResult("Unable to subtract vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
+                    }
                     return new ComputationResult(retMatrix, true);
                 }
             }
+            else
+            {
+                var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
+                VectorHelper.Subtract(retMatrix.Data, lhs.OdData.Data, rhs.OdData.Data);
+                return new ComputationResult(retMatrix, true);
+            }
         }
     }
 }
diff --git a/src/TMG-Framework/Processing/AST/Variable.cs b/src/TMG-Framework/Processing/AST/Variable.cs
index 75a9ad7..484fe78 100644
--- a/src/TMG-Framework/Processing/AST/Variable.cs
+++ b/src/TMG-Framework/Processing/AST/Variable.cs
@@ -16,44 +16,41 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System.Linq;
-using XTMF2;
 
-namespace TMG.Frameworks.Data.Processing.AST
+namespace TMG.Frameworks.Data.Processing.AST;
+
+public sealed class Variable : Value
 {
-    public sealed class Variable : Value
+    public readonly string Name;
+
+    public Variable(int start, string name) : base(start)
     {
-        public readonly string Name;
+        Name = name;
+    }
 
-        public Variable(int start, string name) : base(start)
+    public override ComputationResult Evaluate(IModule[] dataSources)
+    {
+        var source = dataSources.FirstOrDefault(d => d.Name == Name);
+        if (source == null)
         {
-            Name = name;
+            return new ComputationResult("Unable to find a data source named '" + Name + "'!");
         }
-
-        public override ComputationResult Evaluate(IModule[] dataSources)
+        if (source is IFunction<Matrix> odSource)
+        {
+            return new ComputationResult(odSource.Invoke(), false);
+        }
+        if (source is IFunction<Vector> vectorSource)
+        {
+            return new ComputationResult(vectorSource.Invoke(), false);
+        }
+        if (source is IFunction<float> valueSource)
+        {
+            return new ComputationResult(valueSource.Invoke());
+        }
+        if (source is IFunction<Categories> map)
         {
-            var source = dataSources.FirstOrDefault(d => d.Name == Name);
-            if (source == null)
-            {
-                return new ComputationResult("Unable to find a data source named '" + Name + "'!");
-            }
-            if (source is IFunction<Matrix> odSource)
-            {
-                return new ComputationResult(odSource.Invoke(), false);
-            }
-            if (source is IFunction<Vector> vectorSource)
-            {
-                return new ComputationResult(vectorSource.Invoke(), false);
-            }
-            if (source is IFunction<float> valueSource)
-            {
-                return new ComputationResult(valueSource.Invoke());
-            }
-            if(source is IFunction<Categories> map)
-            {
-                return new ComputationResult(new Vector(map.Invoke()), true, ComputationResult.VectorDirection.Unassigned);
-            }
-            return new ComputationResult("The data source '" + Name + "' was not of a valid resource type!");
+            return new ComputationResult(new Vector(map.Invoke()), true, ComputationResult.VectorDirection.Unassigned);
         }
+        return new ComputationResult("The data source '" + Name + "' was not of a valid resource type!");
     }
 }
diff --git a/src/TMG-Framework/Processing/AppendMatrixValueToCSV.cs b/src/TMG-Framework/Processing/AppendMatrixValueToCSV.cs
index e32a164..70a5fe1 100644
--- a/src/TMG-Framework/Processing/AppendMatrixValueToCSV.cs
+++ b/src/TMG-Framework/Processing/AppendMatrixValueToCSV.cs
@@ -16,77 +16,72 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
+
 using TMG.Utilities;
-using XTMF2;
 
-namespace TMG.Processing
+namespace TMG.Processing;
+
+[Module(
+    Name = "Append Matrix Value To CSV",
+    Description = "Reading in a CSV it will append a new column at the end containing the result of looking up an row and column value from a matrix.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public class AppendMatrixValueToCSV : BaseAction
 {
-    [Module(
-        Name = "Append Matrix Value To CSV",
-        Description = "Reading in a CSV it will append a new column at the end containing the result of looking up an row and column value from a matrix.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public class AppendMatrixValueToCSV : BaseAction
-    {
 
-        [Parameter(Name = "Column Name", DefaultValue = "Value", Description = "The name to use for the column", Index = 0)]
-        public IFunction<string> ColumnName = null!;
+    [Parameter(Name = "Column Name", DefaultValue = "Value", Description = "The name to use for the column", Index = 0)]
+    public IFunction<string> ColumnName = null!;
 
-        [Parameter(Name = "Row Index", DefaultValue = "1", Description = "The 0 indexed column containing the sparse map index for the row.", Index = 1)]
-        public IFunction<int> RowIndex = null!;
+    [Parameter(Name = "Row Index", DefaultValue = "1", Description = "The 0 indexed column containing the sparse map index for the row.", Index = 1)]
+    public IFunction<int> RowIndex = null!;
 
-        [Parameter(Name = "Column Index", DefaultValue = "2", Description = "The 0 indexed column containing the sparse map index for the column.", Index = 2)]
-        public IFunction<int> ColumnIndex = null!;
+    [Parameter(Name = "Column Index", DefaultValue = "2", Description = "The 0 indexed column containing the sparse map index for the column.", Index = 2)]
+    public IFunction<int> ColumnIndex = null!;
 
-        [SubModule(Name = "Matrix", Index = 3, Description = "The matrix to assign.", Required = true)]
-        public IFunction<Matrix> Matrix = null!;
+    [SubModule(Name = "Matrix", Index = 3, Description = "The matrix to assign.", Required = true)]
+    public IFunction<Matrix> Matrix = null!;
 
-        [SubModule(Name = "Input Stream", Index = 4, Description = "The stream contianing the CSV file.", Required = true)]
-        public IFunction<ReadStream> InputStream = null!;
+    [SubModule(Name = "Input Stream", Index = 4, Description = "The stream contianing the CSV file.", Required = true)]
+    public IFunction<ReadStream> InputStream = null!;
 
-        [SubModule(Name = "Output Stream", Index = 5, Description = "The stream to store the results.", Required = true)]
-        public IFunction<WriteStream> OutputStream = null!;
+    [SubModule(Name = "Output Stream", Index = 5, Description = "The stream to store the results.", Required = true)]
+    public IFunction<WriteStream> OutputStream = null!;
 
-        public override void Invoke()
+    public override void Invoke()
+    {
+        var matrix = Matrix!.Invoke();
+        var columnName = ColumnName?.Invoke();
+        // name sure we don't just have a blank header
+        columnName = String.IsNullOrEmpty(columnName) ? "Value" : columnName;
+        using var reader = new CsvReader(InputStream!.Invoke(), false);
+        using var writer = new StreamWriter(OutputStream!.Invoke());
+        int rowIndex = RowIndex!.Invoke();
+        int columnIndex = ColumnIndex!.Invoke();
+        int minimumRowSize = Math.Max(rowIndex, columnIndex) + 1;
+        // Process header
+        var headers = reader.Headers;
+        for (int i = 0; i < headers.Length; i++)
         {
-            var matrix = Matrix!.Invoke();
-            var columnName = ColumnName?.Invoke();
-            // name sure we don't just have a blank header
-            columnName = String.IsNullOrEmpty(columnName) ? "Value" : columnName;
-            using var reader = new CsvReader(InputStream!.Invoke(), false);
-            using var writer = new StreamWriter(OutputStream!.Invoke());
-            int rowIndex = RowIndex!.Invoke();
-            int columnIndex = ColumnIndex!.Invoke();
-            int minimumRowSize = Math.Max(rowIndex, columnIndex) + 1;
-            // Process header
-            var headers = reader.Headers;
-            for (int i = 0; i < headers.Length; i++)
-            {
-                writer.Write(headers[i]);
-                // it is safe to just have a comma after since we are adding a new column
-                writer.Write(',');
-            }
-            writer.Write(columnName);
-            writer.WriteLine();
-            // Process main body
-            while(reader.LoadLine(out var columns))
+            writer.Write(headers[i]);
+            // it is safe to just have a comma after since we are adding a new column
+            writer.Write(',');
+        }
+        writer.Write(columnName);
+        writer.WriteLine();
+        // Process main body
+        while (reader.LoadLine(out var columns))
+        {
+            if (columns >= minimumRowSize)
             {
-                if (columns >= minimumRowSize)
+                // copy all of the old values
+                for (int i = 0; i < columns; i++)
                 {
-                    // copy all of the old values
-                    for (int i = 0; i < columns; i++)
-                    {
-                        reader.Get(out string value, i);
-                        writer.Write(value);
-                        writer.Write(',');
-                    }
-                    reader.Get(out int o, rowIndex);
-                    reader.Get(out int d, columnIndex);
-                    writer.WriteLine(matrix.GetFromSparseIndexes(o, d));
+                    reader.Get(out string value, i);
+                    writer.Write(value);
+                    writer.Write(',');
                 }
+                reader.Get(out int o, rowIndex);
+                reader.Get(out int d, columnIndex);
+                writer.WriteLine(matrix.GetFromSparseIndexes(o, d));
             }
         }
     }
diff --git a/src/TMG-Framework/Processing/Evaluate2DGravityModel.cs b/src/TMG-Framework/Processing/Evaluate2DGravityModel.cs
index de3fb24..8bf2d83 100644
--- a/src/TMG-Framework/Processing/Evaluate2DGravityModel.cs
+++ b/src/TMG-Framework/Processing/Evaluate2DGravityModel.cs
@@ -16,115 +16,110 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
+
 using TMG.Utilities;
-using XTMF2;
 
-namespace TMG.Processing
+namespace TMG.Processing;
+
+[Module(Name = "Evaluate 2D Gravity Model", Description = "Evaluate the result of the 2D Gravity model.",
+DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public sealed class Evaluate2DGravityModel : BaseFunction<Matrix>
 {
-    [Module(Name = "Evaluate 2D Gravity Model", Description = "Evaluate the result of the 2D Gravity model.",
-    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public sealed class Evaluate2DGravityModel : BaseFunction<Matrix>
-    {
-        [SubModule(Name = "Production", Required = true, Index = 0, Description = "")]
-        public IFunction<Vector> Production = null!;
+    [SubModule(Name = "Production", Required = true, Index = 0, Description = "")]
+    public IFunction<Vector> Production = null!;
 
-        [SubModule(Name = "Attraction", Required = true, Index = 1, Description = "")]
-        public IFunction<Vector> Attraction = null!;
+    [SubModule(Name = "Attraction", Required = true, Index = 1, Description = "")]
+    public IFunction<Vector> Attraction = null!;
 
-        [SubModule(Name = "Friction", Required = true, Index = 2, Description = "")]
-        public IFunction<Matrix> Friction = null!;
+    [SubModule(Name = "Friction", Required = true, Index = 2, Description = "")]
+    public IFunction<Matrix> Friction = null!;
 
-        [Parameter(Name = "Max Iterations", Index = 3, DefaultValue = "100", Description = "The maximum number of iterations before terminating.")]
-        public IFunction<int> MaxIterations = null!;
+    [Parameter(Name = "Max Iterations", Index = 3, DefaultValue = "100", Description = "The maximum number of iterations before terminating.")]
+    public IFunction<int> MaxIterations = null!;
 
-        [Parameter(Name = "Max Error", Index = 4, DefaultValue = "0.05", Description = "The maximum amount of error before terminating.")]
-        public IFunction<float> MaxError = null!;
+    [Parameter(Name = "Max Error", Index = 4, DefaultValue = "0.05", Description = "The maximum amount of error before terminating.")]
+    public IFunction<float> MaxError = null!;
 
-        private static void Apply(Matrix ret, Matrix friction, Vector production,
-            Vector attraction, Vector attractionStar, float[] columnTotals)
-        {
-            Parallel.For(0, production.Count, new ParallelOptions() { MaxDegreeOfParallelism = Environment.ProcessorCount },
-                () => new float[columnTotals.Length],
-                (flatOrigin, state, localTotals) =>
+    private static void Apply(Matrix ret, Matrix friction, Vector production,
+        Vector attraction, Vector attractionStar, float[] columnTotals)
+    {
+        Parallel.For(0, production.Count, new ParallelOptions() { MaxDegreeOfParallelism = Environment.ProcessorCount },
+            () => new float[columnTotals.Length],
+            (flatOrigin, state, localTotals) =>
+            {
+                var sProduction = production.Data;
+                var length = sProduction.Length;
+                var rowIndex = length * flatOrigin;
+                var sAttraction = attraction.Data;
+                var sFriction = friction.Data.Slice(rowIndex, length);
+                var sRet = ret.Data.Slice(rowIndex, length);
+                var sAttractionStar = attractionStar.Data;
+
+                // check to see if there is no production, if not skip this
+                if (sProduction[flatOrigin] > 0)
                 {
-                    var sProduction = production.Data;
-                    var length = sProduction.Length;
-                    var rowIndex = length * flatOrigin;
-                    var sAttraction = attraction.Data;
-                    var sFriction = friction.Data.Slice(rowIndex, length);
-                    var sRet = ret.Data.Slice(rowIndex, length);
-                    var sAttractionStar = attractionStar.Data;
-                    
-                    // check to see if there is no production, if not skip this
-                    if (sProduction[flatOrigin] > 0)
+                    var sumAf = VectorHelper.Multiply3AndSum(sFriction, sAttraction, sAttractionStar);
+                    sumAf = (sProduction[flatOrigin] / sumAf);
+                    if (float.IsInfinity(sumAf) | float.IsNaN(sumAf))
                     {
-                        var sumAf = VectorHelper.Multiply3AndSum(sFriction, sAttraction, sAttractionStar);
-                        sumAf = (sProduction[flatOrigin] / sumAf);
-                        if (float.IsInfinity(sumAf) | float.IsNaN(sumAf))
-                        {
-                            // this needs to be 0f, otherwise we will be making the attractions have to be balanced higher
-                            sumAf = 0f;
-                        }
-                        VectorHelper.Multiply3Scalar1AndColumnSum(sRet, sFriction, sAttraction, sAttractionStar, sumAf, localTotals.AsSpan());
+                        // this needs to be 0f, otherwise we will be making the attractions have to be balanced higher
+                        sumAf = 0f;
                     }
-                    return localTotals;
-                },
-            localTotals =>
-            {
-                lock (columnTotals)
-                {
-                    VectorHelper.Add(columnTotals, 0, columnTotals, 0, localTotals, 0, columnTotals.Length);
+                    VectorHelper.Multiply3Scalar1AndColumnSum(sRet, sFriction, sAttraction, sAttractionStar, sumAf, localTotals.AsSpan());
                 }
-            });
-        }
+                return localTotals;
+            },
+        localTotals =>
+        {
+            lock (columnTotals)
+            {
+                VectorHelper.Add(columnTotals, 0, columnTotals, 0, localTotals, 0, columnTotals.Length);
+            }
+        });
+    }
 
-        private bool Balance(Vector flatAttractions, Vector flatAttractionStar, float epsilon, float[] columnTotals)
+    private bool Balance(Vector flatAttractions, Vector flatAttractionStar, float epsilon, float[] columnTotals)
+    {
+        VectorHelper.Divide(columnTotals.AsSpan(), flatAttractions.Data, columnTotals.AsSpan());
+        VectorHelper.Multiply(flatAttractionStar.Data, flatAttractionStar.Data, columnTotals);
+        VectorHelper.ReplaceIfNotFinite(flatAttractionStar.Data, 1.0f);
+        return VectorHelper.AreBoundedBy(columnTotals, 0, 1.0f, epsilon, columnTotals.Length);
+    }
+
+    public override Matrix Invoke()
+    {
+        var production = Production.Invoke();
+        var attraction = Attraction.Invoke();
+        var friction = Friction.Invoke();
+        var attractionStar = new Vector(attraction);
+        SetToOne(attractionStar);
+        var ret = new Matrix(friction);
+        var maxIterations = MaxIterations.Invoke();
+        var maxError = MaxError.Invoke();
+        if (production.Categories != attraction.Categories)
         {
-            VectorHelper.Divide(columnTotals.AsSpan(), flatAttractions.Data, columnTotals.AsSpan());
-            VectorHelper.Multiply(flatAttractionStar.Data, flatAttractionStar.Data, columnTotals);
-            VectorHelper.ReplaceIfNotFinite(flatAttractionStar.Data, 1.0f);
-            return VectorHelper.AreBoundedBy(columnTotals, 0, 1.0f, epsilon, columnTotals.Length);
+            throw new XTMFRuntimeException(this, "The production and attraction are not of the same type.");
         }
-
-        public override Matrix Invoke()
+        if (production.Categories != friction.RowCategories)
         {
-            var production = Production.Invoke();
-            var attraction = Attraction.Invoke();
-            var friction = Friction.Invoke();
-            var attractionStar = new Vector(attraction);
-            SetToOne(attractionStar);
-            var ret = new Matrix(friction);
-            var maxIterations = MaxIterations.Invoke();
-            var maxError = MaxError.Invoke();
-            if (production.Categories != attraction.Categories)
-            {
-                throw new XTMFRuntimeException(this, "The production and attraction are not of the same type.");
-            }
-            if (production.Categories != friction.RowCategories)
-            {
-                throw new XTMFRuntimeException(this, "The production and friction are not of the same type.");
-            }
-            float[] columnTotals = new float[attraction.Data.Length];
-            int iteration = 0;
-            do
-            {
-                Array.Clear(columnTotals, 0, columnTotals.Length);
-                Apply(ret, friction, production, attraction, attractionStar, columnTotals);
-            } while (!Balance(attraction, attractionStar, maxError, columnTotals) || (++iteration < maxIterations));
-            return ret;
+            throw new XTMFRuntimeException(this, "The production and friction are not of the same type.");
         }
+        float[] columnTotals = new float[attraction.Data.Length];
+        int iteration = 0;
+        do
+        {
+            Array.Clear(columnTotals, 0, columnTotals.Length);
+            Apply(ret, friction, production, attraction, attractionStar, columnTotals);
+        } while (!Balance(attraction, attractionStar, maxError, columnTotals) || (++iteration < maxIterations));
+        return ret;
+    }
 
-        private static void SetToOne(Vector attractionStar)
+    private static void SetToOne(Vector attractionStar)
+    {
+        var aStarData = attractionStar.Data;
+        for (int i = 0; i < aStarData.Length; i++)
         {
-            var aStarData = attractionStar.Data;
-            for (int i = 0; i < aStarData.Length; i++)
-            {
-                aStarData[i] = 1.0f;
-            }
+            aStarData[i] = 1.0f;
         }
     }
 }
diff --git a/src/TMG-Framework/Processing/EvaluateMatrix.cs b/src/TMG-Framework/Processing/EvaluateMatrix.cs
index 50104b0..910cf53 100644
--- a/src/TMG-Framework/Processing/EvaluateMatrix.cs
+++ b/src/TMG-Framework/Processing/EvaluateMatrix.cs
@@ -16,71 +16,67 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using XTMF2;
+
 using TMG.Frameworks.Data.Processing.AST;
 
-namespace TMG.Processing
+namespace TMG.Processing;
+
+[Module(Name = "Evaluate Matrix", Description = "Evaluates a matrix given the expression.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public class EvaluateMatrix : BaseFunction<Matrix>
 {
-    [Module(Name = "Evaluate Matrix", Description = "Evaluates a matrix given the expression.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public class EvaluateMatrix : BaseFunction<Matrix>
-    {
-        [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
-        public IFunction<string> Expression = null!;
+    [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
+    public IFunction<string> Expression = null!;
 
-        [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
-        public IModule[] Variables = null!;
+    [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
+    public IModule[] Variables = null!;
 
-        private string? PreviousExpressionString = null;
-        private Expression? PreviousExpression = null;
+    private string? PreviousExpressionString = null;
+    private Expression? PreviousExpression = null;
 
-        public override Matrix Invoke()
+    public override Matrix Invoke()
+    {
+        string? error = null;
+        // compile and optimize the expression
+        var expressionString = Expression.Invoke();
+        if (PreviousExpression == null || expressionString != PreviousExpressionString)
         {
-            string? error = null;
-            // compile and optimize the expression
-            var expressionString = Expression.Invoke();
-            if (PreviousExpression == null || expressionString != PreviousExpressionString)
-            {
-                PreviousExpressionString = expressionString;
-                if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(expressionString, out var expression, ref error))
-                {
-                    throw new XTMFRuntimeException(this, error);
-                }
-                PreviousExpression = expression;
-            }
-            var result = PreviousExpression.Evaluate(Variables);
-            if(result.Error)
-            {
-                throw new XTMFRuntimeException(this, result.ErrorMessage);
-            }
-            // this easy case, the expression was of the correct type
-            if(result.IsOdResult)
-            {
-                return result.OdData;
-            }
-            // if the result ended up being a
-            if(result.IsVectorResult)
+            PreviousExpressionString = expressionString;
+            if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(expressionString, out var expression, ref error))
             {
-                throw new XTMFRuntimeException(this, "The expression resulted in a vector instead of a matrix!");
+                throw new XTMFRuntimeException(this, error);
             }
-            throw new XTMFRuntimeException(this, "The expression resulted in a scalar instead of a matrix!");
+            PreviousExpression = expression;
+        }
+        var result = PreviousExpression.Evaluate(Variables);
+        if (result.Error)
+        {
+            throw new XTMFRuntimeException(this, result.ErrorMessage);
+        }
+        // this easy case, the expression was of the correct type
+        if (result.IsOdResult)
+        {
+            return result.OdData;
         }
+        // if the result ended up being a
+        if (result.IsVectorResult)
+        {
+            throw new XTMFRuntimeException(this, "The expression resulted in a vector instead of a matrix!");
+        }
+        throw new XTMFRuntimeException(this, "The expression resulted in a scalar instead of a matrix!");
+    }
 
-        public override bool RuntimeValidation(ref string? error)
+    public override bool RuntimeValidation(ref string? error)
+    {
+        foreach (var module in Variables)
         {
-            foreach(var module in Variables)
+            if (!(module is IFunction<Matrix> || module is IFunction<Vector> || module is IFunction<float>
+                || module is IFunction<Categories>))
             {
-                if(!(module is IFunction<Matrix> || module is IFunction<Vector> || module is IFunction<float>
-                    || module is IFunction<Categories>))
-                {
-                    error = $"Invalid variable module type {module.GetType().Name} from module {module.Name}!";
-                    return false;
-                }
+                error = $"Invalid variable module type {module.GetType().Name} from module {module.Name}!";
+                return false;
             }
-            return true;
         }
+        return true;
     }
 }
diff --git a/src/TMG-Framework/Processing/EvaluateScalar.cs b/src/TMG-Framework/Processing/EvaluateScalar.cs
index db146a6..2b17362 100644
--- a/src/TMG-Framework/Processing/EvaluateScalar.cs
+++ b/src/TMG-Framework/Processing/EvaluateScalar.cs
@@ -16,61 +16,55 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using XTMF2;
-using TMG.Frameworks.Data.Processing.AST;
 
-namespace TMG.Processing
+namespace TMG.Processing;
+
+[Module(Name = "Evaluate Scalar", Description = "Evaluate a scalar given the expression.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public class EvaluateScalar : BaseFunction<float>
 {
-    [Module(Name = "Evaluate Scalar", Description = "Evaluate a scalar given the expression.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public class EvaluateScalar : BaseFunction<float>
-    {
-        [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
-        public IFunction<string> Expression = null!;
+    [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
+    public IFunction<string> Expression = null!;
 
-        [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
-        public IModule[] Variables = null!;
+    [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
+    public IModule[] Variables = null!;
 
-        public override float Invoke()
+    public override float Invoke()
+    {
+        string? error = null;
+        // compile and optimize the expression
+        if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(Expression.Invoke(), out var expression, ref error))
         {
-            string? error = null;
-            // compile and optimize the expression
-            if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(Expression.Invoke(), out var expression, ref error))
-            {
-                throw new XTMFRuntimeException(this, error);
-            }
-            var result = expression.Evaluate(Variables);
-            if (result.Error)
-            {
-                throw new XTMFRuntimeException(this, result.ErrorMessage);
-            }
-            if (result.IsVectorResult)
-            {
-                throw new XTMFRuntimeException(this, "The expression resulted in a vector instead of a scalar!");
-            }
-            if (result.IsOdResult)
-            {
-                throw new XTMFRuntimeException(this, "The expression resulted in a matrix instead of a scalar!");
-            }
-            return result.LiteralValue;
-            
+            throw new XTMFRuntimeException(this, error);
+        }
+        var result = expression.Evaluate(Variables);
+        if (result.Error)
+        {
+            throw new XTMFRuntimeException(this, result.ErrorMessage);
+        }
+        if (result.IsVectorResult)
+        {
+            throw new XTMFRuntimeException(this, "The expression resulted in a vector instead of a scalar!");
         }
+        if (result.IsOdResult)
+        {
+            throw new XTMFRuntimeException(this, "The expression resulted in a matrix instead of a scalar!");
+        }
+        return result.LiteralValue;
 
-        public override bool RuntimeValidation(ref string? error)
+    }
+
+    public override bool RuntimeValidation(ref string? error)
+    {
+        foreach (var module in Variables)
         {
-            foreach (var module in Variables)
+            if (!(module is IFunction<Matrix> || module is IFunction<Vector> || module is IFunction<float>
+                || module is IFunction<Categories>))
             {
-                if (!(module is IFunction<Matrix> || module is IFunction<Vector> || module is IFunction<float>
-                    || module is IFunction<Categories>))
-                {
-                    error = $"Invalid variable module type {module.GetType().Name} from module {module.Name}!";
-                    return false;
-                }
+                error = $"Invalid variable module type {module.GetType().Name} from module {module.Name}!";
+                return false;
             }
-            return true;
         }
+        return true;
     }
 }
diff --git a/src/TMG-Framework/Processing/EvaluateVector.cs b/src/TMG-Framework/Processing/EvaluateVector.cs
index 783d845..32ad012 100644
--- a/src/TMG-Framework/Processing/EvaluateVector.cs
+++ b/src/TMG-Framework/Processing/EvaluateVector.cs
@@ -16,61 +16,55 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using XTMF2;
-using TMG.Frameworks.Data.Processing.AST;
 
-namespace TMG.Processing
+namespace TMG.Processing;
+
+[Module(Name = "Evaluate Vector", Description = "Evaluate a vector given the expression.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public class EvaluateVector : BaseFunction<Vector>
 {
-    [Module(Name = "Evaluate Vector", Description = "Evaluate a vector given the expression.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public class EvaluateVector : BaseFunction<Vector>
-    {
-        [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
-        public IFunction<string> Expression = null!;
+    [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
+    public IFunction<string> Expression = null!;
 
-        [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
-        public IModule[] Variables = null!;
+    [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
+    public IModule[] Variables = null!;
 
-        public override Vector Invoke()
+    public override Vector Invoke()
+    {
+        string? error = null;
+        // compile and optimize the expression
+        if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(Expression.Invoke(), out var expression, ref error))
         {
-            string? error = null;
-            // compile and optimize the expression
-            if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(Expression.Invoke(), out var expression, ref error))
-            {
-                throw new XTMFRuntimeException(this, error);
-            }
-            var result = expression.Evaluate(Variables);
-            if (result.Error)
-            {
-                throw new XTMFRuntimeException(this, result.ErrorMessage);
-            }
-            // this easy case, the expression was of the correct type
-            if (result.IsVectorResult)
-            {
-                return result.VectorData;
-            }
-            if (result.IsOdResult)
-            {
-                throw new XTMFRuntimeException(this, "The expression resulted in a matrix instead of a vector!");
-            }
-            throw new XTMFRuntimeException(this, "The expression resulted in a scalar instead of a vector!");
+            throw new XTMFRuntimeException(this, error);
+        }
+        var result = expression.Evaluate(Variables);
+        if (result.Error)
+        {
+            throw new XTMFRuntimeException(this, result.ErrorMessage);
+        }
+        // this easy case, the expression was of the correct type
+        if (result.IsVectorResult)
+        {
+            return result.VectorData;
         }
+        if (result.IsOdResult)
+        {
+            throw new XTMFRuntimeException(this, "The expression resulted in a matrix instead of a vector!");
+        }
+        throw new XTMFRuntimeException(this, "The expression resulted in a scalar instead of a vector!");
+    }
 
-        public override bool RuntimeValidation(ref string? error)
+    public override bool RuntimeValidation(ref string? error)
+    {
+        foreach (var module in Variables)
         {
-            foreach (var module in Variables)
+            if (!(module is IFunction<Matrix> || module is IFunction<Vector> || module is IFunction<float>
+                || module is IFunction<Categories>))
             {
-                if (!(module is IFunction<Matrix> || module is IFunction<Vector> || module is IFunction<float>
-                    || module is IFunction<Categories>))
-                {
-                    error = $"Invalid variable module type {module.GetType().Name} from module {module.Name}!";
-                    return false;
-                }
+                error = $"Invalid variable module type {module.GetType().Name} from module {module.Name}!";
+                return false;
             }
-            return true;
         }
+        return true;
     }
 }
diff --git a/src/TMG-Framework/Processing/ExecutePipelineInOrderParallel.cs b/src/TMG-Framework/Processing/ExecutePipelineInOrderParallel.cs
index 9c082df..125fe16 100644
--- a/src/TMG-Framework/Processing/ExecutePipelineInOrderParallel.cs
+++ b/src/TMG-Framework/Processing/ExecutePipelineInOrderParallel.cs
@@ -16,33 +16,27 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using XTMF2;
 
-namespace TMG.Processing
+namespace TMG.Processing;
+
+[Module(Name = "Execute Pipeline In Order Parallel", Description = "Execute a given pipeline",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public sealed class ExecutePipelineInOrderParallel<T> : BaseFunction<IEnumerable<T>, IEnumerable<T>>
 {
-    [Module(Name = "Execute Pipeline In Order Parallel", Description = "Execute a given pipeline",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public sealed class ExecutePipelineInOrderParallel<T> : BaseFunction<IEnumerable<T>, IEnumerable<T>>
-    {
-        [SubModule(Index = 0, Name = "To Execute In Parallel", Required = true, Description = "The functions in order to execute the data through in parallel.")]
-        public IFunction<T, T> ToExecuteInParallel = null!;
+    [SubModule(Index = 0, Name = "To Execute In Parallel", Required = true, Description = "The functions in order to execute the data through in parallel.")]
+    public IFunction<T, T> ToExecuteInParallel = null!;
 
-        [SubModule(Index = 1, Name = "To Execute In Serial", Required = false, Description = "The functions in order to execute the data through in parallel.")]
-        public IFunction<T,T>[] ToExecuteNotInParallel = null!;
+    [SubModule(Index = 1, Name = "To Execute In Serial", Required = false, Description = "The functions in order to execute the data through in parallel.")]
+    public IFunction<T, T>[] ToExecuteNotInParallel = null!;
 
-        public override IEnumerable<T> Invoke(IEnumerable<T> context)
+    public override IEnumerable<T> Invoke(IEnumerable<T> context)
+    {
+        var current = context.AsParallel().AsOrdered().Select(element => ToExecuteInParallel.Invoke(element)).AsSequential();
+        for (int i = 0; i < ToExecuteNotInParallel.Length; i++)
         {
-            var current = context.AsParallel().AsOrdered().Select(element => ToExecuteInParallel.Invoke(element)).AsSequential();
-            for (int i = 0; i < ToExecuteNotInParallel.Length; i++)
-            {
-                int localI = i;
-                current = current.Select(element => ToExecuteNotInParallel[localI].Invoke(element));
-            }
-            return current.AsEnumerable();
+            int localI = i;
+            current = current.Select(element => ToExecuteNotInParallel[localI].Invoke(element));
         }
+        return current.AsEnumerable();
     }
 }
diff --git a/src/TMG-Framework/Processing/IntegerizeMatrix.cs b/src/TMG-Framework/Processing/IntegerizeMatrix.cs
index afa4326..eda7504 100644
--- a/src/TMG-Framework/Processing/IntegerizeMatrix.cs
+++ b/src/TMG-Framework/Processing/IntegerizeMatrix.cs
@@ -16,156 +16,148 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using XTMF2;
-using TMG;
-using System.Threading.Tasks;
-
-namespace TMG.Processing
+
+namespace TMG.Processing;
+
+[Module(Name = "Integerize Matrix", Description = "Takes in a matrix and then integerizes it trying to keep the total by planning district.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public class IntegerizeMatrix : BaseFunction<Matrix>
 {
-    [Module(Name = "Integerize Matrix", Description = "Takes in a matrix and then integerizes it trying to keep the total by planning district.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public class IntegerizeMatrix : BaseFunction<Matrix>
-    {
-        [SubModule(Required = true, Index = 0, Name = "Input Matrix", Description = "The matrix that will be integerized.")]
-        public IFunction<Matrix> InputMatrix = null!;
+    [SubModule(Required = true, Index = 0, Name = "Input Matrix", Description = "The matrix that will be integerized.")]
+    public IFunction<Matrix> InputMatrix = null!;
 
-        [Parameter(Index = 1, Name = "Random Seed", Description = "The number used to initialize the random number generator.")]
-        public IFunction<int> RandomSeed = null!;
+    [Parameter(Index = 1, Name = "Random Seed", Description = "The number used to initialize the random number generator.")]
+    public IFunction<int> RandomSeed = null!;
 
-        [SubModule(Required = true, Index = 2, Name = "Zone To PD Map", Description = "A mapping between zone numbers and")]
-        public IFunction<CategoryMap> ZoneToPDMap = null!;
+    [SubModule(Required = true, Index = 2, Name = "Zone To PD Map", Description = "A mapping between zone numbers and")]
+    public IFunction<CategoryMap> ZoneToPDMap = null!;
 
-        /// <summary>
-        /// Computes an integer matrix given the input matrix, randomly assigning the remainders within
-        /// the planning district for the zones.
-        /// </summary>
-        /// <returns>The integerized matrix.</returns>
-        public override Matrix Invoke()
-        {
-            var baseMatrix = InputMatrix!.Invoke();
-            var pdMap = ZoneToPDMap!.Invoke();
-            var zoneToPD = pdMap.CreateIndex();
-            var remainders = SplitIntegerAndRemainderMatrix(baseMatrix, pdMap, zoneToPD, out var pdRemainders);
-            AssignIntegerRemainders(baseMatrix, remainders, pdRemainders, zoneToPD);
-            return baseMatrix;
-        }
+    /// <summary>
+    /// Computes an integer matrix given the input matrix, randomly assigning the remainders within
+    /// the planning district for the zones.
+    /// </summary>
+    /// <returns>The integerized matrix.</returns>
+    public override Matrix Invoke()
+    {
+        var baseMatrix = InputMatrix!.Invoke();
+        var pdMap = ZoneToPDMap!.Invoke();
+        var zoneToPD = pdMap.CreateIndex();
+        var remainders = SplitIntegerAndRemainderMatrix(baseMatrix, pdMap, zoneToPD, out var pdRemainders);
+        AssignIntegerRemainders(baseMatrix, remainders, pdRemainders, zoneToPD);
+        return baseMatrix;
+    }
 
-        /// <summary>
-        /// Splits the integer portion of the matrix from the remainders.
-        /// The rawMatrix will be integerized.
-        /// </summary>
-        /// <param name="rawMatrix">The matrix containing both the integer and remainder data</param>
-        /// <param name="pdMap">The mapping between zone indexes and pd indexes</param>
-        /// <param name="pdRemainderTotals">The </param>
-        /// <returns>A new matrix containing the remainders</returns>
-        private static Matrix SplitIntegerAndRemainderMatrix(Matrix rawMatrix, CategoryMap pdMap, Dictionary<CategoryIndex, CategoryIndex> zoneToPd, out Matrix pdRemainderTotals)
-        {
-            var remainders = new Matrix(rawMatrix.RowCategories, rawMatrix.ColumnCategories);
-            var pdMatrix = new Matrix(pdMap.Destination, pdMap.Destination);
+    /// <summary>
+    /// Splits the integer portion of the matrix from the remainders.
+    /// The rawMatrix will be integerized.
+    /// </summary>
+    /// <param name="rawMatrix">The matrix containing both the integer and remainder data</param>
+    /// <param name="pdMap">The mapping between zone indexes and pd indexes</param>
+    /// <param name="pdRemainderTotals">The </param>
+    /// <returns>A new matrix containing the remainders</returns>
+    private static Matrix SplitIntegerAndRemainderMatrix(Matrix rawMatrix, CategoryMap pdMap, Dictionary<CategoryIndex, CategoryIndex> zoneToPd, out Matrix pdRemainderTotals)
+    {
+        var remainders = new Matrix(rawMatrix.RowCategories, rawMatrix.ColumnCategories);
+        var pdMatrix = new Matrix(pdMap.Destination, pdMap.Destination);
 
-            // Split the integer and remainders while also accumulating the remainders into a PDxPD matrix
-            Parallel.For(0, rawMatrix.RowCategories.Count,
-                () =>
+        // Split the integer and remainders while also accumulating the remainders into a PDxPD matrix
+        Parallel.For(0, rawMatrix.RowCategories.Count,
+            () =>
+            {
+                return new Matrix(pdMap.Destination, pdMap.Destination);
+            }
+            , (int i, ParallelLoopState _, Matrix pdRemainders) =>
+            {
+                int pdI = zoneToPd[i];
+                var iData = rawMatrix.GetRow(i);
+                var rData = remainders.GetRow(i);
+                var pdRow = pdRemainders.GetRow(pdI);
+                for (int j = 0; j < rawMatrix.ColumnCategories.Count; j++)
                 {
-                    return new Matrix(pdMap.Destination, pdMap.Destination);
+                    int pdJ = zoneToPd[j];
+                    var original = iData[j];
+                    iData[j] = (float)Math.Truncate(original);
+                    rData[j] = original - iData[j];
+                    pdRow[pdJ] += rData[j];
                 }
-                , (int i, ParallelLoopState _, Matrix pdRemainders) =>
-                {
-                    int pdI = zoneToPd[i];
-                    var iData = rawMatrix.GetRow(i);
-                    var rData = remainders.GetRow(i);
-                    var pdRow = pdRemainders.GetRow(pdI);
-                    for (int j = 0; j < rawMatrix.ColumnCategories.Count; j++)
-                    {
-                        int pdJ = zoneToPd[j];
-                        var original = iData[j];
-                        iData[j] = (float)Math.Truncate(original);
-                        rData[j] = original - iData[j];
-                        pdRow[pdJ] += rData[j];
-                    }
-                    return pdRemainders;
-                }, (pdRemainders) =>
-                {
-                    lock (pdMatrix)
-                    {
-                        Utilities.VectorHelper.Add(pdMatrix.Data, pdMatrix.Data, pdRemainders.Data);
-                    }
-                });
-            pdRemainderTotals = pdMatrix;
-            return remainders;
-        }
-
-        private void AssignIntegerRemainders(Matrix integers, Matrix remainders, Matrix pdRemainders, Dictionary<CategoryIndex, CategoryIndex> zoneToPD)
-        {
-            var flatZones = integers.RowCategories;
-            var pdIndexes = flatZones.Select((z, i) => zoneToPD[i]).ToArray();
-            var numberOfPDs = pdRemainders.RowCategories.Count;
-            // Create indexes to look for each PDxPD
-            var pairs = new List<ODPair>[numberOfPDs * numberOfPDs];
-            for (int i = 0; i < flatZones.Count; i++)
+                return pdRemainders;
+            }, (pdRemainders) =>
             {
-                var row = new Span<List<ODPair>>(pairs, pdIndexes[i] * numberOfPDs, numberOfPDs);
-                for (int j = 0; j < flatZones.Count; j++)
+                lock (pdMatrix)
                 {
-                    var list = row[pdIndexes[j]];
-                    if (list == null)
-                    {
-                        list = row[pdIndexes[j]] = new List<ODPair>(100);
-                    }
-                    list.Add(new ODPair() { Origin = i, Destination = j });
+                    Utilities.VectorHelper.Add(pdMatrix.Data, pdMatrix.Data, pdRemainders.Data);
                 }
-            }
-
-            var random = new Random(RandomSeed!.Invoke());
+            });
+        pdRemainderTotals = pdMatrix;
+        return remainders;
+    }
 
-            // Method to assign an additional trip to the integer matrix based on the remainders for the given pd of origin and destination
-            void Assign(List<ODPair> zoneList, double pop, ref float pdTotal)
+    private void AssignIntegerRemainders(Matrix integers, Matrix remainders, Matrix pdRemainders, Dictionary<CategoryIndex, CategoryIndex> zoneToPD)
+    {
+        var flatZones = integers.RowCategories;
+        var pdIndexes = flatZones.Select((z, i) => zoneToPD[i]).ToArray();
+        var numberOfPDs = pdRemainders.RowCategories.Count;
+        // Create indexes to look for each PDxPD
+        var pairs = new List<ODPair>[numberOfPDs * numberOfPDs];
+        for (int i = 0; i < flatZones.Count; i++)
+        {
+            var row = new Span<List<ODPair>>(pairs, pdIndexes[i] * numberOfPDs, numberOfPDs);
+            for (int j = 0; j < flatZones.Count; j++)
             {
-                for (int z = 0; z < zoneList.Count; z++)
+                var list = row[pdIndexes[j]];
+                if (list == null)
                 {
-                    int i = zoneList[z].Origin;
-                    int j = zoneList[z].Destination;
-                    var index = i * flatZones.Count + j;
-                    pop -= remainders.Data[index];
-                    if (pop <= 0)
-                    {
-                        integers.Data[index] += 1.0f;
-                        pdTotal -= remainders.Data[index];
-                        remainders.Data[index] = 0.0f;
-                        return;
-                    }
+                    list = row[pdIndexes[j]] = new List<ODPair>(100);
                 }
+                list.Add(new ODPair() { Origin = i, Destination = j });
             }
+        }
 
-            // Create the random seeds to work with for each PDxPD            
-            var seeds = new int[pairs.Length];
-            for (int i = 0; i < seeds.Length; i++)
-            {
-                seeds[i] = random.Next(int.MinValue, int.MaxValue);
-            }
+        var random = new Random(RandomSeed!.Invoke());
 
-            // Solve for each PDxPD
-            Parallel.For(0, pairs.Length, (int index) =>
+        // Method to assign an additional trip to the integer matrix based on the remainders for the given pd of origin and destination
+        void Assign(List<ODPair> zoneList, double pop, ref float pdTotal)
+        {
+            for (int z = 0; z < zoneList.Count; z++)
             {
-                var r = new Random(seeds[index]);
-                int toAssign = (int)Math.Round(pdRemainders.Data[index]);
-                var zoneList = pairs[index];
-                for (int k = 0; k < toAssign; k++)
+                int i = zoneList[z].Origin;
+                int j = zoneList[z].Destination;
+                var index = i * flatZones.Count + j;
+                pop -= remainders.Data[index];
+                if (pop <= 0)
                 {
-                    double pop = r.NextDouble() * pdRemainders.Data[index];
-                    Assign(zoneList, pop, ref pdRemainders.Data[index]);
+                    integers.Data[index] += 1.0f;
+                    pdTotal -= remainders.Data[index];
+                    remainders.Data[index] = 0.0f;
+                    return;
                 }
-            });
+            }
         }
 
-        struct ODPair
+        // Create the random seeds to work with for each PDxPD            
+        var seeds = new int[pairs.Length];
+        for (int i = 0; i < seeds.Length; i++)
         {
-            internal int Origin;
-            internal int Destination;
+            seeds[i] = random.Next(int.MinValue, int.MaxValue);
         }
+
+        // Solve for each PDxPD
+        Parallel.For(0, pairs.Length, (int index) =>
+        {
+            var r = new Random(seeds[index]);
+            int toAssign = (int)Math.Round(pdRemainders.Data[index]);
+            var zoneList = pairs[index];
+            for (int k = 0; k < toAssign; k++)
+            {
+                double pop = r.NextDouble() * pdRemainders.Data[index];
+                Assign(zoneList, pop, ref pdRemainders.Data[index]);
+            }
+        });
+    }
+
+    struct ODPair
+    {
+        internal int Origin;
+        internal int Destination;
     }
 }
diff --git a/src/TMG-Framework/Saving/SaveMatrixAsCSV.cs b/src/TMG-Framework/Saving/SaveMatrixAsCSV.cs
index f913d49..57714ee 100644
--- a/src/TMG-Framework/Saving/SaveMatrixAsCSV.cs
+++ b/src/TMG-Framework/Saving/SaveMatrixAsCSV.cs
@@ -16,112 +16,106 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-using XTMF2;
 
-namespace TMG.Saving
+namespace TMG.Saving;
+
+[Module(Name = "Save Matrix To CSV", Description = "Saves a matrix to the given write stream.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public class SaveMatrixAsCSV : BaseAction<(Matrix Matrix, WriteStream Stream)>
 {
-    [Module(Name = "Save Matrix To CSV", Description = "Saves a matrix to the given write stream.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public class SaveMatrixAsCSV : BaseAction<(Matrix Matrix, WriteStream Stream)>
-    {
-        [Parameter(Name = "Third Normalized", DefaultValue = "True", Index = 0,
-            Description = "Should the data be saved in third normalized form?  If not it will be saved as a CSV Matrix")]
-        public IFunction<bool> ThirdNormalized = null!;
+    [Parameter(Name = "Third Normalized", DefaultValue = "True", Index = 0,
+        Description = "Should the data be saved in third normalized form?  If not it will be saved as a CSV Matrix")]
+    public IFunction<bool> ThirdNormalized = null!;
 
-        [Parameter(Name = "First Index Header", DefaultValue = "Origin", Index = 1,
-            Description = "The name of the first index.")]
-        public IFunction<string> FirstIndexHeader = null!;
+    [Parameter(Name = "First Index Header", DefaultValue = "Origin", Index = 1,
+        Description = "The name of the first index.")]
+    public IFunction<string> FirstIndexHeader = null!;
 
-        [Parameter(Name = "Second Index Header", DefaultValue = "Destination", Index = 2,
-            Description = "The name of the second index.")]
-        public IFunction<string> SecondIndexHeader = null!;
+    [Parameter(Name = "Second Index Header", DefaultValue = "Destination", Index = 2,
+        Description = "The name of the second index.")]
+    public IFunction<string> SecondIndexHeader = null!;
 
-        [Parameter(Name = "Data Index Header", DefaultValue = "Data", Index = 3,
-            Description = "The name of the Data index.")]
-        public IFunction<string> DataIndexHeader = null!;
+    [Parameter(Name = "Data Index Header", DefaultValue = "Data", Index = 3,
+        Description = "The name of the Data index.")]
+    public IFunction<string> DataIndexHeader = null!;
 
-        public override void Invoke((Matrix Matrix, WriteStream Stream) context)
+    public override void Invoke((Matrix Matrix, WriteStream Stream) context)
+    {
+        if (ThirdNormalized.Invoke())
         {
-            if(ThirdNormalized.Invoke())
-            {
-                WriteThirdNormalized(context);
-            }
-            else
-            {
-                WriteCSVMatrix(context);
-            }
+            WriteThirdNormalized(context);
+        }
+        else
+        {
+            WriteCSVMatrix(context);
         }
+    }
 
-        private void WriteCSVMatrix((Matrix Matrix, WriteStream Stream) context)
+    private void WriteCSVMatrix((Matrix Matrix, WriteStream Stream) context)
+    {
+        using var writer = new StreamWriter(context.Stream);
+        var matrix = context.Matrix;
+        var rowCategories = matrix.RowCategories;
+        var columnCategories = matrix.ColumnCategories;
+        var rowLength = rowCategories.Count;
+        var columnLength = columnCategories.Count;
+        writer.Write('"');
+        writer.Write(FirstIndexHeader.Invoke().Replace('"', '\''));
+        writer.Write('\\');
+        writer.Write(SecondIndexHeader.Invoke().Replace('"', '\''));
+        writer.Write('"');
+        for (int i = 0; i < columnLength; i++)
         {
-            using var writer = new StreamWriter(context.Stream);
-            var matrix = context.Matrix;
-            var rowCategories = matrix.RowCategories;
-            var columnCategories = matrix.ColumnCategories;
-            var rowLength = rowCategories.Count;
-            var columnLength = columnCategories.Count;
-            writer.Write('"');
-            writer.Write(FirstIndexHeader.Invoke().Replace('"', '\''));
-            writer.Write('\\');
-            writer.Write(SecondIndexHeader.Invoke().Replace('"', '\''));
-            writer.Write('"');
-            for (int i = 0; i < columnLength; i++)
+            writer.Write(',');
+            writer.Write(columnCategories.GetSparseIndex(i));
+        }
+        writer.WriteLine();
+        var data = matrix.Data;
+        int pos = 0;
+        for (int i = 0; i < rowLength; i++)
+        {
+            writer.Write(rowCategories.GetSparseIndex(i));
+            for (int j = 0; j < columnLength; j++)
             {
                 writer.Write(',');
-                writer.Write(columnCategories.GetSparseIndex(i));
+                writer.Write(data[pos]);
             }
             writer.WriteLine();
-            var data = matrix.Data;
-            int pos = 0;
-            for (int i = 0; i < rowLength; i++)
-            {
-                writer.Write(rowCategories.GetSparseIndex(i));
-                for (int j = 0; j < columnLength; j++)
-                {
-                    writer.Write(',');
-                    writer.Write(data[pos]);
-                }
-                writer.WriteLine();
-            }
         }
+    }
 
-        private static void WriteWithQuotes(StreamWriter writer, string name)
-        {
-            writer.Write('"');
-            writer.Write(name.Replace('"', '\''));
-            writer.Write('"');
-        }
+    private static void WriteWithQuotes(StreamWriter writer, string name)
+    {
+        writer.Write('"');
+        writer.Write(name.Replace('"', '\''));
+        writer.Write('"');
+    }
 
-        private void WriteThirdNormalized((Matrix Matrix, WriteStream Stream) context)
+    private void WriteThirdNormalized((Matrix Matrix, WriteStream Stream) context)
+    {
+        using (StreamWriter writer = new StreamWriter(context.Stream))
         {
-            using (StreamWriter writer = new StreamWriter(context.Stream))
+            var matrix = context.Matrix;
+            var map = matrix.RowCategories;
+            var length = map.Count;
+            var data = matrix.Data;
+            WriteWithQuotes(writer, FirstIndexHeader.Invoke());
+            writer.Write(',');
+            WriteWithQuotes(writer, SecondIndexHeader.Invoke());
+            writer.Write(',');
+            WriteWithQuotes(writer, DataIndexHeader.Invoke());
+            writer.WriteLine();
+            for (int i = 0; i < data.Length; i++)
             {
-                var matrix = context.Matrix;
-                var map = matrix.RowCategories;
-                var length = map.Count;
-                var data = matrix.Data;
-                WriteWithQuotes(writer, FirstIndexHeader.Invoke());
-                writer.Write(',');
-                WriteWithQuotes(writer, SecondIndexHeader.Invoke());
-                writer.Write(',');
-                WriteWithQuotes(writer, DataIndexHeader.Invoke());
-                writer.WriteLine();
-                for (int i = 0; i < data.Length; i++)
+                //ignore zeroed out data to save disk space
+                if (data[i] != 0.0)
                 {
-                    //ignore zeroed out data to save disk space
-                    if(data[i] != 0.0)
-                    {
-                        var (row, column) = matrix.GetSparseIndex(i);
-                        writer.Write(row);
-                        writer.Write(',');
-                        writer.Write(column);
-                        writer.Write(',');
-                        writer.WriteLine(data[i]);
-                    }
+                    var (row, column) = matrix.GetSparseIndex(i);
+                    writer.Write(row);
+                    writer.Write(',');
+                    writer.Write(column);
+                    writer.Write(',');
+                    writer.WriteLine(data[i]);
                 }
             }
         }
diff --git a/src/TMG-Framework/Saving/SaveMatrixAsMTX.cs b/src/TMG-Framework/Saving/SaveMatrixAsMTX.cs
index 2937ae2..92ef800 100644
--- a/src/TMG-Framework/Saving/SaveMatrixAsMTX.cs
+++ b/src/TMG-Framework/Saving/SaveMatrixAsMTX.cs
@@ -16,55 +16,47 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.IO;
-using XTMF2;
-using TMG.Utilities;
-using System.Runtime.InteropServices;
 
-namespace TMG.Saving
+namespace TMG.Saving;
+
+[Module(Name = "Save Matrix To MTX", Description = "Saves a matrix to the given write stream.",
+DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public class SaveMatrixAsMTX : BaseAction<(Matrix Matrix, WriteStream Stream)>
 {
-    [Module(Name = "Save Matrix To MTX", Description = "Saves a matrix to the given write stream.",
-    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public class SaveMatrixAsMTX : BaseAction<(Matrix Matrix, WriteStream Stream)>
-    {
-        private const uint MagicNumber = 0xC4D4F1B2;
+    private const uint MagicNumber = 0xC4D4F1B2;
 
-        private const int FloatType = 0x1;
+    private const int FloatType = 0x1;
 
-        public override void Invoke((Matrix Matrix, WriteStream Stream) context)
+    public override void Invoke((Matrix Matrix, WriteStream Stream) context)
+    {
+        using (var writer = new BinaryWriter(context.Stream))
         {
-            using (var writer = new BinaryWriter(context.Stream))
+            var matrix = context.Matrix;
+            var rowCategories = matrix.RowCategories;
+            var columnCategories = matrix.ColumnCategories;
+            var rowLength = rowCategories.Count;
+            var columnLength = columnCategories.Count;
+            writer.Write(MagicNumber);
+            writer.Write((int)1);
+            writer.Write(FloatType);
+            writer.Write((int)2);
+            // write out the lengths for each index
+            writer.Write(rowLength);
+            writer.Write(columnLength);
+            writer.Flush();
+            using (var indexWriter = new BinaryWriter(context.Stream, Encoding.Unicode, true))
             {
-                var matrix = context.Matrix;
-                var rowCategories = matrix.RowCategories;
-                var columnCategories = matrix.ColumnCategories;
-                var rowLength = rowCategories.Count;
-                var columnLength = columnCategories.Count;
-                writer.Write(MagicNumber);
-                writer.Write((int)1);
-                writer.Write(FloatType);
-                writer.Write((int)2);
-                // write out the lengths for each index
-                writer.Write(rowLength);
-                writer.Write(columnLength);
-                writer.Flush();
-                using (var indexWriter = new BinaryWriter(context.Stream, Encoding.Unicode, true))
+                for (int i = 0; i < rowLength; i++)
+                {
+                    indexWriter.Write(rowCategories.GetSparseIndex(i));
+                }
+                for (int i = 0; i < columnLength; i++)
                 {
-                    for (int i = 0; i < rowLength; i++)
-                    {
-                        indexWriter.Write(rowCategories.GetSparseIndex(i));
-                    }
-                    for (int i = 0; i < columnLength; i++)
-                    {
-                        indexWriter.Write(columnCategories.GetSparseIndex(i));
-                    }
+                    indexWriter.Write(columnCategories.GetSparseIndex(i));
                 }
-                // use span to avoid copying the data
-                writer.Write(MemoryMarshal.Cast<float,byte>(matrix.Data));
             }
+            // use span to avoid copying the data
+            writer.Write(MemoryMarshal.Cast<float, byte>(matrix.Data));
         }
     }
 }
diff --git a/src/TMG-Framework/Saving/SaveVectorAsCSV.cs b/src/TMG-Framework/Saving/SaveVectorAsCSV.cs
index ed9bb5e..257a1d1 100644
--- a/src/TMG-Framework/Saving/SaveVectorAsCSV.cs
+++ b/src/TMG-Framework/Saving/SaveVectorAsCSV.cs
@@ -16,51 +16,45 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-using XTMF2;
 
-namespace TMG.Saving
+namespace TMG.Saving;
+
+[Module(Name = "Save Vector To CSV", Description = "Saves a vector to the given write stream.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public sealed class SaveVectorAsCSV : BaseAction<(Vector Data, WriteStream Stream)>
 {
-    [Module(Name = "Save Vector To CSV", Description = "Saves a vector to the given write stream.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public sealed class SaveVectorAsCSV : BaseAction<(Vector Data, WriteStream Stream)>
+    public override void Invoke((Vector Data, WriteStream Stream) context)
     {
-        public override void Invoke((Vector Data, WriteStream Stream) context)
+        using (var writer = new StreamWriter(context.Stream))
         {
-            using (var writer = new StreamWriter(context.Stream))
+            var data = context.Data;
+            var flatData = data.Data;
+            var map = data.Categories;
+            WriteHeaders(writer);
+            var length = map.Count;
+            for (int i = 0; i < length; i++)
             {
-                var data = context.Data;
-                var flatData = data.Data;
-                var map = data.Categories;
-                WriteHeaders(writer);
-                var length = map.Count;
-                for (int i = 0; i < length; i++)
-                {
-                    writer.Write(map.GetSparseIndex(i));
-                    writer.Write(',');
-                    writer.WriteLine(flatData[i]);
-                }
+                writer.Write(map.GetSparseIndex(i));
+                writer.Write(',');
+                writer.WriteLine(flatData[i]);
             }
         }
+    }
 
-        [Parameter(Name = "Map Column Name", DefaultValue = "Zone", Description = "The header to give to the map indexes", Index = 0)]
-        public IFunction<string> MapColumnName = null!;
+    [Parameter(Name = "Map Column Name", DefaultValue = "Zone", Description = "The header to give to the map indexes", Index = 0)]
+    public IFunction<string> MapColumnName = null!;
 
-        [Parameter(Name = "Data Column Name", DefaultValue = "Data", Description = "The header to give to the data", Index = 1)]
-        public IFunction<string> DataColumnName = null!;
+    [Parameter(Name = "Data Column Name", DefaultValue = "Data", Description = "The header to give to the data", Index = 1)]
+    public IFunction<string> DataColumnName = null!;
 
-        private void WriteHeaders(StreamWriter writer)
-        {
-            writer.Write('\"');
-            writer.Write(MapColumnName.Invoke().Replace('\"', '\''));
-            writer.Write('\"');
-            writer.Write(',');
-            writer.Write('\"');
-            writer.Write(DataColumnName.Invoke());
-            writer.WriteLine('\"');
-        }
+    private void WriteHeaders(StreamWriter writer)
+    {
+        writer.Write('\"');
+        writer.Write(MapColumnName.Invoke().Replace('\"', '\''));
+        writer.Write('\"');
+        writer.Write(',');
+        writer.Write('\"');
+        writer.Write(DataColumnName.Invoke());
+        writer.WriteLine('\"');
     }
 }
diff --git a/src/TMG-Framework/Select/SelectGivenTime.cs b/src/TMG-Framework/Select/SelectGivenTime.cs
index fe3d75c..6119c84 100644
--- a/src/TMG-Framework/Select/SelectGivenTime.cs
+++ b/src/TMG-Framework/Select/SelectGivenTime.cs
@@ -16,76 +16,71 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using XTMF2;
 
-namespace TMG.Select
+namespace TMG.Select;
+
+[Module(Name = "Select Matrix By Time Period", Description = "Get a piece of data given a time period.  If no results are possible the first data is returned.",
+    DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
+public sealed class SelectGivenTime<T> : BaseFunction<Time, T>
 {
-    [Module(Name = "Select Matrix By Time Period", Description = "Get a piece of data given a time period.  If no results are possible the first data is returned.",
-        DocumentationLink = "http://tmg.utoronto.ca/doc/2.0")]
-    public sealed class SelectGivenTime<T> : BaseFunction<Time, T>
-    {
-        [SubModule(Index = 0, Name = "Time Period Data", Required = true, Description = "The possible results for given time periods")]
-        public IFunction<(TimePeriod period, T data)>[] TimePeriodData = null!;
+    [SubModule(Index = 0, Name = "Time Period Data", Required = true, Description = "The possible results for given time periods")]
+    public IFunction<(TimePeriod period, T data)>[] TimePeriodData = null!;
 
-        [Parameter(Index = 1, Name = "Default Time Period", DefaultValue = "0", Required = true, Description = "The time period to select if no time periods are applicable.")]
-        public IFunction<int> DefaultTimePeriod = null!;
+    [Parameter(Index = 1, Name = "Default Time Period", DefaultValue = "0", Required = true, Description = "The time period to select if no time periods are applicable.")]
+    public IFunction<int> DefaultTimePeriod = null!;
 
-        private TimePeriod[]? _TimeOperations;
+    private TimePeriod[]? _TimeOperations;
 
-        public override T Invoke(Time context)
+    public override T Invoke(Time context)
+    {
+        var local = _TimeOperations;
+        if (local is not null)
         {
-            var local = _TimeOperations;
-            if (local is not null)
+            for (int i = 0; i < local.Length; i++)
             {
-                for (int i = 0; i < local.Length; i++)
+                if (local[i].Contains(context))
                 {
-                    if (local[i].Contains(context))
-                    {
-                        return TimePeriodData[i].Invoke().data;
-                    }
+                    return TimePeriodData[i].Invoke().data;
                 }
-                return ReturnDefaultData();
             }
-            return BuildIndexAndReturnResult(context);
+            return ReturnDefaultData();
         }
+        return BuildIndexAndReturnResult(context);
+    }
 
-        private T ReturnDefaultData()
+    private T ReturnDefaultData()
+    {
+        var index = DefaultTimePeriod.Invoke();
+        if (index < 0)
         {
-            var index = DefaultTimePeriod.Invoke();
-            if (index < 0)
-            {
-                throw new XTMFRuntimeException(this, "Unable to use a default index less than zero!");
-            }
-            else if (index >= TimePeriodData.Length)
-            {
-                throw new XTMFRuntimeException(this, "Unable to use a default index higher than the number of time periods!");
-            }
-            return TimePeriodData[index].Invoke().data;
+            throw new XTMFRuntimeException(this, "Unable to use a default index less than zero!");
         }
+        else if (index >= TimePeriodData.Length)
+        {
+            throw new XTMFRuntimeException(this, "Unable to use a default index higher than the number of time periods!");
+        }
+        return TimePeriodData[index].Invoke().data;
+    }
 
-        private T BuildIndexAndReturnResult(Time context)
+    private T BuildIndexAndReturnResult(Time context)
+    {
+        var local = new TimePeriod[TimePeriodData.Length];
+        for (int i = 0; i < TimePeriodData.Length; i++)
         {
-            var local = new TimePeriod[TimePeriodData.Length];
-            for (int i = 0; i < TimePeriodData.Length; i++)
-            {
-                var res = TimePeriodData[i].Invoke();
-                local[i] = res.period;
-            }
-            _TimeOperations = local;
-            return Invoke(context);
+            var res = TimePeriodData[i].Invoke();
+            local[i] = res.period;
         }
+        _TimeOperations = local;
+        return Invoke(context);
+    }
 
-        public override bool RuntimeValidation(ref string? error)
+    public override bool RuntimeValidation(ref string? error)
+    {
+        if (TimePeriodData.Length <= 0)
         {
-            if (TimePeriodData.Length <= 0)
-            {
-                error = "You must have at least one matrix available!";
-                return false;
-            }
-            return true;
+            error = "You must have at least one matrix available!";
+            return false;
         }
+        return true;
     }
 }
diff --git a/src/TMG-Framework/TMG-Framework.csproj b/src/TMG-Framework/TMG-Framework.csproj
index c35ab72..11935cb 100644
--- a/src/TMG-Framework/TMG-Framework.csproj
+++ b/src/TMG-Framework/TMG-Framework.csproj
@@ -4,6 +4,7 @@
     <TargetFramework>net10.0</TargetFramework>
     <RootNamespace>TMG</RootNamespace>
     <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
     <Authors>University of Toronto</Authors>
     <Company>University of Toronto</Company>
     <Description>A set of modules for XTMF2 to provide assistance in Travel Demand Modelling.</Description>
diff --git a/src/TMG-Framework/Utilities/CSVReader.cs b/src/TMG-Framework/Utilities/CSVReader.cs
index c89eaaa..b0f9f5b 100644
--- a/src/TMG-Framework/Utilities/CSVReader.cs
+++ b/src/TMG-Framework/Utilities/CSVReader.cs
@@ -17,491 +17,485 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
+namespace TMG.Utilities;
 
-namespace TMG.Utilities
+public sealed class CsvReader : IDisposable
 {
-    public sealed class CsvReader : IDisposable
-    {
-        internal char[] LineBuffer = new char[512];
+    internal char[] LineBuffer = new char[512];
 
-        internal int LinePosition;
+    internal int LinePosition;
 
-        /// <summary>
-        /// The reader we use to get the IO data
-        /// </summary>
-        private readonly BinaryReader Reader;
+    /// <summary>
+    /// The reader we use to get the IO data
+    /// </summary>
+    private readonly BinaryReader Reader;
 
-        /// <summary>
-        /// The segments set when we read in a line
-        /// </summary>
-        private CsvPartition[] Data = new CsvPartition[50];
+    /// <summary>
+    /// The segments set when we read in a line
+    /// </summary>
+    private CsvPartition[] Data = new CsvPartition[50];
 
-        private char[] DataBuffer = new char[0x4000];
-        private char[]? DataBuffer2;
+    private char[] DataBuffer = new char[0x4000];
+    private char[]? DataBuffer2;
 
-        private int DataBufferLength;
+    private int DataBufferLength;
 
-        private int DataBufferPosition;
+    private int DataBufferPosition;
 
-        private readonly bool SpacesAsSeperator;
+    private readonly bool SpacesAsSeperator;
 
-        private readonly string[] _headers;
-        public ReadOnlySpan<string> Headers => _headers;
+    private readonly string[] _headers;
+    public ReadOnlySpan<string> Headers => _headers;
 
-        public long LineNumber { get; private set; }
+    public long LineNumber { get; private set; }
 
-        /// <summary>
-        /// Create a link to a CSV file
-        /// </summary>
-        /// <param name="fileName"></param>
-        /// <param name="spacesAsSeperator">If true, spaces outside of spaces will denote breaks for columns</param>
-        public CsvReader(string fileName, bool spacesAsSeperator = false)
+    /// <summary>
+    /// Create a link to a CSV file
+    /// </summary>
+    /// <param name="fileName"></param>
+    /// <param name="spacesAsSeperator">If true, spaces outside of spaces will denote breaks for columns</param>
+    public CsvReader(string fileName, bool spacesAsSeperator = false)
+    {
+        FileName = fileName;
+        Reader = new BinaryReader(File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite));
+        BaseStream = Reader.BaseStream;
+        DataBufferLength = -1;
+        SpacesAsSeperator = spacesAsSeperator;
+        _headers = LoadLine(out int columns) && columns > 0 ? new string[columns] : Array.Empty<string>();
+        for (int i = 0; i < _headers.Length; i++)
         {
-            FileName = fileName;
-            Reader = new BinaryReader(File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite));
-            BaseStream = Reader.BaseStream;
-            DataBufferLength = -1;
-            SpacesAsSeperator = spacesAsSeperator;
-            _headers = LoadLine(out int columns) && columns > 0 ? new string[columns] : Array.Empty<string>();
-            for (int i = 0; i < _headers.Length; i++)
-            {
-                Get(out _headers[i], i);
-            }
+            Get(out _headers[i], i);
         }
+    }
 
-        public CsvReader(Stream stream, bool spacesAsSeperator = false)
+    public CsvReader(Stream stream, bool spacesAsSeperator = false)
+    {
+        FileName = "Stream";
+        Reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
+        BaseStream = Reader.BaseStream;
+        DataBufferLength = -1;
+        SpacesAsSeperator = spacesAsSeperator;
+        _headers = LoadLine(out int columns) && columns > 0 ? new string[columns] : Array.Empty<string>();
+        for (int i = 0; i < _headers.Length; i++)
         {
-            FileName = "Stream";
-            Reader = new BinaryReader(stream, System.Text.Encoding.UTF8, true);
-            BaseStream = Reader.BaseStream;
-            DataBufferLength = -1;
-            SpacesAsSeperator = spacesAsSeperator;
-            _headers = LoadLine(out int columns) && columns > 0 ? new string[columns] : Array.Empty<string>();
-            for (int i = 0; i < _headers.Length; i++)
-            {
-                Get(out _headers[i], i);
-            }
+            Get(out _headers[i], i);
         }
+    }
 
-        public Stream BaseStream
-        {
-            get;
-        }
+    public Stream BaseStream
+    {
+        get;
+    }
 
-        public bool EndOfFile => DataBufferLength == 0;
+    public bool EndOfFile => DataBufferLength == 0;
 
-        /// <summary>
-        /// The file name
-        /// </summary>
-        public string FileName { get; }
+    /// <summary>
+    /// The file name
+    /// </summary>
+    public string FileName { get; }
 
-        public void Close()
-        {
-            Dispose(false);
-        }
+    public void Close()
+    {
+        Dispose(false);
+    }
 
-        /// <summary>
-        /// Find the index of the column with the given header.
-        /// </summary>
-        /// <param name="header">The name of the header to search for.</param>
-        /// <returns>The index for the column with the given name. -1 if the header is not found.</returns>
-        public int GetColumnIndexWithHeader(string header)
+    /// <summary>
+    /// Find the index of the column with the given header.
+    /// </summary>
+    /// <param name="header">The name of the header to search for.</param>
+    /// <returns>The index for the column with the given name. -1 if the header is not found.</returns>
+    public int GetColumnIndexWithHeader(string header)
+    {
+        for (int i = 0; i < _headers.Length; i++)
         {
-            for (int i = 0; i < _headers.Length; i++)
+            if (header.Equals(_headers[i], StringComparison.OrdinalIgnoreCase))
             {
-                if(header.Equals(_headers[i], StringComparison.OrdinalIgnoreCase))
-                {
-                    return i;
-                }
+                return i;
             }
-            return -1;
         }
+        return -1;
+    }
 
-        /// <summary>
-        ///Get a float from a col position
-        /// </summary>
-        /// <param name="item">Where to put the data</param>
-        /// <param name="pos">Which column to read from, 0 indexed</param>
-        public void Get(out float item, int pos)
-        {
-            var data = Data[pos];
-            item = float.Parse(LineBuffer.AsSpan(data.Start, data.End - data.Start));
-        }
+    /// <summary>
+    ///Get a float from a col position
+    /// </summary>
+    /// <param name="item">Where to put the data</param>
+    /// <param name="pos">Which column to read from, 0 indexed</param>
+    public void Get(out float item, int pos)
+    {
+        var data = Data[pos];
+        item = float.Parse(LineBuffer.AsSpan(data.Start, data.End - data.Start));
+    }
 
-        /// <summary>
-        ///Get a double from a col position
-        /// </summary>
-        /// <param name="item">Where to put the data</param>
-        /// <param name="pos">Which column to read from, 0 indexed</param>
-        public void Get(out double item, int pos)
-        {
-            var data = Data[pos];
-            item = double.Parse(LineBuffer.AsSpan(data.Start, data.End - data.Start));
-        }
+    /// <summary>
+    ///Get a double from a col position
+    /// </summary>
+    /// <param name="item">Where to put the data</param>
+    /// <param name="pos">Which column to read from, 0 indexed</param>
+    public void Get(out double item, int pos)
+    {
+        var data = Data[pos];
+        item = double.Parse(LineBuffer.AsSpan(data.Start, data.End - data.Start));
+    }
 
-        /// <summary>
-        /// Get an int from a col position
-        /// </summary>
-        /// <param name="item">Where to put the data</param>
-        /// <param name="pos">Which column to read from, 0 indexed</param>
-        public void Get(out int item, int pos)
-        {
-            var data = Data[pos];
-            item = int.Parse(LineBuffer.AsSpan(data.Start, data.End - data.Start));
-        }
+    /// <summary>
+    /// Get an int from a col position
+    /// </summary>
+    /// <param name="item">Where to put the data</param>
+    /// <param name="pos">Which column to read from, 0 indexed</param>
+    public void Get(out int item, int pos)
+    {
+        var data = Data[pos];
+        item = int.Parse(LineBuffer.AsSpan(data.Start, data.End - data.Start));
+    }
 
-        /// <summary>
-        /// Get a character out
-        /// </summary>
-        /// <param name="item">Where to put the data</param>
-        /// <param name="pos">Which column to read from, 0 indexed</param>
-        public void Get(out char item, int pos)
-        {
-            item = LineBuffer[Data[pos].Start];
-        }
+    /// <summary>
+    /// Get a character out
+    /// </summary>
+    /// <param name="item">Where to put the data</param>
+    /// <param name="pos">Which column to read from, 0 indexed</param>
+    public void Get(out char item, int pos)
+    {
+        item = LineBuffer[Data[pos].Start];
+    }
 
-        /// <summary>
-        /// Get a string out
-        /// </summary>
-        /// <param name="item">Where to put the data</param>
-        /// <param name="pos">Which column to read from, 0 indexed</param>
-        public void Get(out string item, int pos)
-        {
-            var data = Data[pos];
-            item = new string(LineBuffer, data.Start, data.End - data.Start);
-        }
+    /// <summary>
+    /// Get a string out
+    /// </summary>
+    /// <param name="item">Where to put the data</param>
+    /// <param name="pos">Which column to read from, 0 indexed</param>
+    public void Get(out string item, int pos)
+    {
+        var data = Data[pos];
+        item = new string(LineBuffer, data.Start, data.End - data.Start);
+    }
 
-        /// <summary>
-        /// Get a read-only span of a string out
-        /// </summary>
-        /// <param name="item">Where to initialize the span</param>
-        /// <param name="pos">Which column to read from, 0 indexed</param>
-        public void Get(out ReadOnlySpan<char> item, int pos)
-        {
-            var data = Data[pos];
-            item = LineBuffer.AsSpan(data.Start, data.End - data.Start);
-        }
+    /// <summary>
+    /// Get a read-only span of a string out
+    /// </summary>
+    /// <param name="item">Where to initialize the span</param>
+    /// <param name="pos">Which column to read from, 0 indexed</param>
+    public void Get(out ReadOnlySpan<char> item, int pos)
+    {
+        var data = Data[pos];
+        item = LineBuffer.AsSpan(data.Start, data.End - data.Start);
+    }
+
+    /// <summary>
+    /// Reads in a line and gives the number of columns
+    /// </summary>
+    /// <returns>The number of columns returned</returns>
+    public int LoadLine()
+    {
+        LoadLine(out int res);
+        return res;
+    }
 
-        /// <summary>
-        /// Reads in a line and gives the number of columns
-        /// </summary>
-        /// <returns>The number of columns returned</returns>
-        public int LoadLine()
+    /// <summary>
+    /// Reads in a line and gives the number of columns
+    /// </summary>
+    /// <param name="columns">The number of columns read in for this line.</param>
+    /// <returns>True if data was read. (Not end of file)</returns>
+    public bool LoadLine(out int columns)
+    {
+        var numberOfColumns = 0;
+        LinePosition = 0;
+        if (Reader == null) throw new IOException("No file has been loaded!");
+        if (FastEndOfFile())
         {
-            LoadLine(out int res);
-            return res;
+            columns = 0;
+            return false;
         }
-
-        /// <summary>
-        /// Reads in a line and gives the number of columns
-        /// </summary>
-        /// <param name="columns">The number of columns read in for this line.</param>
-        /// <returns>True if data was read. (Not end of file)</returns>
-        public bool LoadLine(out int columns)
+        LineNumber++;
+        var prevEnd = -1;
+        var addOne = false;
+        var i = 0;
+        var prevC = '\0';
+        var quote = false;
+        var previousWasQuote = false;
+        if (SpacesAsSeperator)
         {
-            var numberOfColumns = 0;
-            LinePosition = 0;
-            if (Reader == null) throw new IOException("No file has been loaded!");
-            if (FastEndOfFile())
+            while (true)
             {
-                columns = 0;
-                return false;
-            }
-            LineNumber++;
-            var prevEnd = -1;
-            var addOne = false;
-            var i = 0;
-            var prevC = '\0';
-            var quote = false;
-            var previousWasQuote = false;
-            if (SpacesAsSeperator)
-            {
-                while (true)
+                char c;
+                // make sure there is data
+                if (DataBufferPosition >= DataBufferLength)
                 {
-                    char c;
-                    // make sure there is data
-                    if (DataBufferPosition >= DataBufferLength)
+                    LoadInData();
+                    // if we are at the end of file just end it
+                    if (DataBufferLength <= 0)
                     {
-                        LoadInData();
-                        // if we are at the end of file just end it
-                        if (DataBufferLength <= 0)
+                        if (addOne)
                         {
-                            if (addOne)
-                            {
-                                Data[numberOfColumns++] = new CsvPartition(prevEnd + 1, i);
-                            }
-                            columns = numberOfColumns;
-                            return columns > 0;
-                        }
-                    }
-                    c = DataBuffer[DataBufferPosition++];
-                    if ((prevC == '\r' && c != '\n' && c != '\0') || (c == '\n') || (c == '\0'))
-                    {
-                        // Create a new column if this is a Linux file format.
-                        if (prevC != '\r')
-                        {
-                            if (Data.Length <= numberOfColumns)
-                            {
-                                ExpandDataSections();
-                            }
                             Data[numberOfColumns++] = new CsvPartition(prevEnd + 1, i);
-                            addOne = false;
-                        }
-                        else if (prevC == '\r' && c != '\n' && c != '\0')
-                        {
-                            // If it was just a MAC encoded line ending then we need to process the current character in the next load.
-                            DataBufferPosition--;
-                            addOne = false;
                         }
-                        break;
+                        columns = numberOfColumns;
+                        return columns > 0;
                     }
-                    if (c == '"')
+                }
+                c = DataBuffer[DataBufferPosition++];
+                if ((prevC == '\r' && c != '\n' && c != '\0') || (c == '\n') || (c == '\0'))
+                {
+                    // Create a new column if this is a Linux file format.
+                    if (prevC != '\r')
                     {
-                        if (previousWasQuote)
-                        {
-                            // if the previous was a quote, reactive quote mode and
-                            // add it to the line buffer
-                            previousWasQuote = false;
-                            quote = true;
-                        }
-                        else
+                        if (Data.Length <= numberOfColumns)
                         {
-                            previousWasQuote = true;
-                            if (prevEnd == i - 1)
-                            {
-                                quote = true;
-                                continue;
-                            }
-                            if (quote)
-                            {
-                                quote = false;
-                                continue;
-                            }
+                            ExpandDataSections();
                         }
-                        // if it is just in the middle continue on
+                        Data[numberOfColumns++] = new CsvPartition(prevEnd + 1, i);
+                        addOne = false;
                     }
-                    else
+                    else if (prevC == '\r' && c != '\n' && c != '\0')
                     {
-                        previousWasQuote = false;
+                        // If it was just a MAC encoded line ending then we need to process the current character in the next load.
+                        DataBufferPosition--;
+                        addOne = false;
                     }
-                    if (LinePosition >= LineBuffer.Length)
+                    break;
+                }
+                if (c == '"')
+                {
+                    if (previousWasQuote)
                     {
-                        Array.Resize(ref LineBuffer, LineBuffer.Length * 2);
+                        // if the previous was a quote, reactive quote mode and
+                        // add it to the line buffer
+                        previousWasQuote = false;
+                        quote = true;
                     }
-                    LineBuffer[LinePosition++] = c;
-                    // if a comma or an end quote followed by a comma
-                    if ((!quote && (c == ',' || c == '\t' || (prevC != ' ' && c == ' ')))
-                        || c == '\r')
+                    else
                     {
-                        addOne = false;
-                        if (Data.Length <= numberOfColumns)
+                        previousWasQuote = true;
+                        if (prevEnd == i - 1)
                         {
-                            ExpandDataSections();
+                            quote = true;
+                            continue;
+                        }
+                        if (quote)
+                        {
+                            quote = false;
+                            continue;
                         }
-                        Data[numberOfColumns++] = new CsvPartition(prevEnd + 1, prevEnd = i);
                     }
-                    else
+                    // if it is just in the middle continue on
+                }
+                else
+                {
+                    previousWasQuote = false;
+                }
+                if (LinePosition >= LineBuffer.Length)
+                {
+                    Array.Resize(ref LineBuffer, LineBuffer.Length * 2);
+                }
+                LineBuffer[LinePosition++] = c;
+                // if a comma or an end quote followed by a comma
+                if ((!quote && (c == ',' || c == '\t' || (prevC != ' ' && c == ' ')))
+                    || c == '\r')
+                {
+                    addOne = false;
+                    if (Data.Length <= numberOfColumns)
                     {
-                        addOne = true;
+                        ExpandDataSections();
                     }
-                    prevC = c;
-                    i++;
+                    Data[numberOfColumns++] = new CsvPartition(prevEnd + 1, prevEnd = i);
+                }
+                else
+                {
+                    addOne = true;
                 }
+                prevC = c;
+                i++;
             }
-            else
+        }
+        else
+        {
+            while (true)
             {
-                while (true)
+                char c;
+                // make sure there is data
+                if (DataBufferPosition >= DataBufferLength)
                 {
-                    char c;
-                    // make sure there is data
-                    if (DataBufferPosition >= DataBufferLength)
+                    LoadInData();
+                    // if we are at the end of file just end it
+                    if (DataBufferLength <= 0)
                     {
-                        LoadInData();
-                        // if we are at the end of file just end it
-                        if (DataBufferLength <= 0)
+                        if (addOne)
                         {
-                            if (addOne)
-                            {
-                                Data[numberOfColumns++] = new CsvPartition(prevEnd + 1, i);
-                            }
-                            columns = numberOfColumns;
-                            return columns > 0;
-                        }
-                    }
-                    c = DataBuffer[DataBufferPosition++];
-                    if ((prevC == '\r' && c != '\n' && c != '\0') || (c == '\n') || (c == '\0'))
-                    {
-                        // Create a new column if this is a Linux file format.
-                        if (prevC != '\r')
-                        {
-                            if (Data.Length <= numberOfColumns)
-                            {
-                                ExpandDataSections();
-                            }
                             Data[numberOfColumns++] = new CsvPartition(prevEnd + 1, i);
-                            addOne = false;
                         }
-                        else if (prevC == '\r' && c != '\n' && c != '\0')
-                        {
-                            // If it was just a MAC encoded line ending then we need to process the current character in the next load.
-                            DataBufferPosition--;
-                            addOne = false;
-                        }
-                        break;
+                        columns = numberOfColumns;
+                        return columns > 0;
                     }
-                    if (c == '"')
+                }
+                c = DataBuffer[DataBufferPosition++];
+                if ((prevC == '\r' && c != '\n' && c != '\0') || (c == '\n') || (c == '\0'))
+                {
+                    // Create a new column if this is a Linux file format.
+                    if (prevC != '\r')
                     {
-                        if (previousWasQuote)
-                        {
-                            // if the previous was a quote, reactive quote mode and
-                            // add it to the line buffer
-                            previousWasQuote = false;
-                            quote = true;
-                        }
-                        else
+                        if (Data.Length <= numberOfColumns)
                         {
-                            previousWasQuote = true;
-                            if (prevEnd == i - 1)
-                            {
-                                quote = true;
-                                continue;
-                            }
-                            if (quote)
-                            {
-                                quote = false;
-                                continue;
-                            }
+                            ExpandDataSections();
                         }
-                        // if it is just in the middle continue on
+                        Data[numberOfColumns++] = new CsvPartition(prevEnd + 1, i);
+                        addOne = false;
                     }
-                    else
+                    else if (prevC == '\r' && c != '\n' && c != '\0')
                     {
-                        previousWasQuote = false;
+                        // If it was just a MAC encoded line ending then we need to process the current character in the next load.
+                        DataBufferPosition--;
+                        addOne = false;
                     }
-                    if (LinePosition >= LineBuffer.Length)
+                    break;
+                }
+                if (c == '"')
+                {
+                    if (previousWasQuote)
                     {
-                        Array.Resize(ref LineBuffer, LineBuffer.Length * 2);
+                        // if the previous was a quote, reactive quote mode and
+                        // add it to the line buffer
+                        previousWasQuote = false;
+                        quote = true;
                     }
-                    LineBuffer[LinePosition++] = c;
-                    // if a comma or an end quote followed by a comma
-                    if ((!quote && (c == ',' || c == '\t'))
-                        || c == '\r')
+                    else
                     {
-                        addOne = false;
-                        if (Data.Length <= numberOfColumns)
+                        previousWasQuote = true;
+                        if (prevEnd == i - 1)
                         {
-                            ExpandDataSections();
+                            quote = true;
+                            continue;
+                        }
+                        if (quote)
+                        {
+                            quote = false;
+                            continue;
                         }
-                        Data[numberOfColumns++] = new CsvPartition(prevEnd + 1, prevEnd = i);
                     }
-                    else
+                    // if it is just in the middle continue on
+                }
+                else
+                {
+                    previousWasQuote = false;
+                }
+                if (LinePosition >= LineBuffer.Length)
+                {
+                    Array.Resize(ref LineBuffer, LineBuffer.Length * 2);
+                }
+                LineBuffer[LinePosition++] = c;
+                // if a comma or an end quote followed by a comma
+                if ((!quote && (c == ',' || c == '\t'))
+                    || c == '\r')
+                {
+                    addOne = false;
+                    if (Data.Length <= numberOfColumns)
                     {
-                        addOne = true;
+                        ExpandDataSections();
                     }
-                    prevC = c;
-                    i++;
+                    Data[numberOfColumns++] = new CsvPartition(prevEnd + 1, prevEnd = i);
                 }
+                else
+                {
+                    addOne = true;
+                }
+                prevC = c;
+                i++;
             }
-            // check to see if there was actually no data
-            if (LinePosition == 0 || (numberOfColumns == 1 && Data[0].End == 0))
-            {
-                columns = 0;
-            }
-            else
-            {
-                columns = addOne ? numberOfColumns + 1 : numberOfColumns;
-            }
-            return true;
         }
-
-        /// <summary>
-        /// Reset to go to the start
-        /// </summary>
-        public void Reset()
+        // check to see if there was actually no data
+        if (LinePosition == 0 || (numberOfColumns == 1 && Data[0].End == 0))
         {
-            Reader.BaseStream.Seek(0, SeekOrigin.Begin);
-            DataBuffer2 = null;
-            DataBufferLength = -1;
-            LineNumber = 0;
+            columns = 0;
         }
-
-        private void ExpandDataSections()
+        else
         {
-            Array.Resize(ref Data, Data.Length * 2);
+            columns = addOne ? numberOfColumns + 1 : numberOfColumns;
         }
+        return true;
+    }
 
-        private bool FastEndOfFile()
-        {
-            return DataBufferLength == 0;
-        }
+    /// <summary>
+    /// Reset to go to the start
+    /// </summary>
+    public void Reset()
+    {
+        Reader.BaseStream.Seek(0, SeekOrigin.Begin);
+        DataBuffer2 = null;
+        DataBufferLength = -1;
+        LineNumber = 0;
+    }
 
-        private volatile bool NextDataReady;
-        private volatile int NextDataBufferLength;
+    private void ExpandDataSections()
+    {
+        Array.Resize(ref Data, Data.Length * 2);
+    }
+
+    private bool FastEndOfFile()
+    {
+        return DataBufferLength == 0;
+    }
 
-        private void LoadInData()
+    private volatile bool NextDataReady;
+    private volatile int NextDataBufferLength;
+
+    private void LoadInData()
+    {
+        if (DataBuffer2 == null)
         {
-            if (DataBuffer2 == null)
-            {
-                DataBuffer2 = new char[0x4000];
-                NextDataBufferLength = Reader.Read(DataBuffer2, 0, DataBuffer.Length);
-                NextDataReady = true;
-            }
-            // spin-wait on this being ready until the data is ready
-            while (!NextDataReady)
-            {
-            }
-            DataBufferPosition = 0;
-            var temp = DataBuffer;
-            DataBuffer = DataBuffer2;
-            DataBuffer2 = temp;
-            DataBufferLength = NextDataBufferLength;
-            NextDataReady = false;
-            // load the next set of data in parallel
-            Task.Run(() =>
-            {
-                NextDataBufferLength = Reader.Read(DataBuffer2, 0, DataBuffer.Length);
-                Thread.MemoryBarrier();
-                NextDataReady = true;
-            });
+            DataBuffer2 = new char[0x4000];
+            NextDataBufferLength = Reader.Read(DataBuffer2, 0, DataBuffer.Length);
+            NextDataReady = true;
         }
-
-        private readonly struct CsvPartition
+        // spin-wait on this being ready until the data is ready
+        while (!NextDataReady)
         {
-            public readonly int End;
-            public readonly int Start;
-
-            public CsvPartition(int start, int end)
-            {
-                Start = start;
-                End = end;
-            }
         }
+        DataBufferPosition = 0;
+        var temp = DataBuffer;
+        DataBuffer = DataBuffer2;
+        DataBuffer2 = temp;
+        DataBufferLength = NextDataBufferLength;
+        NextDataReady = false;
+        // load the next set of data in parallel
+        Task.Run(() =>
+        {
+            NextDataBufferLength = Reader.Read(DataBuffer2, 0, DataBuffer.Length);
+            Thread.MemoryBarrier();
+            NextDataReady = true;
+        });
+    }
 
-        #region IDisposable Members
+    private readonly struct CsvPartition
+    {
+        public readonly int End;
+        public readonly int Start;
 
-        private void Dispose(bool gcCalled)
+        public CsvPartition(int start, int end)
         {
-            if (!gcCalled)
-            {
-                GC.SuppressFinalize(this);
-            }
-            Reader.Dispose();
+            Start = start;
+            End = end;
         }
+    }
 
-        ~CsvReader()
-        {
-            Dispose(true);
-        }
+    #region IDisposable Members
 
-        public void Dispose()
+    private void Dispose(bool gcCalled)
+    {
+        if (!gcCalled)
         {
-            Dispose(false);
+            GC.SuppressFinalize(this);
         }
+        Reader.Dispose();
+    }
 
-        #endregion IDisposable Members
+    ~CsvReader()
+    {
+        Dispose(true);
     }
-}
\ No newline at end of file
+
+    public void Dispose()
+    {
+        Dispose(false);
+    }
+
+    #endregion IDisposable Members
+}
diff --git a/src/TMG-Framework/Utilities/ExceptionHelper.cs b/src/TMG-Framework/Utilities/ExceptionHelper.cs
index 3bfa0e8..ee074e2 100644
--- a/src/TMG-Framework/Utilities/ExceptionHelper.cs
+++ b/src/TMG-Framework/Utilities/ExceptionHelper.cs
@@ -16,49 +16,44 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Text;
 
-namespace TMG.Utilities
+namespace TMG.Utilities;
+
+/// <summary>
+/// This class provides wrappers around common exception types.  The
+/// reason to use this is to help the JIT inline methods.  If a method
+/// throws an exception it can not be inlined however, if you call one of the
+/// exception helpers it can still be inlined.
+/// </summary>
+internal static class ExceptionHelper
 {
     /// <summary>
-    /// This class provides wrappers around common exception types.  The
-    /// reason to use this is to help the JIT inline methods.  If a method
-    /// throws an exception it can not be inlined however, if you call one of the
-    /// exception helpers it can still be inlined.
+    /// Invoke an out of range exception for a parameter with the given name.
     /// </summary>
-    internal static class ExceptionHelper
+    /// <param name="name">The name of the parameter that caused the out of range exception.</param>
+    [DoesNotReturn]
+    internal static void ThrowOutOfRangeException(string name)
     {
-        /// <summary>
-        /// Invoke an out of range exception for a parameter with the given name.
-        /// </summary>
-        /// <param name="name">The name of the parameter that caused the out of range exception.</param>
-        [DoesNotReturn]
-        internal static void ThrowOutOfRangeException(string name)
-        {
-            throw new ArgumentOutOfRangeException(name);
-        }
+        throw new ArgumentOutOfRangeException(name);
+    }
 
-        /// <summary>
-        /// Invoke an ArgumentNullException for a parameter with the given name.
-        /// </summary>
-        /// <param name="name">The name of the parameter that caused the ArgumentNullException.</param>
-        [DoesNotReturn]
-        internal static void ThrowParameterNull(string name)
-        {
-            throw new ArgumentNullException(name);
-        }
+    /// <summary>
+    /// Invoke an ArgumentNullException for a parameter with the given name.
+    /// </summary>
+    /// <param name="name">The name of the parameter that caused the ArgumentNullException.</param>
+    [DoesNotReturn]
+    internal static void ThrowParameterNull(string name)
+    {
+        throw new ArgumentNullException(name);
+    }
 
-        /// <summary>
-        /// Invoke an ArgumentNullException for a parameter with the given name.
-        /// </summary>
-        /// <param name="name">The name of the parameter that caused the ArgumentNullException.</param>
-        [DoesNotReturn]
-        internal static T ThrowParameterNull<T>(string name)
-        {
-            throw new ArgumentNullException(name);
-        }
+    /// <summary>
+    /// Invoke an ArgumentNullException for a parameter with the given name.
+    /// </summary>
+    /// <param name="name">The name of the parameter that caused the ArgumentNullException.</param>
+    [DoesNotReturn]
+    internal static T ThrowParameterNull<T>(string name)
+    {
+        throw new ArgumentNullException(name);
     }
 }
diff --git a/src/TMG-Framework/Utilities/ObjectStream.cs b/src/TMG-Framework/Utilities/ObjectStream.cs
index b515ecd..1832a9d 100644
--- a/src/TMG-Framework/Utilities/ObjectStream.cs
+++ b/src/TMG-Framework/Utilities/ObjectStream.cs
@@ -16,28 +16,23 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with TMG-Framework for XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using XTMF2;
 
-namespace TMG
+namespace TMG;
+
+public abstract class ObjectStream<OUT> : BaseFunction<OUT>
 {
-    public abstract class ObjectStream<OUT> : BaseFunction<OUT>
-    {
-        /// <summary>
-        /// Invoke this function to signal that the stream should
-        /// restart the stream.
-        /// </summary>
-        public abstract void Reset();
-    }
+    /// <summary>
+    /// Invoke this function to signal that the stream should
+    /// restart the stream.
+    /// </summary>
+    public abstract void Reset();
+}
 
-    public abstract class ObjectStream<IN,OUT> : BaseFunction<IN,OUT>
-    {
-        /// <summary>
-        /// Invoke this function to signal that the stream should
-        /// restart the stream.
-        /// </summary>
-        public abstract void Reset();
-    }
+public abstract class ObjectStream<IN, OUT> : BaseFunction<IN, OUT>
+{
+    /// <summary>
+    /// Invoke this function to signal that the stream should
+    /// restart the stream.
+    /// </summary>
+    public abstract void Reset();
 }
diff --git a/src/TMG-Framework/Utilities/SpanHelper.cs b/src/TMG-Framework/Utilities/SpanHelper.cs
index 9243357..94acee9 100644
--- a/src/TMG-Framework/Utilities/SpanHelper.cs
+++ b/src/TMG-Framework/Utilities/SpanHelper.cs
@@ -16,22 +16,16 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Text;
 
-namespace TMG
+namespace TMG;
+
+static class SpanHelper
 {
-    static class SpanHelper
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal static Span<U> NonPortableCast<T, U>(this Span<T> span)
+        where T : struct
+        where U : struct
     {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static Span<U> NonPortableCast<T,U>(this Span<T> span) 
-            where T : struct
-            where U : struct
-        {
-            return MemoryMarshal.Cast<T,U>(span);
-        }
+        return MemoryMarshal.Cast<T, U>(span);
     }
 }
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Add.cs b/src/TMG-Framework/Utilities/VectorHelper/Add.cs
index a1d34bf..58a06fd 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Add.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Add.cs
@@ -17,12 +17,8 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Threading.Tasks;
 
 namespace TMG.Utilities;
 
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagAnd.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagAnd.cs
index e6eb7e0..868dbf5 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagAnd.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagAnd.cs
@@ -16,13 +16,9 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
+
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Threading.Tasks;
-// ReSharper disable CompareOfFloatsByEqualityOperator
 
 namespace TMG.Utilities;
 
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfEquals.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfEquals.cs
index a4e1e9c..2291a5e 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfEquals.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfEquals.cs
@@ -16,14 +16,10 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
+
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Threading.Tasks;
 using static System.Numerics.Vector;
-// ReSharper disable CompareOfFloatsByEqualityOperator
 
 namespace TMG.Utilities;
 
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThan.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThan.cs
index ee3d2b3..a637577 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThan.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThan.cs
@@ -16,12 +16,9 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
+
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Threading.Tasks;
 using static System.Numerics.Vector;
 
 namespace TMG.Utilities;
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThanOrEqual.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThanOrEqual.cs
index 025209f..18634cf 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThanOrEqual.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThanOrEqual.cs
@@ -16,12 +16,9 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
+
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Threading.Tasks;
 using static System.Numerics.Vector;
 
 namespace TMG.Utilities;
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThan.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThan.cs
index 2b573f9..5fbab14 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThan.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThan.cs
@@ -16,12 +16,9 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
+
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Threading.Tasks;
 using static System.Numerics.Vector;
 
 namespace TMG.Utilities;
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThanOrEqual.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThanOrEqual.cs
index c3cce06..3704b33 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThanOrEqual.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThanOrEqual.cs
@@ -17,12 +17,8 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Threading.Tasks;
 using static System.Numerics.Vector;
 
 namespace TMG.Utilities;
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfNotEquals.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfNotEquals.cs
index 2ab5f74..376c490 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfNotEquals.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfNotEquals.cs
@@ -16,10 +16,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
+
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 
 namespace TMG.Utilities;
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagOr.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagOr.cs
index c271d4d..ea29464 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagOr.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagOr.cs
@@ -16,15 +16,10 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Collections.Generic;
+
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Threading.Tasks;
 using static System.Numerics.Vector;
-// ReSharper disable CompareOfFloatsByEqualityOperator
 
 namespace TMG.Utilities;
 
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Divide.cs b/src/TMG-Framework/Utilities/VectorHelper/Divide.cs
index 9f14011..38998af 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Divide.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Divide.cs
@@ -17,10 +17,7 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 
 namespace TMG.Utilities;
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Exp.cs b/src/TMG-Framework/Utilities/VectorHelper/Exp.cs
index b157516..6c542d4 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Exp.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Exp.cs
@@ -18,9 +18,6 @@ You should have received a copy of the GNU General Public License
 */
 
 using System.Runtime.Intrinsics;
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics.X86;
 
 namespace TMG.Utilities;
diff --git a/src/TMG-Framework/Utilities/VectorHelper/FusedMultiplyAdd.cs b/src/TMG-Framework/Utilities/VectorHelper/FusedMultiplyAdd.cs
index d088219..c98dc7e 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/FusedMultiplyAdd.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/FusedMultiplyAdd.cs
@@ -17,10 +17,7 @@ You should have received a copy of the GNU General Public License
     along with XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 
 namespace TMG.Utilities;
diff --git a/src/TMG-Framework/Utilities/VectorHelper/If.cs b/src/TMG-Framework/Utilities/VectorHelper/If.cs
index 85f0a22..37b3893 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/If.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/If.cs
@@ -17,9 +17,6 @@ You should have received a copy of the GNU General Public License
     along with XTMF2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 
 namespace TMG.Utilities
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Log.cs b/src/TMG-Framework/Utilities/VectorHelper/Log.cs
index 97b83b4..e762ca6 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Log.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Log.cs
@@ -18,9 +18,6 @@ You should have received a copy of the GNU General Public License
 */
 
 using System.Runtime.Intrinsics;
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics.X86;
 
 namespace TMG.Utilities;
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Multiply.cs b/src/TMG-Framework/Utilities/VectorHelper/Multiply.cs
index c12afee..0f93d47 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Multiply.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Multiply.cs
@@ -17,10 +17,7 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 
 namespace TMG.Utilities;
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Pow.cs b/src/TMG-Framework/Utilities/VectorHelper/Pow.cs
index 459cbbe..2e0d691 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Pow.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Pow.cs
@@ -16,17 +16,14 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 
 namespace TMG.Utilities;
 
 public static partial class VectorHelper
 {
-        /// <summary>
+    /// <summary>
     /// Raises each element of the lhs span to the power of rhs and stores the result in dest.
     /// </summary>
     /// <param name="dest">The destination span.</param>
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Subtract.cs b/src/TMG-Framework/Utilities/VectorHelper/Subtract.cs
index 440d14f..83e831f 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Subtract.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Subtract.cs
@@ -17,11 +17,7 @@ You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Threading.Tasks;
 
 namespace TMG.Utilities;
 
diff --git a/src/TMG-Framework/Utilities/VectorHelper/VectorHelper.cs b/src/TMG-Framework/Utilities/VectorHelper/VectorHelper.cs
index af049bd..7ae6aa1 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/VectorHelper.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/VectorHelper.cs
@@ -16,11 +16,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     You should have received a copy of the GNU General Public License
     along with XTMF.  If not, see <http://www.gnu.org/licenses/>.
 */
-using System;
-using System.Diagnostics.CodeAnalysis;
+
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;