From ee8ae5d3c39e7bf5a9210b9ed1f9175af83904ba Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Wed, 17 Jun 2026 11:36:28 -0400
Subject: [PATCH 01/10] Update CI2

---
 .github/workflows/BuildAndTest.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/BuildAndTest.yml b/.github/workflows/BuildAndTest.yml
index 5091006..fd69e8e 100644
--- a/.github/workflows/BuildAndTest.yml
+++ b/.github/workflows/BuildAndTest.yml
@@ -13,10 +13,8 @@ jobs:
     - uses: actions/checkout@v1
       with:
         repository: TravelModellingGroup/XTMF2
-        ref: origin/dev
-    - name: Build XTMF2  
+    - name: Build XTMF2
       run: |
-        cd "../XTMF2"
         dotnet build -c Release
     - uses: actions/checkout@v1    
     - name: Build TMG-Framework

From a3215c381e08ebf5b50f608035c0cc7949434c02 Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Wed, 17 Jun 2026 11:38:32 -0400
Subject: [PATCH 02/10] Update CI3

---
 .github/workflows/BuildAndTest.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/BuildAndTest.yml b/.github/workflows/BuildAndTest.yml
index fd69e8e..269be86 100644
--- a/.github/workflows/BuildAndTest.yml
+++ b/.github/workflows/BuildAndTest.yml
@@ -13,6 +13,7 @@ jobs:
     - uses: actions/checkout@v1
       with:
         repository: TravelModellingGroup/XTMF2
+        ref: refs/heads/dev
     - name: Build XTMF2
       run: |
         dotnet build -c Release

From 448be6cfa0444e09d243c549afa9448e7576d3f8 Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Wed, 17 Jun 2026 11:45:38 -0400
Subject: [PATCH 03/10] Debug CI

---
 .github/workflows/BuildAndTest.yml | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/BuildAndTest.yml b/.github/workflows/BuildAndTest.yml
index 269be86..e72a03f 100644
--- a/.github/workflows/BuildAndTest.yml
+++ b/.github/workflows/BuildAndTest.yml
@@ -13,8 +13,11 @@ jobs:
     - uses: actions/checkout@v1
       with:
         repository: TravelModellingGroup/XTMF2
-        ref: refs/heads/dev
-    - name: Build XTMF2
+        ref: tree/dev
+    - name: Debug
+      run: |
+        ls -hla .
+    - name: Build XTMF2  
       run: |
         dotnet build -c Release
     - uses: actions/checkout@v1    

From 974390a077a11b98e4ca6d76dbd13306d1e4fb37 Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Wed, 17 Jun 2026 11:47:18 -0400
Subject: [PATCH 04/10] Debug CI

---
 .github/workflows/BuildAndTest.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.github/workflows/BuildAndTest.yml b/.github/workflows/BuildAndTest.yml
index e72a03f..2b63cbe 100644
--- a/.github/workflows/BuildAndTest.yml
+++ b/.github/workflows/BuildAndTest.yml
@@ -13,7 +13,6 @@ jobs:
     - uses: actions/checkout@v1
       with:
         repository: TravelModellingGroup/XTMF2
-        ref: tree/dev
     - name: Debug
       run: |
         ls -hla .

From 0a252cc18f1a77a52d107eb1e62f7958e1b2c969 Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Wed, 17 Jun 2026 11:50:07 -0400
Subject: [PATCH 05/10] Debug CI

---
 .github/workflows/BuildAndTest.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/BuildAndTest.yml b/.github/workflows/BuildAndTest.yml
index 2b63cbe..c757557 100644
--- a/.github/workflows/BuildAndTest.yml
+++ b/.github/workflows/BuildAndTest.yml
@@ -13,6 +13,7 @@ jobs:
     - uses: actions/checkout@v1
       with:
         repository: TravelModellingGroup/XTMF2
+        ref: origin/dev
     - name: Debug
       run: |
         ls -hla .

From d8139aa651896918595bc244ec4edf44ba0933a2 Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Wed, 17 Jun 2026 11:51:47 -0400
Subject: [PATCH 06/10] Debug CI

---
 .github/workflows/BuildAndTest.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/BuildAndTest.yml b/.github/workflows/BuildAndTest.yml
index c757557..c7f281c 100644
--- a/.github/workflows/BuildAndTest.yml
+++ b/.github/workflows/BuildAndTest.yml
@@ -16,7 +16,7 @@ jobs:
         ref: origin/dev
     - name: Debug
       run: |
-        ls -hla .
+        ls .
     - name: Build XTMF2  
       run: |
         dotnet build -c Release

From c4c96eb9667520770dc76e17aed85256fb59c9a6 Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Wed, 17 Jun 2026 11:56:58 -0400
Subject: [PATCH 07/10] Debug CI

---
 .github/workflows/BuildAndTest.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/BuildAndTest.yml b/.github/workflows/BuildAndTest.yml
index c7f281c..c898dfc 100644
--- a/.github/workflows/BuildAndTest.yml
+++ b/.github/workflows/BuildAndTest.yml
@@ -14,17 +14,17 @@ jobs:
       with:
         repository: TravelModellingGroup/XTMF2
         ref: origin/dev
-    - name: Debug
-      run: |
-        ls .
     - name: Build XTMF2  
       run: |
+        cd "D:\a\TMG-Framework\XTMF2"
         dotnet build -c Release
     - uses: actions/checkout@v1    
     - name: Build TMG-Framework
       run: |
+        cd "D:\a\TMG-Framework\TMG-Framework"
         dotnet build -c Release
     - name: Unit Tests
       run: |
+        cd "D:\a\TMG-Framework\TMG-Framework"
         dotnet test -c Release
       

From 8cb04dcab8fbf2966bf5f19423fdae9fa49fd2c6 Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Wed, 17 Jun 2026 11:59:20 -0400
Subject: [PATCH 08/10] Debug CI

---
 .github/workflows/BuildAndTest.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/BuildAndTest.yml b/.github/workflows/BuildAndTest.yml
index c898dfc..1aa1d70 100644
--- a/.github/workflows/BuildAndTest.yml
+++ b/.github/workflows/BuildAndTest.yml
@@ -16,15 +16,15 @@ jobs:
         ref: origin/dev
     - name: Build XTMF2  
       run: |
-        cd "D:\a\TMG-Framework\XTMF2"
+        cd "XTMF2"
         dotnet build -c Release
     - uses: actions/checkout@v1    
     - name: Build TMG-Framework
       run: |
-        cd "D:\a\TMG-Framework\TMG-Framework"
+        cd "TMG-Framework"
         dotnet build -c Release
     - name: Unit Tests
       run: |
-        cd "D:\a\TMG-Framework\TMG-Framework"
+        cd "TMG-Framework"
         dotnet test -c Release
       

From b8973adc954464e7b2637d0c32df27bdb6bc981d Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Wed, 17 Jun 2026 12:02:09 -0400
Subject: [PATCH 09/10] Debug CI

---
 .github/workflows/BuildAndTest.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/BuildAndTest.yml b/.github/workflows/BuildAndTest.yml
index 1aa1d70..5091006 100644
--- a/.github/workflows/BuildAndTest.yml
+++ b/.github/workflows/BuildAndTest.yml
@@ -16,15 +16,13 @@ jobs:
         ref: origin/dev
     - name: Build XTMF2  
       run: |
-        cd "XTMF2"
+        cd "../XTMF2"
         dotnet build -c Release
     - uses: actions/checkout@v1    
     - name: Build TMG-Framework
       run: |
-        cd "TMG-Framework"
         dotnet build -c Release
     - name: Unit Tests
       run: |
-        cd "TMG-Framework"
         dotnet test -c Release
       

From 3033ef6f501f9c424ebdf5c30c0b786eb43794bf Mon Sep 17 00:00:00 2001
From: James Vaughan <James.Vaughan@utoronto.ca>
Date: Sun, 26 Jul 2026 21:09:15 -0400
Subject: [PATCH 10/10] Refactored Matrix and Vector to allow for memory pools

---
 .../Construct/ConstructTimePeriodFromTimes.cs |   4 +-
 src/TMG-Framework/Data/Categories.cs          |  11 +-
 src/TMG-Framework/Data/CategoryIndex.cs       |   2 +-
 src/TMG-Framework/Data/CategoryMap.cs         |  16 ++-
 src/TMG-Framework/Data/Matrix.cs              |  90 +++++++++++---
 src/TMG-Framework/Data/Range.cs               |   2 +-
 src/TMG-Framework/Data/RangeSet.cs            |  11 +-
 src/TMG-Framework/Data/RangeSetSet.cs         |  15 ++-
 src/TMG-Framework/Data/Time.cs                |  10 +-
 src/TMG-Framework/Data/Vector.cs              |  59 ++++++++-
 src/TMG-Framework/FileOperations/CopyFile.cs  |  10 +-
 .../FileOperations/DeleteFile.cs              |   2 +-
 .../Loading/LoadCategoriesFromCSV.cs          |  16 ++-
 .../LoadCategoryMapFromThirdNormalizedCSV.cs  |  19 ++-
 .../Loading/LoadMatrixFromCSVMatrix.cs        |   4 +-
 .../LoadMatrixFromCSVThirdNormalized.cs       |  10 +-
 .../Loading/LoadMatrixFromMTX.cs              |   4 +-
 .../Loading/LoadVectorFromCSV.cs              |   6 +-
 src/TMG-Framework/Processing/AST/ASTNode.cs   |  16 ++-
 src/TMG-Framework/Processing/AST/Add.cs       |  29 +++--
 .../Processing/AST/CompareAnd.cs              |  16 +--
 .../Processing/AST/CompareEqual.cs            |  24 ++--
 .../Processing/AST/CompareGreaterThan.cs      |  24 ++--
 .../AST/CompareGreaterThanOrEqual.cs          |  24 ++--
 .../Processing/AST/CompareNotEquals.cs        |  24 ++--
 src/TMG-Framework/Processing/AST/CompareOr.cs |  16 +--
 src/TMG-Framework/Processing/AST/Compiler.cs  |   6 +-
 src/TMG-Framework/Processing/AST/Divide.cs    |  11 +-
 src/TMG-Framework/Processing/AST/Exponent.cs  |   4 +-
 .../Processing/AST/Expression.cs              | 108 +++++++++++++----
 .../Processing/AST/FunctionCall.cs            |  62 +++++-----
 .../Processing/AST/FusedMultiplyAdd.cs        |  45 ++++---
 src/TMG-Framework/Processing/AST/Multiply.cs  |  10 +-
 src/TMG-Framework/Processing/AST/Negate.cs    |  19 ++-
 src/TMG-Framework/Processing/AST/Subtract.cs  |   8 +-
 .../Processing/AppendMatrixValueToCSV.cs      |  12 +-
 .../Processing/Evaluate2DGravityModel.cs      |  45 +++----
 .../Processing/EvaluateMatrix.cs              |  12 +-
 .../Processing/EvaluateScalar.cs              |   8 +-
 .../Processing/EvaluateVector.cs              |   8 +-
 .../ExecutePipelineInOrderParallel.cs         |   4 +-
 .../Processing/IntegerizeMatrix.cs            |   6 +-
 src/TMG-Framework/Saving/SaveMatrixAsCSV.cs   |   8 +-
 src/TMG-Framework/Saving/SaveMatrixAsMTX.cs   |   2 +-
 src/TMG-Framework/Saving/SaveVectorAsCSV.cs   |   4 +-
 src/TMG-Framework/Select/SelectGivenTime.cs   |  10 +-
 src/TMG-Framework/TMG-Framework.csproj        |   1 +
 src/TMG-Framework/Utilities/CSVReader.cs      |   2 +-
 .../Utilities/ExceptionHelper.cs              |  13 ++
 .../Utilities/VectorHelper/Add.cs             |   6 +-
 .../VectorHelper/Conditions/FlagAnd.cs        |  11 ++
 .../VectorHelper/Conditions/FlagIfEquals.cs   |  16 ++-
 .../Conditions/FlagIfGreaterThan.cs           |  56 +++++++++
 .../Conditions/FlagIfGreaterThanOrEqual.cs    |  57 ++++++++-
 .../VectorHelper/Conditions/FlagIfLessThan.cs |  56 +++++++++
 .../Conditions/FlagIfLessThanOrEqual.cs       |  49 ++++++++
 .../Conditions/FlagIfNotEquals.cs             |  14 ++-
 .../VectorHelper/Conditions/FlagOr.cs         |  13 +-
 .../Utilities/VectorHelper/Multiply.cs        |  12 ++
 .../Utilities/VectorHelper/VectorHelper.cs    |  96 +++++++++++++++
 .../ArbitaryParameterParser.cs                |  14 +--
 .../TMG-Framework.Test/Data/CategoriesTest.cs |   7 +-
 .../Data/CategoryMapTest.cs                   |  38 ++++--
 tests/TMG-Framework.Test/Data/MatrixTest.cs   |   8 +-
 tests/TMG-Framework.Test/Data/RangeTest.cs    |  10 +-
 tests/TMG-Framework.Test/Data/VectorTest.cs   |   8 +-
 ...stLoadCategoryMapFromThirdNormalizedCSV.cs |  53 ++++++---
 .../Loading/TestLoadVector.cs                 |   2 +-
 .../Processing/TestEvaluateMatrix.cs          |   2 +-
 .../Processing/TestEvaluateScalar.cs          |   2 +-
 .../Processing/TestEvaluateVector.cs          |   2 +-
 .../Processing/TestIntegerizeMatrix.cs        |  36 ++++--
 .../Saving/TestSaveMatrixAsCSV.cs             |   4 +-
 .../Saving/TestSaveMatrixAsMTX.cs             |   2 +-
 .../Saving/TestSaveVectorAsCSV.cs             |   6 +-
 .../TMG-Framework.Test.csproj                 |   1 +
 tests/TMG-Framework.Test/Utilities/Helper.cs  |   8 +-
 .../TMG-Framework.Test/Utilities/MapHelper.cs |   8 +-
 .../Utilities/MatrixHelper.cs                 |  11 +-
 .../Utilities/TestCompiler.cs                 | 112 ++++++++++--------
 80 files changed, 1160 insertions(+), 432 deletions(-)

diff --git a/src/TMG-Framework/Construct/ConstructTimePeriodFromTimes.cs b/src/TMG-Framework/Construct/ConstructTimePeriodFromTimes.cs
index 001b4ca..ec91489 100644
--- a/src/TMG-Framework/Construct/ConstructTimePeriodFromTimes.cs
+++ b/src/TMG-Framework/Construct/ConstructTimePeriodFromTimes.cs
@@ -28,10 +28,10 @@ namespace TMG.Construct
     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;
+        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;
+        public IFunction<Time> EndTime = null!;
 
         public override TimePeriod Invoke()
         {
diff --git a/src/TMG-Framework/Data/Categories.cs b/src/TMG-Framework/Data/Categories.cs
index 138aec4..a7775b1 100644
--- a/src/TMG-Framework/Data/Categories.cs
+++ b/src/TMG-Framework/Data/Categories.cs
@@ -22,6 +22,7 @@ You should have received a copy of the GNU General Public License
 using System.Linq;
 using static TMG.Utilities.ExceptionHelper;
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace TMG
 {
@@ -46,7 +47,9 @@ public sealed class Categories : IEnumerable<int>
         /// <param name="elements"></param>
         /// <param name="error"></param>
         /// <returns></returns>
-        public static Categories CreateCategories(List<int> elements, ref string error)
+        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();
@@ -55,10 +58,12 @@ public static Categories CreateCategories(List<int> elements, ref string error)
                 if(elements[i - 1] == elements[i])
                 {
                     error = $"Found a duplicate category {elements[i]}!";
-                    return null;
+                    categories = null;
+                    return false;
                 }
             }
-            return new Categories(elements);
+            categories = new Categories(elements);
+            return true;
         }
 
         /// <summary>
diff --git a/src/TMG-Framework/Data/CategoryIndex.cs b/src/TMG-Framework/Data/CategoryIndex.cs
index a730a0c..f500047 100644
--- a/src/TMG-Framework/Data/CategoryIndex.cs
+++ b/src/TMG-Framework/Data/CategoryIndex.cs
@@ -75,7 +75,7 @@ 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)
             {
diff --git a/src/TMG-Framework/Data/CategoryMap.cs b/src/TMG-Framework/Data/CategoryMap.cs
index 453e145..cd96643 100644
--- a/src/TMG-Framework/Data/CategoryMap.cs
+++ b/src/TMG-Framework/Data/CategoryMap.cs
@@ -18,6 +18,7 @@ You should have received a copy of the GNU General Public License
 */
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text;
 using static TMG.Utilities.ExceptionHelper;
@@ -46,7 +47,9 @@ 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, out CategoryMap map, ref string error)
+            List<(int originFlatIndex, int destinationFlatIndex)> baseToDestination, 
+            [NotNullWhen(true) ] out CategoryMap? map,
+            [NotNullWhen(false)] ref string? error)
         {
             if (baseCategories == null)
             {
@@ -95,7 +98,7 @@ private CategoryMap(Categories baseCategories, Categories destinationCategories,
             _baseToDestination = baseToDestination;
         }
 
-        private static bool FailWith(ref string error, string message)
+        private static bool FailWith([NotNullWhen(false)] ref string? error, string message)
         {
             error = message;
             return false;
@@ -106,7 +109,8 @@ private static bool FailWith(ref string error, string message)
         /// </summary>
         /// <param name="baseToDestination"></param>
         private static bool ValidateMapping(Categories baseCategories, Categories destinationCategories,
-            List<(int originFlatIndex, int destinationFlatIndex)> baseToDestination, ref string error)
+            List<(int originFlatIndex, int destinationFlatIndex)> baseToDestination, 
+            [NotNullWhen(false)] ref string? error)
         {
             if (baseCategories == null)
             {
@@ -138,10 +142,12 @@ private static bool ValidateMapping(Categories baseCategories, Categories destin
         /// <param name="ret"></param>
         /// <param name="error"></param>
         /// <returns></returns>
-        public bool AggregateToDestination(Vector baseVector, out Vector ret, ref string error)
+        public bool AggregateToDestination(Vector baseVector, 
+            [NotNullWhen(true)] out Vector? ret,
+            [NotNullWhen(false)] ref string? error)
         {
             ret = null;
-            if (baseVector == null)
+            if (baseVector is null)
             {
                 return FailWith(ref error, "baseVector was null!");
             }
diff --git a/src/TMG-Framework/Data/Matrix.cs b/src/TMG-Framework/Data/Matrix.cs
index 12332b5..bbe6923 100644
--- a/src/TMG-Framework/Data/Matrix.cs
+++ b/src/TMG-Framework/Data/Matrix.cs
@@ -17,9 +17,12 @@ 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
@@ -27,7 +30,7 @@ namespace TMG
     /// <summary>
     /// A 2D representation with categories for rows and columns
     /// </summary>
-    public sealed class Matrix
+    public sealed class Matrix : IDisposable
     {
         /// <summary>
         /// The categories for the rows.
@@ -42,39 +45,75 @@ public sealed class Matrix
         /// <summary>
         /// The backend storage for the matrix
         /// </summary>
-        public float[] Data { get; }
+        public Span<float> Data => _backingMemory is null ? ThrowAlreadyDisposed() : _backingMemory.Value.Span;
+
+        [DoesNotReturn]
+        private Span<float> ThrowAlreadyDisposed()
+        {
+            throw new ObjectDisposedException(nameof(Matrix));
+        }
+
+        private Memory<float>? _backingMemory;
 
         /// <summary>
         /// Used as a quick lookup for the number of columns per row.
         /// </summary>
         private readonly int _rowSpan;
 
+        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>
+        /// 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>
         /// 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)
+        /// <param name="allocator">The memory pool to use for the matrix data.</param>
+        public Matrix(Categories rowCategories, Categories columnCategories, MemoryPool<float>? allocator)
         {
-            RowCategories = rowCategories ?? throw new ArgumentNullException(nameof(rowCategories));
-            ColumnCategories = columnCategories ?? throw new ArgumentNullException(nameof(columnCategories));
+            RowCategories = rowCategories ?? ThrowParameterNull<Categories>(nameof(rowCategories));
+            ColumnCategories = columnCategories ?? ThrowParameterNull<Categories>(nameof(columnCategories));
             _rowSpan = ColumnCategories.Count;
-            Data = new float[RowCategories.Count * 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)
+        public Matrix(Vector vector) : this(vector, null) { }
+
+        public Matrix(Vector vector, MemoryPool<float>? allocator)
         {
-            if (vector == null)
+            if (vector is null)
             {
                 ThrowParameterNull(nameof(vector));
             }
             ColumnCategories = RowCategories = vector.Categories;
             _rowSpan = ColumnCategories.Count;
-            Data = new float[RowCategories.Count * ColumnCategories.Count];
+            var size = RowCategories.Count * ColumnCategories.Count;
+            _backingMemory = allocator is null ?
+                new float[size].AsMemory() :
+                (_allocator = allocator.Rent(size)).Memory[..size];
         }
 
         /// <summary>
@@ -82,16 +121,26 @@ public Matrix(Vector vector)
         /// matrix.
         /// </summary>
         /// <param name="matrix">The matrix to copy the dimensions from.</param>
-        public Matrix(Matrix matrix)
+        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 == null)
+            if (matrix is null)
             {
                 ThrowParameterNull(nameof(matrix));
             }
             RowCategories = matrix.RowCategories;
             ColumnCategories = matrix.ColumnCategories;
             _rowSpan = matrix._rowSpan;
-            Data = new float[RowCategories.Count * ColumnCategories.Count];
+            var size = RowCategories.Count * ColumnCategories.Count;
+            _backingMemory = allocator is null ?
+                new float[size].AsMemory() :
+                (_allocator = allocator.Rent(size)).Memory[..size];
         }
 
         /// <summary>
@@ -153,7 +202,7 @@ public Span<float> GetRow(int flatRowIndex)
                 ThrowOutOfRangeException(nameof(flatRowIndex));
             }
             flatRowIndex = GetFlatRowIndex(flatRowIndex);
-            return new Span<float>(Data, flatRowIndex, _rowSpan);
+            return Data.Slice(flatRowIndex, _rowSpan);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
@@ -179,7 +228,7 @@ public ref float GetFromSparseIndexes(int rowIndex, int columnIndex)
         public Matrix Clone()
         {
             var ret = new Matrix(this);
-            Array.Copy(Data, ret.Data, Data.Length);
+            Data.CopyTo(ret.Data);
             return ret;
         }
 
@@ -194,5 +243,18 @@ 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 90cf0b4..a24e783 100644
--- a/src/TMG-Framework/Data/Range.cs
+++ b/src/TMG-Framework/Data/Range.cs
@@ -42,7 +42,7 @@ public Range(int start, int stop)
             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)
             {
diff --git a/src/TMG-Framework/Data/RangeSet.cs b/src/TMG-Framework/Data/RangeSet.cs
index fd8d7ee..1d5aaee 100644
--- a/src/TMG-Framework/Data/RangeSet.cs
+++ b/src/TMG-Framework/Data/RangeSet.cs
@@ -18,6 +18,7 @@ You should have received a copy of the GNU General Public License
 */
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Text;
 using static System.Char;
 using static System.String;
@@ -72,13 +73,15 @@ public Range this[int index]
             set => SetRanges[index] = value;
         }
 
-        public static bool TryParse(string rangeString, out RangeSet output)
+        public static bool TryParse(string rangeString, [NotNullWhen(true)] out RangeSet? output)
         {
-            string error = null;
+            string? error = null;
             return TryParse(ref error, rangeString, out output);
         }
 
-        public static bool TryParse(ref string error, string rangeString, out RangeSet 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;
@@ -232,7 +235,7 @@ public void CopyTo(Range[] array, int arrayIndex)
             }
         }
 
-        public override bool Equals(object obj)
+        public override bool Equals(object? obj)
         {
             var other = obj as RangeSet;
             if (other?.Count != Count) return false;
diff --git a/src/TMG-Framework/Data/RangeSetSet.cs b/src/TMG-Framework/Data/RangeSetSet.cs
index 09250c8..c99094a 100644
--- a/src/TMG-Framework/Data/RangeSetSet.cs
+++ b/src/TMG-Framework/Data/RangeSetSet.cs
@@ -18,6 +18,7 @@ You should have received a copy of the GNU General Public License
 */
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Text;
 using static TMG.Utilities.ExceptionHelper;
 
@@ -42,13 +43,15 @@ public RangeSet this[int index]
             set => RangeSets[index] = value;
         }
 
-        public static bool TryParse(string rangeString, out RangeSetSet output)
+        public static bool TryParse(string rangeString, [NotNullWhen(true)] out RangeSetSet? output)
         {
-            string error = null;
+            string? error = null;
             return TryParse(ref error, rangeString, out output);
         }
 
-        public static bool TryParse(ref string error, string rangeString, out RangeSetSet output)
+        public static bool TryParse([NotNullWhen(false)] ref string? error,
+            string rangeString,
+            [NotNullWhen(true)] out RangeSetSet? output)
         {
             if (rangeString == null)
             {
@@ -68,7 +71,7 @@ public static bool TryParse(ref string error, string rangeString, out RangeSetSe
                     {
                         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;
                             }
@@ -88,7 +91,7 @@ public static bool TryParse(ref string error, string rangeString, out RangeSetSe
             // in case it is a set of 1 element
             if (rangeSets.Count == 0)
             {
-                if (RangeSet.TryParse(ref error, rangeString, out RangeSet temp))
+                if (!RangeSet.TryParse(ref error, rangeString, out RangeSet? temp))
                 {
                     return false;
                 }
@@ -128,7 +131,7 @@ public void CopyTo(RangeSet[] array, int arrayIndex)
             }
         }
 
-        public override bool Equals(object obj)
+        public override bool Equals(object? obj)
         {
             var other = obj as RangeSetSet;
             if (Count != other?.Count) return false;
diff --git a/src/TMG-Framework/Data/Time.cs b/src/TMG-Framework/Data/Time.cs
index 6146da9..1fe76a6 100644
--- a/src/TMG-Framework/Data/Time.cs
+++ b/src/TMG-Framework/Data/Time.cs
@@ -17,6 +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.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using XTMF2;
 namespace TMG
@@ -259,15 +260,17 @@ public static bool Intersection(Time start1, Time end1, Time start2, Time end2,
 
         public static bool TryParse(string timeString, out Time time)
         {
-            string error = null;
+            string? error = null;
             return TryParse(ref error, timeString, out time);
         }
 
-        public static bool TryParse(ref string error, string timeString, out Time time)
+        public static bool TryParse(
+            [NotNullWhen(false)]ref string? error, string timeString, out Time time)
         {
             time = new Time();
             if (String.IsNullOrWhiteSpace(timeString))
             {
+                error = "Time string is null or whitespace!";
                 return false;
             }
             int seconds = 0, minutes = 0, hours = 0;
@@ -454,6 +457,7 @@ public static bool TryParse(ref string error, string timeString, out Time time)
                         }
                         break;
                     default:
+                        error = "Unexpected state found!";
                         return false;
                 }
             }
@@ -496,7 +500,7 @@ public int CompareTo(Time other)
             return _internalTime < other._internalTime ? -1 : (_internalTime == other._internalTime ? 0 : 1);
         }
 
-        public override bool Equals(object obj)
+        public override bool Equals(object? obj)
         {
             if (obj is Time other)
             {
diff --git a/src/TMG-Framework/Data/Vector.cs b/src/TMG-Framework/Data/Vector.cs
index cb3d6e7..10d753b 100644
--- a/src/TMG-Framework/Data/Vector.cs
+++ b/src/TMG-Framework/Data/Vector.cs
@@ -17,6 +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 System;
+using System.Buffers;
+using System.Threading;
 using static TMG.Utilities.ExceptionHelper;
 
 namespace TMG
@@ -24,7 +26,7 @@ namespace TMG
     /// <summary>
     /// Represents a single dimension floating point data storage with a given shape.
     /// </summary>
-    public sealed class Vector
+    public sealed class Vector : IDisposable
     {
         /// <summary>
         /// The categories that shape this vector.
@@ -34,20 +36,51 @@ public sealed class Vector
         /// <summary>
         /// The backing data for this vector.
         /// </summary>
-        public float[] Data { get; }
+        public Span<float> Data => _backingMemory is null ? ThrowAlreadyDisposed() : _backingMemory.Value.Span;
+
+        private Span<float> ThrowAlreadyDisposed()
+        {
+            throw new ObjectDisposedException(nameof(Vector));
+        }
+
+        public void Dispose()
+        {
+            _backingMemory = default;
+            Thread.MemoryBarrier();
+            _allocator?.Dispose();
+            _allocator = null;
+        }
+
+        ~Vector()
+        {
+            Dispose();
+        }
+
+        private Memory<float>? _backingMemory;
+
+        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)
+        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)
         {
             if(categories == null)
             {
                 ThrowParameterNull(nameof(categories));
             }
             Categories = categories;
-            Data = new float[Categories.Count];
+            _allocator = allocator?.Rent(Categories.Count);
+            _backingMemory = _allocator?.Memory ?? new float[Categories.Count];
         }
 
         /// <summary>
@@ -55,14 +88,22 @@ public Vector(Categories categories)
         /// 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)
+        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)
         {
             if(vector == null)
             {
                 ThrowParameterNull(nameof(vector));
             }
             Categories = vector.Categories;
-            Data = new float[Categories.Count];
+            _allocator = allocator?.Rent(Categories.Count);
+            _backingMemory = _allocator?.Memory ?? new float[Categories.Count];
         }
 
         public float this[CategoryIndex sparseIndex]
@@ -82,5 +123,11 @@ public float this[CategoryIndex sparseIndex]
                 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;
     }
 }
diff --git a/src/TMG-Framework/FileOperations/CopyFile.cs b/src/TMG-Framework/FileOperations/CopyFile.cs
index b26d043..92e40a5 100644
--- a/src/TMG-Framework/FileOperations/CopyFile.cs
+++ b/src/TMG-Framework/FileOperations/CopyFile.cs
@@ -29,13 +29,13 @@ namespace TMG.FileOperations
     public class CopyFile : BaseAction
     {
         [Parameter(DefaultValue = "", Name = "Origin", Index = 0, Description = "The path to the file/directory to copy.")]
-        public IFunction<string> Origin;
+        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;
+        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;
+        public IFunction<bool> Move = null!;
 
         public override void Invoke()
         {
@@ -66,7 +66,9 @@ public override void Invoke()
                 }
                 else
                 {
-                    oInfo.CopyTo(dInfo.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);
                 }
             }
         }
diff --git a/src/TMG-Framework/FileOperations/DeleteFile.cs b/src/TMG-Framework/FileOperations/DeleteFile.cs
index b0c5883..8390d2a 100644
--- a/src/TMG-Framework/FileOperations/DeleteFile.cs
+++ b/src/TMG-Framework/FileOperations/DeleteFile.cs
@@ -29,7 +29,7 @@ namespace TMG.FileOperations
     public sealed class DeleteFile : BaseAction
     {
         [Parameter(DefaultValue = "", Name = "To Delete", Index = 0, Description = "The path to delete.")]
-        public IFunction<string> ToDelete;
+        public IFunction<string> ToDelete = null!;
 
         public override void Invoke()
         {
diff --git a/src/TMG-Framework/Loading/LoadCategoriesFromCSV.cs b/src/TMG-Framework/Loading/LoadCategoriesFromCSV.cs
index e8ab0ae..d4489e1 100644
--- a/src/TMG-Framework/Loading/LoadCategoriesFromCSV.cs
+++ b/src/TMG-Framework/Loading/LoadCategoriesFromCSV.cs
@@ -46,9 +46,11 @@ public override Categories Invoke(ReadStream stream)
         {
             throw new XTMFRuntimeException(this, "Unable to create Categories object with no contained categories.");
         }
-        string error = null;
-        var ret = Categories.CreateCategories(record, ref error) 
-            ?? throw new XTMFRuntimeException(this, error);
+        string? error = null;
+        if (!Categories.CreateCategories(record, out var ret, ref error))
+        {
+            throw new XTMFRuntimeException(this, error);
+        }
         return ret;
     }
 }
@@ -79,9 +81,11 @@ public override Categories Invoke()
         {
             throw new XTMFRuntimeException(this, "Unable to create Categories object with no contained categories.");
         }
-        string error = null;
-        var ret = Categories.CreateCategories(record, ref error)
-            ?? throw new XTMFRuntimeException(this, error);
+        string? error = null;
+        if (!Categories.CreateCategories(record, out var ret, ref error))
+        {
+            throw new XTMFRuntimeException(this, error);
+        }
         return ret;
     }
 }
\ No newline at end of file
diff --git a/src/TMG-Framework/Loading/LoadCategoryMapFromThirdNormalizedCSV.cs b/src/TMG-Framework/Loading/LoadCategoryMapFromThirdNormalizedCSV.cs
index 66d3aac..8654563 100644
--- a/src/TMG-Framework/Loading/LoadCategoryMapFromThirdNormalizedCSV.cs
+++ b/src/TMG-Framework/Loading/LoadCategoryMapFromThirdNormalizedCSV.cs
@@ -32,19 +32,19 @@ namespace TMG.Loading
     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;
+        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;
+        public IFunction<Categories>? DestinationCategories;
 
         [SubModule(Index = 2, Required = true, Name = "CSV Stream", Description = "The stream that we will read from.")]
-        public IFunction<ReadStream> CSVStream;
+        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;
+        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;
+        public IFunction<int> DestinationColumn = null!;
 
         public override CategoryMap Invoke()
         {
@@ -88,13 +88,12 @@ private CategoryMap LoadWithStrictDestinations(Categories destinationCategories)
         /// <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;
-            var ret = Categories.CreateCategories(records
+            string? error = null;
+            if(!Categories.CreateCategories(records
                 .Select(r => r.destinationSparseIndex)
                 .Distinct()
                 .OrderBy(r => r)
-                .ToList(), ref error);
-            if(ret is null)
+                .ToList(), out var ret,ref error))
             {
                 throw new XTMFRuntimeException(this, error);
             }
@@ -126,7 +125,7 @@ private CategoryMap Load(List<(int baseSparseIndex, int destinationSparseIndex)>
                     }
                     return ret;
                 }).ToList();
-            string error = null;
+            string? error = null;
             if (!CategoryMap.CreateCategoryMap(baseCategories, destinationCategories, flatRecords, out var map, ref error))
             {
                 throw new XTMFRuntimeException(this, error);
diff --git a/src/TMG-Framework/Loading/LoadMatrixFromCSVMatrix.cs b/src/TMG-Framework/Loading/LoadMatrixFromCSVMatrix.cs
index 4f308b9..28ed1f5 100644
--- a/src/TMG-Framework/Loading/LoadMatrixFromCSVMatrix.cs
+++ b/src/TMG-Framework/Loading/LoadMatrixFromCSVMatrix.cs
@@ -30,10 +30,10 @@ namespace TMG.Loading
     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;
+        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;
+        public IFunction<Categories> ColumnCategories = null!;
 
         public override Matrix Invoke(ReadStream stream)
         {
diff --git a/src/TMG-Framework/Loading/LoadMatrixFromCSVThirdNormalized.cs b/src/TMG-Framework/Loading/LoadMatrixFromCSVThirdNormalized.cs
index 222e427..147515a 100644
--- a/src/TMG-Framework/Loading/LoadMatrixFromCSVThirdNormalized.cs
+++ b/src/TMG-Framework/Loading/LoadMatrixFromCSVThirdNormalized.cs
@@ -29,19 +29,19 @@ namespace TMG.Loading
     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;
+        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;
+        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;
+        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;
+        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;
+        public IFunction<int> DataColumn = null!;
 
         public override Matrix Invoke(ReadStream stream)
         {
diff --git a/src/TMG-Framework/Loading/LoadMatrixFromMTX.cs b/src/TMG-Framework/Loading/LoadMatrixFromMTX.cs
index 20818b0..243d62f 100644
--- a/src/TMG-Framework/Loading/LoadMatrixFromMTX.cs
+++ b/src/TMG-Framework/Loading/LoadMatrixFromMTX.cs
@@ -31,7 +31,7 @@ namespace TMG.Loading
     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;
+        public IFunction<Categories> Categories = null!;
 
         private const uint MagicNumber = 0xC4D4F1B2;
 
@@ -77,7 +77,7 @@ public override Matrix Invoke(ReadStream context)
                 var soFar = 0;
                 while (soFar < dataSize)
                 {
-                    var amount = reader.Read(MemoryMarshal.Cast<float,byte>(new Span<float>(data))[soFar..dataSize]);
+                    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!");
diff --git a/src/TMG-Framework/Loading/LoadVectorFromCSV.cs b/src/TMG-Framework/Loading/LoadVectorFromCSV.cs
index be7e775..50c13df 100644
--- a/src/TMG-Framework/Loading/LoadVectorFromCSV.cs
+++ b/src/TMG-Framework/Loading/LoadVectorFromCSV.cs
@@ -29,13 +29,13 @@ namespace TMG.Loading
     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;
+        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;
+        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;
+        public IFunction<int> DataColumn = null!;
 
         public override Vector Invoke(ReadStream stream)
         {
diff --git a/src/TMG-Framework/Processing/AST/ASTNode.cs b/src/TMG-Framework/Processing/AST/ASTNode.cs
index 4a1fb84..f1e7b84 100644
--- a/src/TMG-Framework/Processing/AST/ASTNode.cs
+++ b/src/TMG-Framework/Processing/AST/ASTNode.cs
@@ -17,6 +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.Diagnostics.CodeAnalysis;
 using XTMF2;
 using TMG.Utilities;
 
@@ -36,18 +37,20 @@ protected AstNode(int start)
 
         public abstract ComputationResult Evaluate(IModule[] dataSources);
 
-        internal abstract bool OptimizeAst(ref Expression ex, ref string error);
+        internal abstract bool OptimizeAst(
+            ref Expression ex,
+            [NotNullWhen(false)] ref string? error);
     }
 
     public class ComputationResult
     {
-        public bool IsOdResult => OdData != null;
+        public bool IsOdResult => OdData is not null;
 
-        public bool IsVectorResult => VectorData != null;
+        public bool IsVectorResult => VectorData is not null;
 
-        public bool Error => ErrorMessage != 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; }
 
@@ -68,6 +71,8 @@ public enum VectorDirection
         
         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.
+#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;
@@ -98,5 +103,6 @@ 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 1e824c7..e1a915f 100644
--- a/src/TMG-Framework/Processing/AST/Add.cs
+++ b/src/TMG-Framework/Processing/AST/Add.cs
@@ -18,6 +18,7 @@ You should have received a copy of the GNU General Public License
 */
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using TMG.Utilities;
 
 namespace TMG.Frameworks.Data.Processing.AST
@@ -29,38 +30,46 @@ public Add(int start) : base(start)
 
         }
 
-        internal override bool OptimizeAst(ref Expression ex, ref string error)
+        internal override bool OptimizeAst(
+            ref Expression ex,
+            [NotNullWhen(false)] ref string? error)
         {
             if(!base.OptimizeAst(ref ex, ref error))
             {
                 return false;
             }
-            if(!OptimizeFusedMultiplyAdd(ref ex)
-                || !OptimizeLiterals(ref ex))
+            if(!OptimizeFusedMultiplyAdd(ref ex, ref error)
+                || !OptimizeLiterals(ref ex, ref error))
             {
+
                 return false;
             }
             return true;
         }
 
-        private bool OptimizeLiterals(ref Expression ex)
+        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)
             {
                 ex = new Literal(Start, lhs.Value + rhs.Value);
+                return true;
             }
             return true;
         }
 
-        private bool OptimizeFusedMultiplyAdd(ref Expression ex)
+        private bool OptimizeFusedMultiplyAdd(
+            ref Expression ex,
+            [NotNullWhen(false)] ref string? error)
         {
             var lhsMul = Lhs as Multiply;
             var rhsMul = Rhs as Multiply;
-            if (lhsMul != null)
+            if (lhsMul is not null)
             {
-                ex = new FusedMultiplyAdd(Start, Rhs.Start)
+                ex = new FusedMultiplyAdd(Start, Rhs?.Start ?? -1)
                 {
                     MulLhs = lhsMul.Lhs,
                     MulRhs = lhsMul.Rhs,
@@ -69,7 +78,7 @@ private bool OptimizeFusedMultiplyAdd(ref Expression ex)
             }
             else if (rhsMul != null)
             {
-                ex = new FusedMultiplyAdd(Start, Lhs.Start)
+                ex = new FusedMultiplyAdd(Start, Lhs?.Start ?? -1)
                 { 
                     MulLhs = rhsMul.Lhs,
                     MulRhs = rhsMul.Rhs,
@@ -155,7 +164,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -185,7 +194,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
diff --git a/src/TMG-Framework/Processing/AST/CompareAnd.cs b/src/TMG-Framework/Processing/AST/CompareAnd.cs
index 8325b48..683b607 100644
--- a/src/TMG-Framework/Processing/AST/CompareAnd.cs
+++ b/src/TMG-Framework/Processing/AST/CompareAnd.cs
@@ -80,7 +80,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                     if (lhs.IsVectorResult && rhs.IsVectorResult)
                     {
                         var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FlagAnd(retMatrix.Data, 0, lhs.VectorData.Data, 0, rhs.VectorData.Data, 0, retMatrix.Data.Length);
+                        VectorHelper.FlagAnd(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
                         return new ComputationResult(retMatrix, true, lhs.Direction);
                     }
                     else if (lhs.IsVectorResult)
@@ -94,19 +94,19 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagAnd(retMatrix.Data, i * rowSize, flatLhs[i], flatRhs, 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.Data, i * rowSize, flatLhs, 0, flatRhs, i * rowSize, rowSize);
+                                VectorHelper.FlagAnd(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
                             }
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -121,19 +121,19 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagAnd(retMatrix.Data, i * rowSize, flatRhs[i], flatLhs, i * rowSize, rowSize);
+                                VectorHelper.FlagAnd(retMatrix.GetRow(i), flatRhs[i], flatLhs.Slice(i * rowSize, rowSize));
                             }
                         }
                         else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagAnd(retMatrix.Data, i * rowSize, flatRhs, 0, flatLhs, i * rowSize, rowSize);
+                                VectorHelper.FlagAnd(retMatrix.GetRow(i), flatRhs, flatLhs.Slice(i * rowSize, rowSize));
                             }
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -141,7 +141,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 else
                 {
                     var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.FlagAnd(retMatrix.Data, 0, lhs.OdData.Data, 0, rhs.OdData.Data, 0, retMatrix.Data.Length);
+                    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 ac09729..6d265d8 100644
--- a/src/TMG-Framework/Processing/AST/CompareEqual.cs
+++ b/src/TMG-Framework/Processing/AST/CompareEqual.cs
@@ -45,13 +45,13 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 {
                     var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
                     var flat = retVector.Data;
-                    VectorHelper.FlagIfEquals(flat, 0, lhs.LiteralValue, rhs.VectorData.Data, 0, flat.Length);
+                    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, 0, lhs.LiteralValue, rhs.OdData.Data, 0, retMatrix.Data.Length);
+                    VectorHelper.FlagIfEquals(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
                     return new ComputationResult(retMatrix, true);
                 }
             }
@@ -61,14 +61,14 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 {
                     var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
                     var flat = retVector.Data;
-                    VectorHelper.FlagIfEquals(flat, 0, lhs.VectorData.Data, 0, rhs.LiteralValue, flat.Length);
+                    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, 0, lhs.OdData.Data, 0, rhs.LiteralValue, retMatrix.Data.Length);
+                    VectorHelper.FlagIfEquals(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
                     return new ComputationResult(retMatrix, true);
                 }
             }
@@ -79,7 +79,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                     if (lhs.IsVectorResult && rhs.IsVectorResult)
                     {
                         var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FlagIfEquals(retMatrix.Data, 0, lhs.VectorData.Data, 0, rhs.VectorData.Data, 0, retMatrix.Data.Length);
+                        VectorHelper.FlagIfEquals(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
                         return new ComputationResult(retMatrix, true, lhs.Direction);
                     }
                     else if (lhs.IsVectorResult)
@@ -93,19 +93,19 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagIfEquals(retMatrix.Data, i * rowSize, flatLhs[i], flatRhs, 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, i * rowSize, flatLhs, 0, flatRhs, i * rowSize, rowSize);
+                                VectorHelper.FlagIfEquals(retMatrix.Data.Slice(i * rowSize, rowSize), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
                             }
                         }
                         else
                         {
-                            return new ComputationResult("Unable to compare equal a vector without directionality to a matrix starting at position " + Lhs.Start + "!");
+                            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);
                     }
@@ -120,19 +120,19 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagIfEquals(retMatrix.Data, i * rowSize, flatLhs, i * rowSize, flatRhs[i], rowSize);
+                                VectorHelper.FlagIfEquals(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs[i]);
                             }
                         }
                         else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagIfEquals(retMatrix.Data, i * rowSize, flatLhs, i * rowSize, flatRhs, 0, rowSize);
+                                VectorHelper.FlagIfEquals(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs);
                             }
                         }
                         else
                         {
-                            return new ComputationResult("Unable to compare equal a vector without directionality to a matrix starting at position " + Lhs.Start + "!");
+                            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);
                     }
@@ -140,7 +140,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 else
                 {
                     var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.FlagIfEquals(retMatrix.Data, 0, lhs.OdData.Data, 0, rhs.OdData.Data, 0, retMatrix.Data.Length);
+                    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 28a8a5e..cdfb74f 100644
--- a/src/TMG-Framework/Processing/AST/CompareGreaterThan.cs
+++ b/src/TMG-Framework/Processing/AST/CompareGreaterThan.cs
@@ -44,13 +44,13 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 {
                     var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
                     var flat = retVector.Data;
-                    VectorHelper.FlagIfGreaterThan(flat, 0, lhs.LiteralValue, rhs.VectorData.Data, 0, rhs.VectorData.Data.Length);
+                    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, 0, lhs.LiteralValue, rhs.OdData.Data, 0, rhs.OdData.Data.Length);
+                    VectorHelper.FlagIfGreaterThan(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
                     return new ComputationResult(retMatrix, true);
                 }
             }
@@ -60,14 +60,14 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 {
                     var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
                     var flat = retVector.Data;
-                    VectorHelper.FlagIfGreaterThan(flat, 0, lhs.VectorData.Data, 0, rhs.LiteralValue, flat.Length);
+                    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, 0, lhs.OdData.Data, 0, rhs.LiteralValue, lhs.OdData.Data.Length);
+                    VectorHelper.FlagIfGreaterThan(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
                     return new ComputationResult(retMatrix, true);
                 }
             }
@@ -78,7 +78,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                     if (lhs.IsVectorResult && rhs.IsVectorResult)
                     {
                         var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FlagIfGreaterThan(retMatrix.Data, 0, lhs.VectorData.Data, 0, rhs.VectorData.Data, 0, retMatrix.Data.Length);
+                        VectorHelper.FlagIfGreaterThan(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
                         return new ComputationResult(retMatrix, true, lhs.Direction);
                     }
                     else if (lhs.IsVectorResult)
@@ -92,19 +92,19 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagIfGreaterThan(retMatrix.Data, i * rowSize, flatLhs[i], flatRhs, 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.Data, i * rowSize, flatLhs, 0, flatRhs, i * rowSize, rowSize);
+                                VectorHelper.FlagIfGreaterThan(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
                             }
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -119,19 +119,19 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagIfGreaterThan(retMatrix.Data, i * rowSize, flatLhs, i * rowSize, flatRhs[i], rowSize);
+                                VectorHelper.FlagIfGreaterThan(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs[i]);
                             }
                         }
                         else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagIfGreaterThan(retMatrix.Data, i * rowSize, flatLhs, i * rowSize, flatRhs, 0, rowSize);
+                                VectorHelper.FlagIfGreaterThan(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs);
                             }
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -139,7 +139,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 else
                 {
                     var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.FlagIfGreaterThan(retMatrix.Data, 0, lhs.OdData.Data, 0, rhs.OdData.Data, 0, retMatrix.Data.Length);
+                    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 2fb70d0..5fed622 100644
--- a/src/TMG-Framework/Processing/AST/CompareGreaterThanOrEqual.cs
+++ b/src/TMG-Framework/Processing/AST/CompareGreaterThanOrEqual.cs
@@ -44,13 +44,13 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 {
                     var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
                     var flat = retVector.Data;
-                    VectorHelper.FlagIfGreaterThanOrEqual(flat, 0, lhs.LiteralValue, rhs.VectorData.Data, 0, flat.Length);
+                    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, 0, lhs.LiteralValue, rhs.OdData.Data, 0, rhs.OdData.Data.Length);
+                    VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
                     return new ComputationResult(retMatrix, true);
                 }
             }
@@ -60,14 +60,14 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 {
                     var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
                     var flat = retVector.Data;
-                    VectorHelper.FlagIfGreaterThanOrEqual(flat, 0, lhs.VectorData.Data, 0, rhs.LiteralValue, lhs.VectorData.Data.Length);
+                    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, 0, lhs.OdData.Data, 0, rhs.LiteralValue, lhs.OdData.Data.Length);
+                    VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
                     return new ComputationResult(retMatrix, true);
                 }
             }
@@ -78,7 +78,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                     if (lhs.IsVectorResult && rhs.IsVectorResult)
                     {
                         var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, 0, lhs.VectorData.Data, 0, rhs.VectorData.Data, 0, retMatrix.Data.Length);
+                        VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
                         return new ComputationResult(retMatrix, true, lhs.Direction);
                     }
                     else if (lhs.IsVectorResult)
@@ -92,19 +92,19 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, i * rowSize, flatLhs[i], flatRhs, 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.Data, i * rowSize, flatLhs, 0, flatRhs, i * rowSize, rowSize);
+                                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
                             }
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to compare vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -119,19 +119,19 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, i * rowSize, flatLhs, i * rowSize, flatRhs[i], rowSize);
+                                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs[i]);
                             }
                         }
                         else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, i * rowSize, flatLhs, i * rowSize, flatRhs, 0, rowSize);
+                                VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs);
                             }
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -139,7 +139,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 else
                 {
                     var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.FlagIfGreaterThanOrEqual(retMatrix.Data, 0, lhs.OdData.Data, 0, rhs.OdData.Data, 0, retMatrix.Data.Length);
+                    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 20b101e..9139314 100644
--- a/src/TMG-Framework/Processing/AST/CompareNotEquals.cs
+++ b/src/TMG-Framework/Processing/AST/CompareNotEquals.cs
@@ -45,13 +45,13 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 {
                     var retVector = rhs.Accumulator ? rhs.VectorData : new Vector(rhs.VectorData);
                     var flat = retVector.Data;
-                    VectorHelper.FlagIfNotEquals(flat, 0, lhs.LiteralValue, rhs.VectorData.Data, 0, flat.Length);
+                    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, 0, lhs.LiteralValue, rhs.OdData.Data, 0, retMatrix.Data.Length);
+                    VectorHelper.FlagIfNotEquals(retMatrix.Data, lhs.LiteralValue, rhs.OdData.Data);
                     return new ComputationResult(retMatrix, true);
                 }
             }
@@ -61,14 +61,14 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 {
                     var retVector = lhs.Accumulator ? lhs.VectorData : new Vector(lhs.VectorData);
                     var flat = retVector.Data;
-                    VectorHelper.FlagIfNotEquals(flat, 0, lhs.VectorData.Data, 0, rhs.LiteralValue, flat.Length);
+                    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, 0, lhs.OdData.Data, 0, rhs.LiteralValue, retMatrix.Data.Length);
+                    VectorHelper.FlagIfNotEquals(retMatrix.Data, lhs.OdData.Data, rhs.LiteralValue);
                     return new ComputationResult(retMatrix, true);
                 }
             }
@@ -79,7 +79,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                     if (lhs.IsVectorResult && rhs.IsVectorResult)
                     {
                         var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FlagIfNotEquals(retMatrix.Data, 0, lhs.VectorData.Data, 0, rhs.VectorData.Data, 0, retMatrix.Data.Length);
+                        VectorHelper.FlagIfNotEquals(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
                         return new ComputationResult(retMatrix, true, lhs.Direction);
                     }
                     else if (lhs.IsVectorResult)
@@ -93,19 +93,19 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagIfNotEquals(retMatrix.Data, i * rowSize, flatLhs[i], flatRhs, 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.Data, i * rowSize, flatLhs, 0, flatRhs, i * rowSize, rowSize);
+                                VectorHelper.FlagIfNotEquals(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
                             }
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -120,19 +120,19 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagIfNotEquals(retMatrix.Data, i * rowSize, flatLhs, i * rowSize, flatRhs[i], rowSize);
+                                VectorHelper.FlagIfNotEquals(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs[i]);
                             }
                         }
                         else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagIfNotEquals(retMatrix.Data, i * rowSize, flatLhs, i * rowSize, flatRhs, 0, rowSize);
+                                VectorHelper.FlagIfNotEquals(retMatrix.GetRow(i), flatLhs.Slice(i * rowSize, rowSize), flatRhs);
                             }
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -140,7 +140,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 else
                 {
                     var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.FlagIfNotEquals(retMatrix.Data, 0, lhs.OdData.Data, 0, rhs.OdData.Data, 0, lhs.OdData.Data.Length);
+                    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 ea0756e..ddf2b19 100644
--- a/src/TMG-Framework/Processing/AST/CompareOr.cs
+++ b/src/TMG-Framework/Processing/AST/CompareOr.cs
@@ -80,7 +80,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                     if (lhs.IsVectorResult && rhs.IsVectorResult)
                     {
                         var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.FlagOr(retMatrix.Data, 0, lhs.VectorData.Data, 0, rhs.VectorData.Data, 0, retMatrix.Data.Length);
+                        VectorHelper.FlagOr(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
                         return new ComputationResult(retMatrix, true, lhs.Direction);
                     }
                     else if (lhs.IsVectorResult)
@@ -94,19 +94,19 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagOr(flatRet, i * rowSize, flatLhs[i], flatRhs, 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(flatRet, i * rowSize, flatLhs, 0, flatRhs, i * rowSize, rowSize);
+                                VectorHelper.FlagOr(retMatrix.GetRow(i), flatLhs, flatRhs.Slice(i * rowSize, rowSize));
                             }
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -121,19 +121,19 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagOr(flatRet, i * rowSize, flatRhs[i], flatLhs, i * rowSize, rowSize);
+                                VectorHelper.FlagOr(retMatrix.GetRow(i), flatRhs[i], flatLhs.Slice(i * rowSize, rowSize));
                             }
                         }
                         else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal)
                         {
                             for (int i = 0; i < rowSize; i++)
                             {
-                                VectorHelper.FlagOr(flatRet, i * rowSize, flatRhs, 0, flatLhs, i * rowSize, rowSize);
+                                VectorHelper.FlagOr(retMatrix.GetRow(i), flatRhs, flatLhs.Slice(i * rowSize, rowSize));
                             }
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -141,7 +141,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                 else
                 {
                     var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : new Matrix(lhs.OdData));
-                    VectorHelper.FlagOr(retMatrix.Data, 0, lhs.OdData.Data, 0, rhs.OdData.Data, 0, lhs.OdData.Data.Length);
+                    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 93d1f19..56f269a 100644
--- a/src/TMG-Framework/Processing/AST/Compiler.cs
+++ b/src/TMG-Framework/Processing/AST/Compiler.cs
@@ -17,11 +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
 {
     public static class Compiler
     {
-        public static bool Compile(string expression,out Expression ex, 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);
diff --git a/src/TMG-Framework/Processing/AST/Divide.cs b/src/TMG-Framework/Processing/AST/Divide.cs
index ac11733..aa0fce0 100644
--- a/src/TMG-Framework/Processing/AST/Divide.cs
+++ b/src/TMG-Framework/Processing/AST/Divide.cs
@@ -20,6 +20,7 @@ You should have received a copy of the GNU General Public License
 using XTMF2;
 using TMG.Utilities;
 using System;
+using System.Diagnostics.CodeAnalysis;
 
 namespace TMG.Frameworks.Data.Processing.AST
 {
@@ -30,7 +31,9 @@ public Divide(int start) : base(start)
 
         }
 
-        internal override bool OptimizeAst(ref Expression ex, ref string error)
+        internal override bool OptimizeAst(
+            ref Expression ex,
+            [NotNullWhen(false)] ref string? error)
         {
             if (!base.OptimizeAst(ref ex, ref error))
             {
@@ -102,7 +105,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                     if (lhs.IsVectorResult && rhs.IsVectorResult)
                     {
                         var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : new Vector(lhs.VectorData));
-                        VectorHelper.Divide(retMatrix.Data.AsSpan(), lhs.VectorData.Data.AsSpan(), rhs.VectorData.Data.AsSpan());
+                        VectorHelper.Divide(retMatrix.Data, lhs.VectorData.Data, rhs.VectorData.Data);
                         return new ComputationResult(retMatrix, true, lhs.Direction);
                     }
                     else if (lhs.IsVectorResult)
@@ -130,7 +133,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -161,7 +164,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
diff --git a/src/TMG-Framework/Processing/AST/Exponent.cs b/src/TMG-Framework/Processing/AST/Exponent.cs
index c942f20..92cfbe6 100644
--- a/src/TMG-Framework/Processing/AST/Exponent.cs
+++ b/src/TMG-Framework/Processing/AST/Exponent.cs
@@ -105,7 +105,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         }
                         else
                         {
-                            return new ComputationResult("Unable to subtract vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to subtract vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -134,7 +134,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         }
                         else
                         {
-                            return new ComputationResult("Unable to subtract vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to subtract vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
diff --git a/src/TMG-Framework/Processing/AST/Expression.cs b/src/TMG-Framework/Processing/AST/Expression.cs
index ed22930..ee9c4fe 100644
--- a/src/TMG-Framework/Processing/AST/Expression.cs
+++ b/src/TMG-Framework/Processing/AST/Expression.cs
@@ -19,6 +19,7 @@ You should have received a copy of the GNU General Public License
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Text;
 using System.Threading.Tasks;
 using XTMF2;
@@ -33,13 +34,15 @@ public Expression(int start) : base(start)
 
         }
 
-        private static bool FailWithError(out ComputationResult result, string message)
+        private static bool FailWithError(
+            [NotNullWhen(false)] out ComputationResult? result, string message)
         {
             result = new ComputationResult(message);
             return false;
         }
 
-        protected bool ValidateSizes(ComputationResult lhs, ComputationResult rhs, int position, out ComputationResult errorResult)
+        protected bool ValidateSizes(ComputationResult lhs, ComputationResult rhs, int position, 
+            [NotNullWhen(false)] out ComputationResult? errorResult)
         {
             errorResult = null;
             if (lhs.IsValue || lhs.IsVectorResult && rhs.IsOdResult)
@@ -52,7 +55,7 @@ protected bool ValidateSizes(ComputationResult lhs, ComputationResult rhs, int p
             {
                 if (rhs.IsOdResult)
                 {
-                    if (!(lhs.OdData.ColumnCategories == rhs.OdData.ColumnCategories
+                    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.");
@@ -63,13 +66,13 @@ protected bool ValidateSizes(ComputationResult lhs, ComputationResult rhs, int p
                     switch (rhs.Direction)
                     {
                         case ComputationResult.VectorDirection.Horizontal:
-                            if (!(lhs.OdData.ColumnCategories == rhs.VectorData.Categories))
+                            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))
+                            if (!(lhs.OdData!.RowCategories == rhs.VectorData!.Categories))
                             {
                                 return FailWithError(out errorResult, $"Operation at position {position} failed because data was not of compatible categories.");
                             }
@@ -83,7 +86,7 @@ protected bool ValidateSizes(ComputationResult lhs, ComputationResult rhs, int p
             {
                 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.");
                     }
@@ -92,7 +95,8 @@ protected bool ValidateSizes(ComputationResult lhs, ComputationResult rhs, int p
             return true;
         }
 
-        private static int FindEndOfBracket(char[] buffer, int start, int length, ref string error)
+        private static int FindEndOfBracket(char[] buffer, int start, int length, 
+            [NotNullWhen(false)] ref string? error)
         {
             int bracketLevel = 1;
             int i = start;
@@ -115,14 +119,17 @@ private static int FindEndOfBracket(char[] buffer, int start, int length, ref st
             return -1;
         }
 
-        internal static bool Optimize(ref Expression ex, ref string error)
+        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, 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;
@@ -162,7 +169,12 @@ private static bool IsCompareType(Expression e)
             var t = e.GetType();
             if (t == typeof(Bracket))
             {
-                return IsCompareType(((Bracket)e).InnerExpression);
+                var inner = ((Bracket)e).InnerExpression;
+                if (inner is null)
+                {
+                    return false;
+                }
+                return IsCompareType(inner);
             }
             return t == typeof(CompareEqual)
                 || t == typeof(CompareNotEquals)
@@ -172,7 +184,9 @@ private static bool IsCompareType(Expression e)
                 || t == typeof(CompareOr);
         }
 
-        public static bool Compile(char[] buffer, int start, int length, out Expression ex, ref string error)
+        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);
@@ -186,6 +200,7 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
                             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;
@@ -237,6 +252,7 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
                             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;
@@ -326,6 +342,7 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
                             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;
@@ -354,6 +371,7 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
                             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;
@@ -400,6 +418,7 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
                             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;
@@ -425,6 +444,7 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
                             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;
@@ -450,6 +470,7 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
                             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;
@@ -472,8 +493,9 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
                 {
                     case '(':
                         int endIndex = FindEndOfBracket(buffer, i + 1, endPlusOne - (i + 1), ref error);
-                        if (endPlusOne < 0)
+                        if (endIndex < 0)
                         {
+                            error = $"At position {i} we found a '(' character without an accompanying ')'";
                             return false;
                         }
                         i = endIndex;
@@ -512,11 +534,12 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
                                 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;
                                 }
                                 List<Expression> parameters = new List<Expression>();
                                 int lastStart = i + 1;
-                                Expression p;
+                                Expression? p;
                                 for (int j = i + 1; j < endIndex; j++)
                                 {
                                     if (buffer[j] == '(')
@@ -525,6 +548,7 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
                                         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;
@@ -548,7 +572,7 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
                                     }
                                     parameters.Add(p);
                                 }
-                                if (!FunctionCall.GetCall(start, builder.ToString(), parameters.ToArray(), out FunctionCall toReturn, ref error))
+                                if (!FunctionCall.GetCall(start, builder.ToString(), parameters.ToArray(), out FunctionCall? toReturn, ref error))
                                 {
                                     return false;
                                 }
@@ -573,6 +597,7 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
                             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;
                             }
                             var toReturn = new Bracket(i);
@@ -637,23 +662,30 @@ public static bool Compile(char[] buffer, int start, int length, out Expression
 
     public abstract class MonoExpression : Expression
     {
-        public Expression InnerExpression;
+        public Expression? InnerExpression;
 
         public MonoExpression(int start) : base(start)
         {
 
         }
 
-        internal override bool OptimizeAst(ref Expression ex, ref string error)
+        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;
+            }
             return InnerExpression.OptimizeAst(ref InnerExpression, ref error);
         }
     }
 
     public abstract class BinaryExpression : Expression
     {
-        public Expression Lhs;
-        public Expression Rhs;
+        public Expression? Lhs;
+        public Expression? Rhs;
 
         public BinaryExpression(int start) : base(start)
         {
@@ -662,8 +694,16 @@ public BinaryExpression(int start) : base(start)
 
         public override ComputationResult Evaluate(IModule[] dataSources)
         {
-            ComputationResult lhs = null;
-            ComputationResult rhs = 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));
@@ -684,8 +724,19 @@ public override ComputationResult Evaluate(IModule[] dataSources)
 
         public abstract ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs);
 
-        internal override bool OptimizeAst(ref Expression ex, ref string error)
+        internal override bool OptimizeAst(ref Expression ex, 
+            [NotNullWhen(false)] ref string? 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;
@@ -701,7 +752,8 @@ public Value(int start) : base(start)
 
         }
 
-        internal override bool OptimizeAst(ref Expression ex, ref string error)
+        internal override bool OptimizeAst(ref Expression ex, 
+            [NotNullWhen(false)] ref string? error)
         {
             return true;
         }
@@ -716,11 +768,21 @@ public Bracket(int start) : base(start)
 
         public override ComputationResult Evaluate(IModule[] dataSources)
         {
+            if (InnerExpression is null)
+            {
+                return new ComputationResult($"Bracket at position {Start} has no inner expression!");
+            }
             return InnerExpression.Evaluate(dataSources);
         }
 
-        internal override bool OptimizeAst(ref Expression ex, ref string error)
+        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 false;
diff --git a/src/TMG-Framework/Processing/AST/FunctionCall.cs b/src/TMG-Framework/Processing/AST/FunctionCall.cs
index 87d6691..118e7b4 100644
--- a/src/TMG-Framework/Processing/AST/FunctionCall.cs
+++ b/src/TMG-Framework/Processing/AST/FunctionCall.cs
@@ -17,6 +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.Diagnostics.CodeAnalysis;
 using System.Linq;
 using TMG.Utilities;
 using XTMF2;
@@ -66,7 +67,8 @@ private FunctionCall(int start, FunctionType call, Expression[] parameters) : ba
             _type = call;
         }
 
-        internal override bool OptimizeAst(ref Expression ex, ref string error)
+        internal override bool OptimizeAst(ref Expression ex, 
+            [NotNullWhen(false)] ref string? error)
         {
             for (int i = 0; i < _parameters.Length; i++)
             {
@@ -78,7 +80,9 @@ internal override bool OptimizeAst(ref Expression ex, ref string error)
             return true;
         }
 
-        public static bool GetCall(int start, string call, Expression[] parameters, out FunctionCall ex, ref string error)
+        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;
@@ -90,7 +94,9 @@ public static bool GetCall(int start, string call, Expression[] parameters, out
             return true;
         }
 
-        private static bool Decode(string call, 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();
@@ -519,13 +525,13 @@ private ComputationResult ComputeNormalize(ComputationResult[] values)
             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, 0, flatRead.Length);
+            var denominator = VectorHelper.Sum(flatRead);
             if (denominator == 0f)
             {
                 // only clear the write array if it was an accumulator
                 if (flatRead == flatWrite)
                 {
-                    Array.Clear(flatWrite, 0, flatRead.Length);
+                    flatWrite.Clear();
                 }
             }
             else
@@ -547,21 +553,17 @@ private ComputationResult ComputeIfNaN(ComputationResult[] values)
             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, 0, replacement.VectorData.Data.Length);
+                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;
-                int rows = values[0].OdData.RowCategories.Count;
-                int columns = values[0].OdData.ColumnCategories.Count;
-                System.Threading.Tasks.Parallel.For(0, rows, (int i) =>
-                {
-                    VectorHelper.ReplaceIfNaN(flatSave, flatCond, flatRep, i * columns, columns);
-                });
+                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.");
@@ -628,7 +630,7 @@ private ComputationResult ComputeIf(ComputationResult[] values)
                                 {
                                     var toAssign = cond[i] > 0 ? t : f;
                                     var rowOffset = i * cond.Length;
-                                    Array.Copy(toAssign, rowOffset, result, rowOffset, cond.Length);
+                                    toAssign.Slice(rowOffset, cond.Length).CopyTo(result.Slice(rowOffset, cond.Length));
                                 }
                                 return new ComputationResult(saveTo, true);
                             }
@@ -659,15 +661,14 @@ private ComputationResult ComputeIf(ComputationResult[] values)
                     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);
-                var cond = condition.OdData.Data;
-                var tr = ifTrue.OdData.Data;
-                var fa = ifFalse.OdData.Data;
-                var sa = saveTo.Data;
-                var columnSize = condition.OdData.GetFlatRowIndex(1);
                 // this will never have a remainder
-                var rowSize = cond.Length / columnSize;
-                System.Threading.Tasks.Parallel.For(0, rowSize, (int row) =>
+                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++)
@@ -768,14 +769,14 @@ private ComputationResult Matrix(ComputationResult computationResult)
                     // each row is the single value
                     for (int i = 0; i < flatVector.Length; i++)
                     {
-                        VectorHelper.Set(flatMatrix, i * rowSize, flatVector[i], rowSize);
+                        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 < flatMatrix.Length; i += flatVector.Length)
+                    for (int i = 0; i < newMatrix.NumberOfRows; i++)
                     {
-                        Array.Copy(flatVector, 0, flatMatrix, i, flatVector.Length);
+                        flatVector.CopyTo(newMatrix.GetRow(i));
                     }
                     break;
             }
@@ -799,12 +800,12 @@ private ComputationResult Avg(ComputationResult computationResult)
             if (computationResult.IsVectorResult)
             {
                 var flat = computationResult.VectorData.Data;
-                return new ComputationResult(VectorHelper.Sum(flat, 0, flat.Length) / flat.Length);
+                return new ComputationResult(VectorHelper.Sum(flat) / flat.Length);
             }
             else
             {
                 var flat = computationResult.OdData.Data;
-                return new ComputationResult(VectorHelper.Sum(flat, 0, flat.Length) / flat.Length);
+                return new ComputationResult(VectorHelper.Sum(flat) / flat.Length);
             }
         }
 
@@ -834,12 +835,12 @@ private ComputationResult Sum(ComputationResult computationResult)
         {
             if (computationResult.IsVectorResult)
             {
-                return new ComputationResult(VectorHelper.Sum(computationResult.VectorData.Data, 0, computationResult.VectorData.Data.Length));
+                return new ComputationResult(VectorHelper.Sum(computationResult.VectorData.Data));
             }
             else if (computationResult.IsOdResult)
             {
                 var data = computationResult.OdData.Data;
-                var total = VectorHelper.Sum(data, 0, data.Length);
+                var total = VectorHelper.Sum(data);
                 return new ComputationResult(total);
             }
             return new ComputationResult("Unknown data type to sum!");
@@ -888,11 +889,11 @@ private ComputationResult SumRows(ComputationResult computationResult)
         {
             var ret = new Vector(computationResult.OdData.RowCategories);
             var flatRet = ret.Data;
-            var flatData = computationResult.OdData.Data;
+            var flatData = computationResult.OdData;
             var rowSize = ret.Categories.Count;
             for (int i = 0; i < flatRet.Length; i++)
             {
-                flatRet[i] = VectorHelper.Sum(flatData, i * rowSize, rowSize);
+                flatRet[i] = VectorHelper.Sum(flatData.GetRow(i));
             }
             return new ComputationResult(ret, true, ComputationResult.VectorDirection.Vertical);
         }
@@ -917,11 +918,10 @@ private ComputationResult AvgRows(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++)
             {
-                flatRet[i] = VectorHelper.Sum(flatData, i * rowSize, rowSize);
+                flatRet[i] = VectorHelper.Sum(data.GetRow(i));
             }
             VectorHelper.Multiply(flatRet, flatRet, 1.0f / flatRet.Length);
             return new ComputationResult(ret, true, ComputationResult.VectorDirection.Vertical);
diff --git a/src/TMG-Framework/Processing/AST/FusedMultiplyAdd.cs b/src/TMG-Framework/Processing/AST/FusedMultiplyAdd.cs
index d6043c7..ecd19e7 100644
--- a/src/TMG-Framework/Processing/AST/FusedMultiplyAdd.cs
+++ b/src/TMG-Framework/Processing/AST/FusedMultiplyAdd.cs
@@ -22,15 +22,16 @@ You should have received a copy of the GNU General Public License
 using System;
 using System.Threading.Tasks;
 using System.Security.Cryptography;
+using System.Diagnostics.CodeAnalysis;
 
 namespace TMG.Frameworks.Data.Processing.AST
 {
     public sealed class FusedMultiplyAdd : Expression
     {
 
-        public Expression MulLhs;
-        public Expression MulRhs;
-        public Expression Add;
+        public Expression? MulLhs;
+        public Expression? MulRhs;
+        public Expression? Add;
         private int AddStart;
 
         public FusedMultiplyAdd(int mulStart, int addStart) : base(mulStart)
@@ -40,9 +41,13 @@ public FusedMultiplyAdd(int mulStart, int addStart) : base(mulStart)
 
         public override ComputationResult Evaluate(IModule[] dataSources)
         {
-            ComputationResult mulLhs = null;
-            ComputationResult mulRhs = null;
-            ComputationResult add = 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),
@@ -176,7 +181,7 @@ private ComputationResult EvaluateAddIsValue(ComputationResult lhs, ComputationR
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + MulLhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -205,7 +210,7 @@ private ComputationResult EvaluateAddIsValue(ComputationResult lhs, ComputationR
                         }
                         else
                         {
-                            return new ComputationResult("Unable to add vector without directionality starting at position " + MulLhs.Start + "!");
+                            return new ComputationResult("Unable to add vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -244,15 +249,15 @@ private ComputationResult EvaluateAddIsVector(ComputationResult lhs, Computation
             {
                 if (lhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
                 {
-                    return new ComputationResult("Unable to multiply vector without directionality starting at position " + MulLhs.Start + "!");
+                    return new ComputationResult("Unable to multiply vector without directionality starting at position " + (MulLhs?.Start ?? -1) + "!");
                 }
                 if (rhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
                 {
-                    return new ComputationResult("Unable to multiply vector without directionality starting at position " + MulRhs.Start + "!");
+                    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 + "!");
+                    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)
@@ -394,11 +399,11 @@ private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, Computation
         {
             if (lhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
             {
-                return new ComputationResult("Unable to multiply vector without directionality starting at position " + MulLhs.Start + "!");
+                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 + "!");
+                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)
@@ -478,7 +483,7 @@ private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, Computation
                     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 + "!");
+                        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);
                 }
@@ -486,11 +491,12 @@ private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, Computation
                 {
                     VectorHelper.Multiply(tempVector.Data, lhs.VectorData.Data, rhs.LiteralValue);
                 }
-                var flatTemp = tempVector.Data;
+                
                 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]);
@@ -500,6 +506,7 @@ private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, Computation
                 {
                     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);
@@ -516,8 +523,14 @@ private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, Computation
             }
         }
 
-        internal override bool OptimizeAst(ref Expression ex, ref string error)
+        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 bdb5e10..6da478d 100644
--- a/src/TMG-Framework/Processing/AST/Multiply.cs
+++ b/src/TMG-Framework/Processing/AST/Multiply.cs
@@ -18,6 +18,7 @@ You should have received a copy of the GNU General Public License
 */
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using TMG.Utilities;
 
 namespace TMG.Frameworks.Data.Processing.AST
@@ -29,7 +30,8 @@ public Multiply(int start) : base(start)
 
         }
 
-        internal override bool OptimizeAst(ref Expression ex, ref string error)
+        internal override bool OptimizeAst(ref Expression ex, 
+            [NotNullWhen(false)] ref string? error)
         {
             if (!base.OptimizeAst(ref ex, ref error))
             {
@@ -37,7 +39,7 @@ internal override bool OptimizeAst(ref Expression ex, ref string error)
             }
             var lhs = Lhs as Literal;
             var rhs = Rhs as Literal;
-            if (lhs != null && rhs != null)
+            if (lhs is not null && rhs is not null)
             {
                 ex = new Literal(Start, lhs.Value * rhs.Value);
             }
@@ -119,7 +121,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         }
                         else
                         {
-                            return new ComputationResult("Unable to multiply vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to multiply vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -148,7 +150,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         }
                         else
                         {
-                            return new ComputationResult("Unable to multiply vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to multiply vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
diff --git a/src/TMG-Framework/Processing/AST/Negate.cs b/src/TMG-Framework/Processing/AST/Negate.cs
index eeefb5f..7b38df5 100644
--- a/src/TMG-Framework/Processing/AST/Negate.cs
+++ b/src/TMG-Framework/Processing/AST/Negate.cs
@@ -21,6 +21,7 @@ You should have received a copy of the GNU General Public License
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.Diagnostics.CodeAnalysis;
 using TMG.Utilities;
 using XTMF2;
 
@@ -32,8 +33,15 @@ public Negate(int start) : base(start)
         {
         }
 
-        internal override bool OptimizeAst(ref Expression ex, ref string error)
+        internal override bool OptimizeAst(ref Expression ex, 
+            [NotNullWhen(false)] ref string? 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))
             {
@@ -49,6 +57,11 @@ internal override bool OptimizeAst(ref Expression ex, ref string error)
 
         public override ComputationResult Evaluate(IModule[] dataSources)
         {
+            if (InnerExpression is null)
+            {
+                return new ComputationResult("Unable to evaluate Negate with null operand starting at position " + Start + "!");
+            }
+
             var inner = InnerExpression.Evaluate(dataSources);
             if (inner.IsValue)
             {
@@ -57,7 +70,7 @@ public override ComputationResult Evaluate(IModule[] dataSources)
             else if (inner.IsVectorResult)
             {
                 var ret = inner.Accumulator ? inner.VectorData : new Vector(inner.VectorData);
-                VectorHelper.Negate(ret.Data, inner.VectorData.Data, 0, ret.Data.Length);
+                VectorHelper.Negate(ret.Data, inner.VectorData.Data);
                 return new ComputationResult(ret, true, inner.Direction);
             }
             else
@@ -65,7 +78,7 @@ public override ComputationResult Evaluate(IModule[] dataSources)
                 var ret = inner.Accumulator ? inner.OdData : new Matrix(inner.OdData);
                 var flatRet = ret.Data;
                 var flatInner = inner.OdData.Data;
-                VectorHelper.Negate(flatRet, flatInner, 0, flatInner.Length);
+                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 96d35a8..5b3328b 100644
--- a/src/TMG-Framework/Processing/AST/Subtract.cs
+++ b/src/TMG-Framework/Processing/AST/Subtract.cs
@@ -18,6 +18,7 @@ You should have received a copy of the GNU General Public License
 */
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using TMG.Utilities;
 
 namespace TMG.Frameworks.Data.Processing.AST
@@ -29,7 +30,8 @@ public Subtract(int start) : base(start)
 
         }
 
-        internal override bool OptimizeAst(ref Expression ex, ref string error)
+        internal override bool OptimizeAst(ref Expression ex, 
+            [NotNullWhen(false)] ref string? error)
         {
             if(!base.OptimizeAst(ref ex, ref error))
             {
@@ -120,7 +122,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         }
                         else
                         {
-                            return new ComputationResult("Unable to subtract vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to subtract vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
@@ -149,7 +151,7 @@ public override ComputationResult Evaluate(ComputationResult lhs, ComputationRes
                         }
                         else
                         {
-                            return new ComputationResult("Unable to subtract vector without directionality starting at position " + Lhs.Start + "!");
+                            return new ComputationResult("Unable to subtract vector without directionality starting at position " + (Lhs?.Start ?? -1) + "!");
                         }
                         return new ComputationResult(retMatrix, true);
                     }
diff --git a/src/TMG-Framework/Processing/AppendMatrixValueToCSV.cs b/src/TMG-Framework/Processing/AppendMatrixValueToCSV.cs
index c8791c3..e32a164 100644
--- a/src/TMG-Framework/Processing/AppendMatrixValueToCSV.cs
+++ b/src/TMG-Framework/Processing/AppendMatrixValueToCSV.cs
@@ -33,22 +33,22 @@ public class AppendMatrixValueToCSV : BaseAction
     {
 
         [Parameter(Name = "Column Name", DefaultValue = "Value", Description = "The name to use for the column", Index = 0)]
-        public IFunction<string> ColumnName;
+        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;
+        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;
+        public IFunction<int> ColumnIndex = null!;
 
         [SubModule(Name = "Matrix", Index = 3, Description = "The matrix to assign.", Required = true)]
-        public IFunction<Matrix> Matrix;
+        public IFunction<Matrix> Matrix = null!;
 
         [SubModule(Name = "Input Stream", Index = 4, Description = "The stream contianing the CSV file.", Required = true)]
-        public IFunction<ReadStream> InputStream;
+        public IFunction<ReadStream> InputStream = null!;
 
         [SubModule(Name = "Output Stream", Index = 5, Description = "The stream to store the results.", Required = true)]
-        public IFunction<WriteStream> OutputStream;
+        public IFunction<WriteStream> OutputStream = null!;
 
         public override void Invoke()
         {
diff --git a/src/TMG-Framework/Processing/Evaluate2DGravityModel.cs b/src/TMG-Framework/Processing/Evaluate2DGravityModel.cs
index eb6922e..de3fb24 100644
--- a/src/TMG-Framework/Processing/Evaluate2DGravityModel.cs
+++ b/src/TMG-Framework/Processing/Evaluate2DGravityModel.cs
@@ -30,41 +30,46 @@ namespace TMG.Processing
     public sealed class Evaluate2DGravityModel : BaseFunction<Matrix>
     {
         [SubModule(Name = "Production", Required = true, Index = 0, Description = "")]
-        public IFunction<Vector> Production;
+        public IFunction<Vector> Production = null!;
 
         [SubModule(Name = "Attraction", Required = true, Index = 1, Description = "")]
-        public IFunction<Vector> Attraction;
+        public IFunction<Vector> Attraction = null!;
 
         [SubModule(Name = "Friction", Required = true, Index = 2, Description = "")]
-        public IFunction<Matrix> Friction;
+        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;
+        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;
+        public IFunction<float> MaxError = null!;
 
-        private static void Apply(float[] ret, float[] friction, float[] production,
-            float[] attraction, float[] attractionStar, float[] columnTotals)
+        private static void Apply(Matrix ret, Matrix friction, Vector production,
+            Vector attraction, Vector attractionStar, float[] columnTotals)
         {
-            Parallel.For(0, production.Length, new ParallelOptions() { MaxDegreeOfParallelism = Environment.ProcessorCount },
+            Parallel.For(0, production.Count, new ParallelOptions() { MaxDegreeOfParallelism = Environment.ProcessorCount },
                 () => new float[columnTotals.Length],
                 (flatOrigin, state, localTotals) =>
                 {
-                    var length = production.Length;
+                    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 (production[flatOrigin] > 0)
+                    if (sProduction[flatOrigin] > 0)
                     {
-                        var sumAf = VectorHelper.Multiply3AndSum(friction, rowIndex, attraction, 0, attractionStar, 0, length);
-                        sumAf = (production[flatOrigin] / 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(ret, flatOrigin * production.Length,
-                            friction, rowIndex, attraction, 0, attractionStar, 0, sumAf, localTotals, 0, length);
+                        VectorHelper.Multiply3Scalar1AndColumnSum(sRet, sFriction, sAttraction, sAttractionStar, sumAf, localTotals.AsSpan());
                     }
                     return localTotals;
                 },
@@ -77,11 +82,11 @@ private static void Apply(float[] ret, float[] friction, float[] production,
             });
         }
 
-        private bool Balance(float[] flatAttractions, float[] flatAttractionStar, float epsilon, float[] columnTotals)
+        private bool Balance(Vector flatAttractions, Vector flatAttractionStar, float epsilon, float[] columnTotals)
         {
-            VectorHelper.Divide(columnTotals, flatAttractions, columnTotals);
-            VectorHelper.Multiply(flatAttractionStar, flatAttractionStar, columnTotals);
-            VectorHelper.ReplaceIfNotFinite(flatAttractionStar, 0, 1.0f, flatAttractionStar.Length);
+            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);
         }
 
@@ -108,8 +113,8 @@ public override Matrix Invoke()
             do
             {
                 Array.Clear(columnTotals, 0, columnTotals.Length);
-                Apply(ret.Data, friction.Data, production.Data, attraction.Data, attractionStar.Data, columnTotals);
-            } while (!Balance(attraction.Data, attractionStar.Data, maxError, columnTotals) || (++iteration < maxIterations));
+                Apply(ret, friction, production, attraction, attractionStar, columnTotals);
+            } while (!Balance(attraction, attractionStar, maxError, columnTotals) || (++iteration < maxIterations));
             return ret;
         }
 
diff --git a/src/TMG-Framework/Processing/EvaluateMatrix.cs b/src/TMG-Framework/Processing/EvaluateMatrix.cs
index 1ba69cc..50104b0 100644
--- a/src/TMG-Framework/Processing/EvaluateMatrix.cs
+++ b/src/TMG-Framework/Processing/EvaluateMatrix.cs
@@ -29,17 +29,17 @@ namespace TMG.Processing
     public class EvaluateMatrix : BaseFunction<Matrix>
     {
         [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
-        public IFunction<string> Expression;
+        public IFunction<string> Expression = null!;
 
         [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
-        public IModule[] Variables;
+        public IModule[] Variables = null!;
 
-        private string PreviousExpressionString = null;
-        private Expression PreviousExpression = null;
+        private string? PreviousExpressionString = null;
+        private Expression? PreviousExpression = null;
 
         public override Matrix Invoke()
         {
-            string error = null;
+            string? error = null;
             // compile and optimize the expression
             var expressionString = Expression.Invoke();
             if (PreviousExpression == null || expressionString != PreviousExpressionString)
@@ -69,7 +69,7 @@ public override Matrix Invoke()
             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)
             {
diff --git a/src/TMG-Framework/Processing/EvaluateScalar.cs b/src/TMG-Framework/Processing/EvaluateScalar.cs
index 10c1d01..db146a6 100644
--- a/src/TMG-Framework/Processing/EvaluateScalar.cs
+++ b/src/TMG-Framework/Processing/EvaluateScalar.cs
@@ -29,14 +29,14 @@ namespace TMG.Processing
     public class EvaluateScalar : BaseFunction<float>
     {
         [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
-        public IFunction<string> Expression;
+        public IFunction<string> Expression = null!;
 
         [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
-        public IModule[] Variables;
+        public IModule[] Variables = null!;
 
         public override float Invoke()
         {
-            string error = null;
+            string? error = null;
             // compile and optimize the expression
             if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(Expression.Invoke(), out var expression, ref error))
             {
@@ -59,7 +59,7 @@ public override float Invoke()
             
         }
 
-        public override bool RuntimeValidation(ref string error)
+        public override bool RuntimeValidation(ref string? error)
         {
             foreach (var module in Variables)
             {
diff --git a/src/TMG-Framework/Processing/EvaluateVector.cs b/src/TMG-Framework/Processing/EvaluateVector.cs
index 95b13f0..783d845 100644
--- a/src/TMG-Framework/Processing/EvaluateVector.cs
+++ b/src/TMG-Framework/Processing/EvaluateVector.cs
@@ -29,14 +29,14 @@ namespace TMG.Processing
     public class EvaluateVector : BaseFunction<Vector>
     {
         [Parameter(Name = "Expression", Index = 0, Description = "The expression to compute using the following variables.")]
-        public IFunction<string> Expression;
+        public IFunction<string> Expression = null!;
 
         [SubModule(Name = "Variables", Description = "The variables to use in our expression", Index = 1)]
-        public IModule[] Variables;
+        public IModule[] Variables = null!;
 
         public override Vector Invoke()
         {
-            string error = null;
+            string? error = null;
             // compile and optimize the expression
             if (!TMG.Frameworks.Data.Processing.AST.Compiler.Compile(Expression.Invoke(), out var expression, ref error))
             {
@@ -59,7 +59,7 @@ public override Vector Invoke()
             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)
             {
diff --git a/src/TMG-Framework/Processing/ExecutePipelineInOrderParallel.cs b/src/TMG-Framework/Processing/ExecutePipelineInOrderParallel.cs
index 4d53512..9c082df 100644
--- a/src/TMG-Framework/Processing/ExecutePipelineInOrderParallel.cs
+++ b/src/TMG-Framework/Processing/ExecutePipelineInOrderParallel.cs
@@ -29,10 +29,10 @@ namespace TMG.Processing
     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;
+        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;
+        public IFunction<T,T>[] ToExecuteNotInParallel = null!;
 
         public override IEnumerable<T> Invoke(IEnumerable<T> context)
         {
diff --git a/src/TMG-Framework/Processing/IntegerizeMatrix.cs b/src/TMG-Framework/Processing/IntegerizeMatrix.cs
index 0cca380..afa4326 100644
--- a/src/TMG-Framework/Processing/IntegerizeMatrix.cs
+++ b/src/TMG-Framework/Processing/IntegerizeMatrix.cs
@@ -31,13 +31,13 @@ namespace TMG.Processing
     public class IntegerizeMatrix : BaseFunction<Matrix>
     {
         [SubModule(Required = true, Index = 0, Name = "Input Matrix", Description = "The matrix that will be integerized.")]
-        public IFunction<Matrix> InputMatrix;
+        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;
+        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;
+        public IFunction<CategoryMap> ZoneToPDMap = null!;
 
         /// <summary>
         /// Computes an integer matrix given the input matrix, randomly assigning the remainders within
diff --git a/src/TMG-Framework/Saving/SaveMatrixAsCSV.cs b/src/TMG-Framework/Saving/SaveMatrixAsCSV.cs
index 4287f34..f913d49 100644
--- a/src/TMG-Framework/Saving/SaveMatrixAsCSV.cs
+++ b/src/TMG-Framework/Saving/SaveMatrixAsCSV.cs
@@ -30,19 +30,19 @@ 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;
+        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;
+        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;
+        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;
+        public IFunction<string> DataIndexHeader = null!;
 
         public override void Invoke((Matrix Matrix, WriteStream Stream) context)
         {
diff --git a/src/TMG-Framework/Saving/SaveMatrixAsMTX.cs b/src/TMG-Framework/Saving/SaveMatrixAsMTX.cs
index 02b4b9b..2937ae2 100644
--- a/src/TMG-Framework/Saving/SaveMatrixAsMTX.cs
+++ b/src/TMG-Framework/Saving/SaveMatrixAsMTX.cs
@@ -63,7 +63,7 @@ public override void Invoke((Matrix Matrix, WriteStream Stream) context)
                     }
                 }
                 // use span to avoid copying the data
-                writer.Write(MemoryMarshal.Cast<float,byte>(new Span<float>(matrix.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 ec8396e..ed9bb5e 100644
--- a/src/TMG-Framework/Saving/SaveVectorAsCSV.cs
+++ b/src/TMG-Framework/Saving/SaveVectorAsCSV.cs
@@ -47,10 +47,10 @@ public override void Invoke((Vector Data, WriteStream Stream) context)
         }
 
         [Parameter(Name = "Map Column Name", DefaultValue = "Zone", Description = "The header to give to the map indexes", Index = 0)]
-        public IFunction<string> MapColumnName;
+        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;
+        public IFunction<string> DataColumnName = null!;
 
         private void WriteHeaders(StreamWriter writer)
         {
diff --git a/src/TMG-Framework/Select/SelectGivenTime.cs b/src/TMG-Framework/Select/SelectGivenTime.cs
index 3b27015..fe3d75c 100644
--- a/src/TMG-Framework/Select/SelectGivenTime.cs
+++ b/src/TMG-Framework/Select/SelectGivenTime.cs
@@ -28,17 +28,17 @@ namespace TMG.Select
     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;
+        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;
+        public IFunction<int> DefaultTimePeriod = null!;
 
-        private TimePeriod[] _TimeOperations;
+        private TimePeriod[]? _TimeOperations;
 
         public override T Invoke(Time context)
         {
             var local = _TimeOperations;
-            if (local != null)
+            if (local is not null)
             {
                 for (int i = 0; i < local.Length; i++)
                 {
@@ -78,7 +78,7 @@ private T BuildIndexAndReturnResult(Time context)
             return Invoke(context);
         }
 
-        public override bool RuntimeValidation(ref string error)
+        public override bool RuntimeValidation(ref string? error)
         {
             if (TimePeriodData.Length <= 0)
             {
diff --git a/src/TMG-Framework/TMG-Framework.csproj b/src/TMG-Framework/TMG-Framework.csproj
index 527ec9e..c35ab72 100644
--- a/src/TMG-Framework/TMG-Framework.csproj
+++ b/src/TMG-Framework/TMG-Framework.csproj
@@ -3,6 +3,7 @@
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
     <RootNamespace>TMG</RootNamespace>
+    <Nullable>enable</Nullable>
     <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 3d30b9f..d161659 100644
--- a/src/TMG-Framework/Utilities/CSVReader.cs
+++ b/src/TMG-Framework/Utilities/CSVReader.cs
@@ -41,7 +41,7 @@ public sealed class CsvReader : IDisposable
         private CsvPartition[] Data = new CsvPartition[50];
 
         private char[] DataBuffer = new char[0x4000];
-        private char[] DataBuffer2;
+        private char[]? DataBuffer2;
 
         private int DataBufferLength;
 
diff --git a/src/TMG-Framework/Utilities/ExceptionHelper.cs b/src/TMG-Framework/Utilities/ExceptionHelper.cs
index 920bc35..3bfa0e8 100644
--- a/src/TMG-Framework/Utilities/ExceptionHelper.cs
+++ b/src/TMG-Framework/Utilities/ExceptionHelper.cs
@@ -18,6 +18,7 @@ You should have received a copy of the GNU General Public License
 */
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Text;
 
 namespace TMG.Utilities
@@ -34,6 +35,7 @@ internal static class ExceptionHelper
         /// 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);
@@ -43,9 +45,20 @@ internal static void ThrowOutOfRangeException(string name)
         /// 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);
+        }
     }
 }
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Add.cs b/src/TMG-Framework/Utilities/VectorHelper/Add.cs
index 0324eab..a1d34bf 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Add.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Add.cs
@@ -89,7 +89,6 @@ public static void Add(Span<float> dest, ReadOnlySpan<float> left, float scalar)
             for (; i <= end; i += (nuint)Vector512<float>.Count)
             {
                 var vLeft = Vector512.LoadUnsafe(ref leftRef, i);
-
                 var vResult = vLeft + vRight;
                 vResult.StoreUnsafe(ref destRef, i);
             }
@@ -121,6 +120,11 @@ public static void Add(Span<float> dest, ReadOnlySpan<float> left, float scalar)
         }
     }
 
+    public static void Add(Span<float> dest, float lhs, ReadOnlySpan<float> rhs)
+    {
+        Add(dest, rhs, lhs);
+    }
+
     public static void Add(Span<float> dest, ReadOnlySpan<float> left, ReadOnlySpan<float> right, ReadOnlySpan<float> third)
     {
         EnsureSameSize(dest, left, right, third);
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagAnd.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagAnd.cs
index 423f229..e6eb7e0 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagAnd.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagAnd.cs
@@ -89,6 +89,17 @@ public static void FlagAnd(Span<float> dest, float lhs, ReadOnlySpan<float> rhs)
         
     }
 
+    /// <summary>
+    /// dest[i] = value[i] != 0 AND data != 0 ? 1.0f : 0.0f
+    /// </summary>
+    /// <param name="dest">The destination span.</param>
+    /// <param name="lhs">The data span.</param>
+    /// <param name="rhs">The scalar value to compare against.</param>
+    public static void FlagAnd(Span<float> dest, ReadOnlySpan<float> lhs, float rhs)
+    {
+        FlagAnd(dest, rhs, lhs);
+    }
+
     /// <summary>
     /// dest[i] = value[i] != 0 AND data != 0 ? 1.0f : 0.0f
     /// </summary>
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfEquals.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfEquals.cs
index 7d51675..a4e1e9c 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfEquals.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfEquals.cs
@@ -31,7 +31,7 @@ public static partial class VectorHelper
 {
 
     /// <summary>
-    /// dest[i] = value == data[i] ? 1.0f : 0.0f
+    /// dest[i] = lhs == rhs[i] ? 1.0f : 0.0f
     /// </summary>
     /// <param name="dest">The destination span.</param>
     /// <param name="lhs">The scalar value to compare against.</param>
@@ -87,7 +87,19 @@ public static void FlagIfEquals(Span<float> dest, float lhs, ReadOnlySpan<float>
     }
 
     /// <summary>
-    /// dest[i] = value[i] == data[i] ? 1.0f : 0.0f
+    /// dest[i] = lhs[i] == rhs ? 1.0f : 0.0f
+    /// </summary>
+    /// <param name="dest">The destination span.</param>
+    /// <param name="lhs">The data span.</param>
+    /// <param name="rhs">The scalar value to compare against.</param>
+    public static void FlagIfEquals(Span<float> dest, ReadOnlySpan<float> lhs, float rhs)
+    {
+        // Since the order does not matter, just reverse the sides.
+        FlagIfEquals(dest, rhs, lhs);
+    }
+
+    /// <summary>
+    /// dest[i] = lhs[i] == rhs[i] ? 1.0f : 0.0f
     /// </summary>
     /// <param name="dest">The destination span.</param>
     /// <param name="lhs">The scalar value to compare against.</param>
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThan.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThan.cs
index 9f2664d..ee3d2b3 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThan.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThan.cs
@@ -84,6 +84,62 @@ public static void FlagIfGreaterThan(Span<float> dest, float lhs, ReadOnlySpan<f
 
     }
 
+    /// <summary>
+    /// dest[i] = lhs[i] > rhs ? 1.0f : 0.0f
+    /// </summary>
+    /// <param name="dest">The destination span.</param>
+    /// <param name="lhs">The data span.</param>
+    /// <param name="rhs">The scalar value to compare against.</param>
+    public static void FlagIfGreaterThan(Span<float> dest, ReadOnlySpan<float> lhs, float rhs)
+    {
+        EnsureSameSize(dest, lhs);
+
+        nuint i = 0;
+        var length = (nuint)lhs.Length;
+        ref var pDest = ref MemoryMarshal.GetReference(dest);
+        ref var pLhs = ref MemoryMarshal.GetReference(lhs);
+        if (Vector512.IsHardwareAccelerated && length >= (nuint)Vector512<float>.Count)
+        {
+            var vZero = Vector512<float>.Zero;
+            var vOne = Vector512<float>.One;
+            var rhsV = Vector512.Create(rhs);
+            for (; i <= length - (nuint)Vector512<float>.Count; i += (nuint)Vector512<float>.Count)
+            {
+                var lhsV = Vector512.LoadUnsafe(ref pLhs, i);
+                var destV = Blend(vZero, vOne, Vector512.GreaterThan(lhsV, rhsV));
+                destV.StoreUnsafe(ref pDest, i);
+            }
+
+            if (i <= length - (nuint)Vector256<float>.Count)
+            {
+                var vZero256 = Vector256<float>.Zero;
+                var vOne256 = Vector256<float>.One;
+                var lhsV = Vector256.LoadUnsafe(ref pLhs, i);
+                var destV = Blend(vZero256, vOne256, Vector256.GreaterThan(lhsV, rhsV.GetLower()));
+                destV.StoreUnsafe(ref pDest, i);
+                i += (nuint)Vector256<float>.Count;
+            }
+        }
+        else if (Vector256.IsHardwareAccelerated && length >= (nuint)Vector256<float>.Count)
+        {
+            var vZero = Vector256<float>.Zero;
+            var vOne = Vector256<float>.One;
+            var rhsV = Vector256.Create(rhs);
+            for (; i <= length - (nuint)Vector256<float>.Count; i += (nuint)Vector256<float>.Count)
+            {
+                var lhsV = Vector256.LoadUnsafe(ref pLhs, i);
+                var destV = Blend(vZero, vOne, Vector256.GreaterThan(lhsV, rhsV));
+                destV.StoreUnsafe(ref pDest, i);
+            }
+        }
+        // Process the remainder.
+        for (; i < length; i++)
+        {
+            Unsafe.Add(ref pDest, i) = (Unsafe.Add(ref pLhs, i) > rhs ) ? 1.0f : 0.0f;
+        }
+
+    }
+
     /// <summary>
     /// dest[i] = lhs[i] > rhs[i] ? 1.0f : 0.0f
     /// </summary>
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThanOrEqual.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThanOrEqual.cs
index 889bbf5..025209f 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThanOrEqual.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfGreaterThanOrEqual.cs
@@ -84,6 +84,61 @@ public static void FlagIfGreaterThanOrEqual(Span<float> dest, float lhs, ReadOnl
 
     }
 
+    /// <summary>
+    /// dest[i] = lhs[i] >= rhs ? 1.0f : 0.0f
+    /// </summary>
+    /// <param name="dest">The destination span.</param>
+    /// <param name="lhs">The data span.</param>
+    /// <param name="rhs">The scalar value to compare against.</param>
+    public static void FlagIfGreaterThanOrEqual(Span<float> dest, ReadOnlySpan<float> lhs, float rhs)
+    {
+        EnsureSameSize(dest, lhs);
+
+        nuint i = 0;
+        var length = (nuint)lhs.Length;
+        ref var pDest = ref MemoryMarshal.GetReference(dest);
+        ref var pLhs = ref MemoryMarshal.GetReference(lhs);
+        if (Vector512.IsHardwareAccelerated && length >= (nuint)Vector512<float>.Count)
+        {
+            var vZero = Vector512<float>.Zero;
+            var vOne = Vector512<float>.One;
+            var rhsV = Vector512.Create(rhs);
+            for (; i <= length - (nuint)Vector512<float>.Count; i += (nuint)Vector512<float>.Count)
+            {
+                var lhsV = Vector512.LoadUnsafe(ref pLhs, i);
+                var destV = Blend(vZero, vOne, Vector512.GreaterThanOrEqual(lhsV, rhsV));
+                destV.StoreUnsafe(ref pDest, i);
+            }
+
+            if (i <= length - (nuint)Vector256<float>.Count)
+            {
+                var vZero256 = Vector256<float>.Zero;
+                var vOne256 = Vector256<float>.One;
+                var lhsV = Vector256.LoadUnsafe(ref pLhs, i);
+                var destV = Blend(vZero256, vOne256, Vector256.GreaterThanOrEqual(lhsV, rhsV.GetLower()));
+                destV.StoreUnsafe(ref pDest, i);
+                i += (nuint)Vector256<float>.Count;
+            }
+        }
+        else if (Vector256.IsHardwareAccelerated && length >= (nuint)Vector256<float>.Count)
+        {
+            var vZero = Vector256<float>.Zero;
+            var vOne = Vector256<float>.One;
+            var rhsV = Vector256.Create(rhs);
+            for (; i <= length - (nuint)Vector256<float>.Count; i += (nuint)Vector256<float>.Count)
+            {
+                var lhsV = Vector256.LoadUnsafe(ref pLhs, i);
+                var destV = Blend(vZero, vOne, Vector256.GreaterThanOrEqual(lhsV, rhsV));
+                destV.StoreUnsafe(ref pDest, i);
+            }
+        }
+        // Process the remainder.
+        for (; i < length; i++)
+        {
+            Unsafe.Add(ref pDest, i) = (Unsafe.Add(ref pLhs, i) >= rhs) ? 1.0f : 0.0f;
+        }
+    }
+
     /// <summary>
     /// dest[i] = lhs[i] >= rhs[i] ? 1.0f : 0.0f
     /// </summary>
@@ -154,7 +209,7 @@ public static void FlagIfGreaterThanOrEqual(float[] dest, int destIndex, float l
     /// </summary>
     public static void FlagIfGreaterThanOrEqual(float[] dest, int destIndex, float[] lhs, int lhsIndex, float rhs, int length)
     {
-        FlagIfLessThanOrEqual(dest, destIndex, rhs, lhs, lhsIndex, length);
+        FlagIfGreaterThanOrEqual(dest, destIndex, rhs, lhs, lhsIndex, length);
     }
 
     /// <summary>
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThan.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThan.cs
index 4d8c4c6..2b573f9 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThan.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThan.cs
@@ -84,6 +84,62 @@ public static void FlagIfLessThan(Span<float> dest, float lhs, ReadOnlySpan<floa
 
     }
 
+        /// <summary>
+    /// dest[i] = lhs[i] < rhs ? 1.0f : 0.0f
+    /// </summary>
+    /// <param name="dest">The destination span.</param>
+    /// <param name="lhs">The data span.</param>
+    /// <param name="rhs">The scalar value to compare against.</param>
+    public static void FlagIfLessThan(Span<float> dest, ReadOnlySpan<float> lhs, float rhs)
+    {
+        EnsureSameSize(dest, lhs);
+
+        nuint i = 0;
+        nuint length = (nuint)lhs.Length;
+        ref var pDest = ref MemoryMarshal.GetReference(dest);
+        ref var pLhs = ref MemoryMarshal.GetReference(lhs);
+        if (Vector512.IsHardwareAccelerated && length >= (nuint)Vector512<float>.Count)
+        {
+            var vZero = Vector512<float>.Zero;
+            var vOne = Vector512<float>.One;
+            var rhsV = Vector512.Create(rhs);
+            for (; i <= length - (nuint)Vector512<float>.Count; i += (nuint)Vector512<float>.Count)
+            {
+                var lhsV = Vector512.LoadUnsafe(ref pLhs, i);
+                var destV = Blend(vZero, vOne, Vector512.LessThan(lhsV, rhsV));
+                destV.StoreUnsafe(ref pDest, i);
+            }
+
+            if (i <= length - (nuint)Vector256<float>.Count)
+            {
+                var vZero256 = Vector256<float>.Zero;
+                var vOne256 = Vector256<float>.One;
+                var rhsV256 = Vector256.Create(rhs);
+                var lhsV = Vector256.LoadUnsafe(ref pLhs, i);
+                var destV = Blend(vZero256, vOne256, Vector256.LessThan(lhsV, rhsV256));
+                destV.StoreUnsafe(ref pDest, i);
+                i += (nuint)Vector256<float>.Count;
+            }
+        }
+        else if (Vector256.IsHardwareAccelerated && length >= (nuint)Vector256<float>.Count)
+        {
+            var vZero = Vector256<float>.Zero;
+            var vOne = Vector256<float>.One;
+            var rhsV = Vector256.Create(rhs);
+            for (; i <= length - (nuint)Vector256<float>.Count; i += (nuint)Vector256<float>.Count)
+            {
+                var lhsV = Vector256.LoadUnsafe(ref pLhs, i);
+                var destV = Blend(vZero, vOne, Vector256.LessThan(lhsV, rhsV));
+                destV.StoreUnsafe(ref pDest, i);
+            }
+        }
+        // Process the remainder.
+        for (; i < length; i++)
+        {
+            Unsafe.Add(ref pDest, i) = (Unsafe.Add(ref pLhs, i) < rhs) ? 1.0f : 0.0f;
+        }
+    }
+
     /// <summary>
     /// dest[i] = lhs[i] < rhs[i] ? 1.0f : 0.0f
     /// </summary>
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThanOrEqual.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThanOrEqual.cs
index 8492fe4..c3cce06 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThanOrEqual.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfLessThanOrEqual.cs
@@ -82,7 +82,56 @@ public static void FlagIfLessThanOrEqual(Span<float> dest, float lhs, ReadOnlySp
         {
             Unsafe.Add(ref pDest, i) = (lhs <= Unsafe.Add(ref pRhs, i)) ? 1.0f : 0.0f;
         }
+    }
+
+    public static void FlagIfLessThanOrEqual(Span<float> dest, ReadOnlySpan<float> lhs, float rhs)
+    {
+        EnsureSameSize(dest, lhs);
 
+        nuint i = 0;
+        nuint length = (nuint)lhs.Length;
+        ref var pDest = ref MemoryMarshal.GetReference(dest);
+        ref var pLhs = ref MemoryMarshal.GetReference(lhs);
+        if (Vector512.IsHardwareAccelerated && length >= (nuint)Vector512<float>.Count)
+        {
+            var vZero = Vector512<float>.Zero;
+            var vOne = Vector512<float>.One;
+            var rhsV = Vector512.Create(rhs);
+            for (; i <= length - (nuint)Vector512<float>.Count; i += (nuint)Vector512<float>.Count)
+            {
+                var lhsV = Vector512.LoadUnsafe(ref pLhs, i);
+                var destV = Blend(vZero, vOne, Vector512.LessThanOrEqual(lhsV, rhsV));
+                destV.StoreUnsafe(ref pDest, i);
+            }
+
+            if (i <= length - (nuint)Vector256<float>.Count)
+            {
+                var vZero256 = Vector256<float>.Zero;
+                var vOne256 = Vector256<float>.One;
+                var rhsV256 = Vector256.Create(rhs);
+                var lhsV = Vector256.LoadUnsafe(ref pLhs, i);
+                var destV = Blend(vZero256, vOne256, Vector256.LessThanOrEqual(lhsV, rhsV256));
+                destV.StoreUnsafe(ref pDest, i);
+                i += (nuint)Vector256<float>.Count;
+            }
+        }
+        else if (Vector256.IsHardwareAccelerated && length >= (nuint)Vector256<float>.Count)
+        {
+            var vZero = Vector256<float>.Zero;
+            var vOne = Vector256<float>.One;
+            var rhsV = Vector256.Create(rhs);
+            for (; i <= length - (nuint)Vector256<float>.Count; i += (nuint)Vector256<float>.Count)
+            {
+                var lhsV = Vector256.LoadUnsafe(ref pLhs, i);
+                var destV = Blend(vZero, vOne, Vector256.LessThanOrEqual(lhsV, rhsV));
+                destV.StoreUnsafe(ref pDest, i);
+            }
+        }
+        // Process the remainder.
+        for (; i < length; i++)
+        {
+            Unsafe.Add(ref pDest, i) = (Unsafe.Add(ref pLhs, i) <= rhs) ? 1.0f : 0.0f;
+        }
     }
 
     /// <summary>
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfNotEquals.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfNotEquals.cs
index ccbf3c1..2ab5f74 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfNotEquals.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagIfNotEquals.cs
@@ -28,7 +28,7 @@ public static partial class VectorHelper
 {
 
     /// <summary>
-    /// dest[i] = value != data[i] ? 1.0f : 0.0f
+    /// dest[i] = lhs != rhs[i] ? 1.0f : 0.0f
     /// </summary>
     /// <param name="dest">The destination span.</param>
     /// <param name="lhs">The scalar value to compare against.</param>
@@ -83,6 +83,18 @@ public static void FlagIfNotEquals(Span<float> dest, float lhs, ReadOnlySpan<flo
 
     }
 
+    /// <summary>
+    /// dest[i] = lhs[i] != rhs ? 1.0f : 0.0f
+    /// </summary>
+    /// <param name="dest">The destination span.</param>
+    /// <param name="lhs">The scalar value to compare against.</param>
+    /// <param name="rhs">The data span.</param>
+    public static void FlagIfNotEquals(Span<float> dest, ReadOnlySpan<float> lhs, float rhs)
+    {
+        // The order does not matter, so we can just call the other function
+        FlagIfNotEquals(dest, rhs, lhs);
+    }
+
     /// <summary>
     /// dest[i] = value[i] != data[i] ? 1.0f : 0.0f
     /// </summary>
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagOr.cs b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagOr.cs
index e5b6e7f..c271d4d 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagOr.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Conditions/FlagOr.cs
@@ -31,7 +31,7 @@ namespace TMG.Utilities;
 public static partial class VectorHelper
 {
     /// <summary>
-    /// dest[i] = value != 0 OR data != 0 ? 1.0f : 0.0f
+    /// dest[i] = lhs != 0 OR rhs != 0 ? 1.0f : 0.0f
     /// </summary>
     /// <param name="dest">The destination span.</param>
     /// <param name="lhs">The scalar value to compare against.</param>
@@ -91,6 +91,17 @@ public static void FlagOr(Span<float> dest, float lhs, ReadOnlySpan<float> rhs)
 
     }
 
+    /// <summary>
+    /// dest[i] = lhs[i] != 0 OR rhs != 0 ? 1.0f : 0.0f
+    /// </summary>
+    /// <param name="dest">The destination span.</param>
+    /// <param name="lhs">The scalar value to compare against.</param>
+    /// <param name="rhs">The data span.</param>
+    public static void FlagOr(Span<float> dest, ReadOnlySpan<float> lhs, float rhs)
+    {
+        FlagOr(dest, rhs, lhs);
+    }
+
     /// <summary>
     /// dest[i] = value[i] != 0 OR data != 0 ? 1.0f : 0.0f
     /// </summary>
diff --git a/src/TMG-Framework/Utilities/VectorHelper/Multiply.cs b/src/TMG-Framework/Utilities/VectorHelper/Multiply.cs
index dd998c8..c12afee 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/Multiply.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/Multiply.cs
@@ -255,6 +255,18 @@ public static void Multiply(Span<float> dest,
         }
     }
 
+    /// <summary>
+    /// Dest[i] = lhs * rhs[i]
+    /// </summary>
+    /// <param name="dest">The location to store the values into.</param>
+    /// <param name="left">The scalar value that is being multiplied.</param>
+    /// <param name="right">The span of values that is being multiplied.</param>
+    public static void Multiply(Span<float> dest,
+        float left, ReadOnlySpan<float> right)
+    {
+        Multiply(dest, right, left);
+    }
+
     /// <summary>
     /// Dest[i] = lhs[i] * rhs[i] * third
     /// </summary>
diff --git a/src/TMG-Framework/Utilities/VectorHelper/VectorHelper.cs b/src/TMG-Framework/Utilities/VectorHelper/VectorHelper.cs
index 41171fc..af049bd 100644
--- a/src/TMG-Framework/Utilities/VectorHelper/VectorHelper.cs
+++ b/src/TMG-Framework/Utilities/VectorHelper/VectorHelper.cs
@@ -1248,6 +1248,57 @@ public static bool AreBoundedBy(float[] data, int dataIndex, float baseNumber, f
         return AreBoundedBy(new Span<float>(data, dataIndex, length), baseNumber, maxVarriation);
     }
 
+    internal static void ReplaceIfNaN(Span<float> dest, Span<float> source, Span<float> replacement)
+    {
+        if (dest.Length != source.Length || dest.Length != replacement.Length)
+        {
+            throw new ArgumentException("All spans must be the same length");
+        }
+        ref var pDest = ref MemoryMarshal.GetReference(dest);
+        ref var pSource = ref MemoryMarshal.GetReference(source);
+        ref var pReplacement = ref MemoryMarshal.GetReference(replacement);
+
+        nuint length = (nuint)dest.Length;
+        nuint i = 0;
+        if (Vector512.IsHardwareAccelerated && length >= (nuint)Vector512<float>.Count)
+        {
+            var end = (nuint)(dest.Length - Vector512<float>.Count);
+            for (; i <= end; i += (nuint)Vector512<float>.Count)
+            {
+                var vSource = Vector512.LoadUnsafe(ref pSource, i);
+                var vReplace = Vector512.LoadUnsafe(ref pReplacement, i);
+                var result = SelectIfFinite(vSource, vReplace);
+                Vector512.StoreUnsafe(result, ref pDest, i);
+            }
+            if ((nuint)length - i >= (nuint)Vector256<float>.Count)
+            {
+                var vSource = Vector256.LoadUnsafe(ref pSource, i);
+                var vReplace = Vector256.LoadUnsafe(ref pReplacement, i);
+                var result = SelectIfFinite(vSource, vReplace);
+                Vector256.StoreUnsafe(result, ref pDest, i);
+                i += (nuint)Vector256<float>.Count;
+            }
+        }
+        else if (Vector256.IsHardwareAccelerated && length >= (nuint)Vector256<float>.Count)
+        {
+            var end = (nuint)(dest.Length - Vector256<float>.Count);
+            for (; i <= end; i += (nuint)Vector256<float>.Count)
+            {
+                var vSource = Vector256.LoadUnsafe(ref pSource, i);
+                var vReplace = Vector256.LoadUnsafe(ref pReplacement, i);
+                var result = SelectIfFinite(vSource, vReplace);
+                Vector256.StoreUnsafe(result, ref pDest, i);
+            }
+        }
+        
+        // Process the remainder
+        for (; i < length; i++)
+        {
+            dest[(int)i] = !float.IsNaN(source[(int)i]) ? source[(int)i] : replacement[(int)i];
+        }
+        
+    }
+
     internal static void ReplaceIfNaN(float[] dest, float[] source, float[] replacement, int offset, int length)
     {
         if (dest == null || source == null || replacement == null)
@@ -1293,6 +1344,51 @@ public static void Negate(float[] dest, float[] source, int offset, int length)
         }
     }
 
+    public static void Negate(Span<float> dest, Span<float> source)
+    {
+        if (dest.Length != source.Length)
+        {
+            throw new ArgumentException("Both spans must be the same length");
+        }
+        nuint i = 0;
+        nuint length = (nuint)dest.Length;
+        ref var pDest = ref MemoryMarshal.GetReference(dest);
+        ref var pSource = ref MemoryMarshal.GetReference(source);
+
+        if (Vector512.IsHardwareAccelerated && length >= (nuint)Vector512<float>.Count)
+        {
+            for (; i <= length - (nuint)Vector512<float>.Count; i += (nuint)Vector512<float>.Count)
+            {
+                var vSource = Vector512.LoadUnsafe(ref pSource, i);
+                var result = Vector512.Negate(vSource);
+                Vector512.StoreUnsafe(result, ref pDest, i);
+            }
+
+            if ((nuint)length - i >= (nuint)Vector256<float>.Count)
+            {
+                var vSource = Vector256.LoadUnsafe(ref pSource, i);
+                var result = Vector256.Negate(vSource);
+                Vector256.StoreUnsafe(result, ref pDest, i);
+                i += (nuint)Vector256<float>.Count;
+            }    
+        }
+        else if(Vector256.IsHardwareAccelerated && length >= (nuint)Vector256<float>.Count)
+        {
+            for (; i <= length - (nuint)Vector256<float>.Count; i += (nuint)Vector256<float>.Count)
+            {
+                var vSource = Vector256.LoadUnsafe(ref pSource, i);
+                var result = Vector256.Negate(vSource);
+                Vector256.StoreUnsafe(result, ref pDest, i);
+            }
+        }
+
+        // Process the remaining data.
+        for (; i < (nuint)dest.Length; i++)
+        {
+            Unsafe.Add(ref pDest, i) = -Unsafe.Add(ref pSource, i);
+        }
+    }
+
     /// <summary>
     /// Is the mask is 1, then the RHS is selected LHS if 0.
     /// </summary>
diff --git a/tests/TMG-Framework.Test/ArbitaryParameterParser.cs b/tests/TMG-Framework.Test/ArbitaryParameterParser.cs
index 83a4dca..76012c8 100644
--- a/tests/TMG-Framework.Test/ArbitaryParameterParser.cs
+++ b/tests/TMG-Framework.Test/ArbitaryParameterParser.cs
@@ -28,7 +28,7 @@ public class ArbitraryParameterParserTest
         [TestMethod]
         public void TestCharParsing()
         {
-            string error = null;
+            string? error = null;
             var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(char), "1", ref error);
             if (!(obj.Value is char))
             {
@@ -44,7 +44,7 @@ public void TestCharParsing()
         [TestMethod]
         public void TestDateTimeParsing()
         {
-            string error = null;
+            string? error = null;
             var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(DateTime), "10:00 AM", ref error);
             if (!(obj.Value is DateTime))
             {
@@ -60,7 +60,7 @@ public void TestDateTimeParsing()
         [TestMethod]
         public void TestFloatParsing()
         {
-            string error = null;
+            string? error = null;
             var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(float), "12345.123", ref error);
             if (!(obj.Value is float))
             {
@@ -76,7 +76,7 @@ public void TestFloatParsing()
         [TestMethod]
         public void TestIntegerParsing()
         {
-            string error = null;
+            string? error = null;
             var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(int), "12345", ref error);
             if (!(obj.Value is int))
             {
@@ -92,7 +92,7 @@ public void TestIntegerParsing()
         [TestMethod]
         public void TestStringParsing()
         {
-            string error = null;
+            string? error = null;
             var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(string), "12345.123", ref error);
             if (!(obj.Value is string))
             {
@@ -108,7 +108,7 @@ public void TestStringParsing()
         [TestMethod]
         public void TestTestStructParsing()
         {
-            string error = null;
+            string? error = null;
             var obj = ArbitraryParameterParser.ArbitraryParameterParse(typeof(TestStruct), "10:00 AM", ref error);
             if (!(obj.Value is TestStruct))
             {
@@ -124,7 +124,7 @@ public void TestTestStructParsing()
         private struct TestStruct
         {
             // ReSharper disable once UnusedMember.Local
-            public static bool TryParse(ref string error, string input, out TestStruct output)
+            public static bool TryParse(ref string? error, string input, out TestStruct output)
             {
                 output = default(TestStruct);
                 if (input.Length > 0)
diff --git a/tests/TMG-Framework.Test/Data/CategoriesTest.cs b/tests/TMG-Framework.Test/Data/CategoriesTest.cs
index d87d7c4..c5bcf69 100644
--- a/tests/TMG-Framework.Test/Data/CategoriesTest.cs
+++ b/tests/TMG-Framework.Test/Data/CategoriesTest.cs
@@ -30,9 +30,12 @@ public class CategoriesTest
         [TestMethod]
         public void CreateMap()
         {
-            string error = null;
+            string? error = null;
             var set = new List<int>() { 2, 6, 4, 8, 10 };
-            var categories = Categories.CreateCategories(set, ref error);
+            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));
diff --git a/tests/TMG-Framework.Test/Data/CategoryMapTest.cs b/tests/TMG-Framework.Test/Data/CategoryMapTest.cs
index 1b2d693..b4fbfb1 100644
--- a/tests/TMG-Framework.Test/Data/CategoryMapTest.cs
+++ b/tests/TMG-Framework.Test/Data/CategoryMapTest.cs
@@ -29,10 +29,16 @@ public class CategoryMapTest
         [TestMethod]
         public void Aggregate()
         {
-            string error = null;
-            Categories a = Categories.CreateCategories(new List<int> { 1, 3, 5, 7 }, 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);
-            Categories b = Categories.CreateCategories(new List<int> { 2, 4 }, ref 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)>()
@@ -48,7 +54,7 @@ public void Aggregate()
             va.Data[2] = 2;
             va.Data[3] = 4;
             Assert.IsTrue(map.AggregateToDestination(va, out var result, ref error), error);
-            Assert.HasCount(2, result.Data);
+            Assert.AreEqual(2, result.Data.Length);
             Assert.AreSame(b, result.Categories);
             Assert.AreEqual(10, result.Data[0]);
             Assert.AreEqual(6, result.Data[1]);
@@ -57,10 +63,16 @@ public void Aggregate()
         [TestMethod]
         public void CreateIndex()
         {
-            string error = null;
-            Categories a = Categories.CreateCategories(new List<int> { 1, 3, 5, 7 }, 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);
-            Categories b = Categories.CreateCategories(new List<int> { 2, 4 }, ref 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)>()
@@ -80,10 +92,16 @@ public void CreateIndex()
         [TestMethod]
         public void CreateReverseIndex()
         {
-            string error = null;
-            Categories a = Categories.CreateCategories(new List<int> { 1, 3, 5, 7 }, 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);
-            Categories b = Categories.CreateCategories(new List<int> { 2, 4 }, ref 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)>()
diff --git a/tests/TMG-Framework.Test/Data/MatrixTest.cs b/tests/TMG-Framework.Test/Data/MatrixTest.cs
index fe2bec6..5c9b127 100644
--- a/tests/TMG-Framework.Test/Data/MatrixTest.cs
+++ b/tests/TMG-Framework.Test/Data/MatrixTest.cs
@@ -62,8 +62,12 @@ public void GetFlatRowIndex()
 
         private static Categories CreateMap()
         {
-            string error = null;
-            return Categories.CreateCategories(new List<int>() { 2, 6, 4, 8, 10 }, 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;
         }
     }
 }
diff --git a/tests/TMG-Framework.Test/Data/RangeTest.cs b/tests/TMG-Framework.Test/Data/RangeTest.cs
index bca4d46..abdef52 100644
--- a/tests/TMG-Framework.Test/Data/RangeTest.cs
+++ b/tests/TMG-Framework.Test/Data/RangeTest.cs
@@ -58,9 +58,9 @@ public void ToStringTest()
         [TestMethod()]
         public void TryParseTestFail()
         {
-            string error = null;
+            string? error = null;
             string rangeString = "{1-2,4-5},{11-12,14-15";
-            bool actual = RangeSetSet.TryParse(ref error, rangeString, out RangeSetSet output);
+            bool actual = RangeSetSet.TryParse(ref error, rangeString, out RangeSetSet? output);
             Assert.IsNotNull(error);
             Assert.IsNull(output);
             Assert.IsFalse(actual);
@@ -74,7 +74,7 @@ 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);
+            var actual = RangeSetSet.TryParse(rangeString, out RangeSetSet? output);
             Assert.AreEqual(outputExpected, output);
             Assert.IsTrue(actual);
         }
@@ -85,10 +85,10 @@ public void TryParseTestNonError()
         [TestMethod()]
         public void TryParseTestSuccess()
         {
-            string error = null;
+            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);
+            var actual = RangeSetSet.TryParse(ref error, rangeString, out RangeSetSet? output);
             Assert.IsNull(error);
             Assert.AreEqual(outputExpected, output);
             Assert.IsTrue(actual);
diff --git a/tests/TMG-Framework.Test/Data/VectorTest.cs b/tests/TMG-Framework.Test/Data/VectorTest.cs
index df3bd67..779376c 100644
--- a/tests/TMG-Framework.Test/Data/VectorTest.cs
+++ b/tests/TMG-Framework.Test/Data/VectorTest.cs
@@ -46,8 +46,12 @@ public void CreateVector()
 
         private static Categories CreateMap()
         {
-            string error = null;
-            return Categories.CreateCategories(new List<int>() { 2, 6, 4, 8, 10 }, 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;
         }
     }
 }
diff --git a/tests/TMG-Framework.Test/Loading/TestLoadCategoryMapFromThirdNormalizedCSV.cs b/tests/TMG-Framework.Test/Loading/TestLoadCategoryMapFromThirdNormalizedCSV.cs
index 06b122d..98fd0a9 100644
--- a/tests/TMG-Framework.Test/Loading/TestLoadCategoryMapFromThirdNormalizedCSV.cs
+++ b/tests/TMG-Framework.Test/Loading/TestLoadCategoryMapFromThirdNormalizedCSV.cs
@@ -42,8 +42,11 @@ public class TestLoadCategoryMapFromThirdNormalizedCSV
         [TestMethod]
         public void LoadMapWithoutDestinations()
         {
-            string error = null;
-            var baseCategories = Categories.CreateCategories(new List<int> { 1, 2, 3, 4 }, ref error);
+            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
             {
@@ -54,7 +57,7 @@ public void LoadMapWithoutDestinations()
                     DestinationColumn = Helper.CreateParameter(1),
                     BaseCategories = Helper.CreateParameter(baseCategories),
                     DestinationCategories = null,
-                    CSVStream = Helper.CreateParameter(pipe.GetReadStream(null))
+                    CSVStream = Helper.CreateParameter(pipe.GetReadStream(null!))
                 };
                 var map = module.Invoke();
                 Assert.IsNotNull(map);
@@ -76,9 +79,15 @@ public void LoadMapWithoutDestinations()
         [TestMethod]
         public void LoadMapWithDestinations()
         {
-            string error = null;
-            var baseCategories = Categories.CreateCategories(new List<int> { 1, 2, 3, 4 }, ref error);
-            var destinationCategories = Categories.CreateCategories(new List<int> { 1, 2 }, ref error);
+            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
             {
@@ -89,7 +98,7 @@ public void LoadMapWithDestinations()
                     DestinationColumn = Helper.CreateParameter(1),
                     BaseCategories = Helper.CreateParameter(baseCategories),
                     DestinationCategories = Helper.CreateParameter(destinationCategories),
-                    CSVStream = Helper.CreateParameter(pipe.GetReadStream(null))
+                    CSVStream = Helper.CreateParameter(pipe.GetReadStream(null!))
                 };
                 var map = module.Invoke();
                 Assert.IsNotNull(map);
@@ -113,9 +122,15 @@ public void LoadMapWithBadDestinations()
         {
             Helper.ThrowsException<XTMFRuntimeException>(() =>
             {
-                string error = null;
-                var baseCategories = Categories.CreateCategories(new List<int> { 1, 2, 3, 4 }, ref error);
-                var destinationCategories = Categories.CreateCategories(new List<int> { 1 }, ref error);
+                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
                 {
@@ -126,7 +141,7 @@ public void LoadMapWithBadDestinations()
                         DestinationColumn = Helper.CreateParameter(1),
                         BaseCategories = Helper.CreateParameter(baseCategories),
                         DestinationCategories = Helper.CreateParameter(destinationCategories),
-                        CSVStream = Helper.CreateParameter(pipe.GetReadStream(null))
+                        CSVStream = Helper.CreateParameter(pipe.GetReadStream(null!))
                     };
                     // We expect this to throw
                     var _ = module.Invoke();
@@ -146,9 +161,15 @@ public void LoadMapWithBadBase()
         {
             Helper.ThrowsException<XTMFRuntimeException>(() =>
             {
-                string error = null;
-                var baseCategories = Categories.CreateCategories(new List<int> { 1, 2, 4 }, ref error);
-                var destinationCategories = Categories.CreateCategories(new List<int> { 1, 2 }, ref error);
+                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
                 {
@@ -159,7 +180,7 @@ public void LoadMapWithBadBase()
                         DestinationColumn = Helper.CreateParameter(1),
                         BaseCategories = Helper.CreateParameter(baseCategories),
                         DestinationCategories = Helper.CreateParameter(destinationCategories),
-                        CSVStream = Helper.CreateParameter(pipe.GetReadStream(null))
+                        CSVStream = Helper.CreateParameter(pipe.GetReadStream(null!))
                     };
                     // We expect this to throw
                     var _ = module.Invoke();
@@ -178,7 +199,7 @@ public void LoadMapWithBadBase()
         private static MemoryPipe CreateMapPipe()
         {
             var pipe = new MemoryPipe();
-            var writeStream = pipe.GetWriteStream(null);
+            var writeStream = pipe.GetWriteStream(null!);
             var writer = new StreamWriter(writeStream);
             writer.WriteLine("Zone,PD");
             writer.WriteLine("1,1");
diff --git a/tests/TMG-Framework.Test/Loading/TestLoadVector.cs b/tests/TMG-Framework.Test/Loading/TestLoadVector.cs
index 8ee96b7..72c6e30 100644
--- a/tests/TMG-Framework.Test/Loading/TestLoadVector.cs
+++ b/tests/TMG-Framework.Test/Loading/TestLoadVector.cs
@@ -65,7 +65,7 @@ internal static string WriteVectorCSV(Categories categories, float[] data)
         try
         {
             var vector = new Vector(categories);
-            Array.Copy(data, vector.Data, vector.Data.Length);
+            data.AsSpan().CopyTo(vector.Data);
             var save = new TMG.Saving.SaveVectorAsCSV()
             {
                 MapColumnName = Helper.CreateParameter("Zone"),
diff --git a/tests/TMG-Framework.Test/Processing/TestEvaluateMatrix.cs b/tests/TMG-Framework.Test/Processing/TestEvaluateMatrix.cs
index b1c120b..ff28e6e 100644
--- a/tests/TMG-Framework.Test/Processing/TestEvaluateMatrix.cs
+++ b/tests/TMG-Framework.Test/Processing/TestEvaluateMatrix.cs
@@ -47,7 +47,7 @@ public void LargeMatrixMathFMA()
                     Helper.CreateParameter(c, "C"),
                 }
             };
-            string error = null;
+            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 4c59e04..73d35b1 100644
--- a/tests/TMG-Framework.Test/Processing/TestEvaluateScalar.cs
+++ b/tests/TMG-Framework.Test/Processing/TestEvaluateScalar.cs
@@ -47,7 +47,7 @@ public void TestLargeScalar()
                     Helper.CreateParameter(c, "C"),
                 }
             };
-            string error = null;
+            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 8809e8b..83b464f 100644
--- a/tests/TMG-Framework.Test/Processing/TestEvaluateVector.cs
+++ b/tests/TMG-Framework.Test/Processing/TestEvaluateVector.cs
@@ -46,7 +46,7 @@ public void LargeVectorMathFMA()
                     Helper.CreateParameter(c, "C"),
                 }
             };
-            string error = null;
+            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/TestIntegerizeMatrix.cs b/tests/TMG-Framework.Test/Processing/TestIntegerizeMatrix.cs
index 0003a86..8af9737 100644
--- a/tests/TMG-Framework.Test/Processing/TestIntegerizeMatrix.cs
+++ b/tests/TMG-Framework.Test/Processing/TestIntegerizeMatrix.cs
@@ -36,9 +36,15 @@ public class TestIntegerizeMatrix
         [TestMethod]
         public void IntegerizeZeroMatrix()
         {
-            string error = null;
-            var zones = Categories.CreateCategories(new List<int>() { 1, 2, 3, 4 }, ref error);
-            var pds = Categories.CreateCategories(new List<int>() { 1, 2, }, 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)>()
             {
                 new (0, 0),
@@ -63,9 +69,15 @@ public void IntegerizeZeroMatrix()
         [TestMethod]
         public void IntegerizeIdentityMatrix()
         {
-            string error = null;
-            var zones = Categories.CreateCategories(new List<int>() { 1, 2, 3, 4 }, ref error);
-            var pds = Categories.CreateCategories(new List<int>() { 1, 2, }, 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)>()
             {
                 new (0, 0),
@@ -96,9 +108,15 @@ public void IntegerizeIdentityMatrix()
         [TestMethod]
         public void IntegerizeRealMatrix()
         {
-            string error = null;
-            var zones = Categories.CreateCategories(new List<int>() { 1, 2, 3, 4 }, ref error);
-            var pds = Categories.CreateCategories(new List<int>() { 1, 2, }, 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)>()
             {
                 new (0, 0),
diff --git a/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsCSV.cs b/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsCSV.cs
index f0c34dc..559f2f4 100644
--- a/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsCSV.cs
+++ b/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsCSV.cs
@@ -87,7 +87,7 @@ public void SaveMatrixAsCSVAsMatrixAndLoad()
                         RowCategories = Helper.CreateParameter(categories),
                         ColumnCategories = Helper.CreateParameter(categories)
                     }.Invoke(readStream);
-                    string error = null;
+                    string? error = null;
                     Assert.IsTrue(MatrixHelper.Compare(a, readMatrix, ref error), error);
                 }
             }
@@ -161,7 +161,7 @@ public void SaveMatrixAsCSVAsThirdNormalizedAndLoad()
                         DestinationColumn = Helper.CreateParameter(1),
                         DataColumn = Helper.CreateParameter(2),
                     }.Invoke(readStream);
-                    string error = null;
+                    string? error = null;
                     Assert.IsTrue(MatrixHelper.Compare(a, readMatrix, ref error), error);
                 }
             }
diff --git a/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsMTX.cs b/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsMTX.cs
index fadb9fe..db30cb4 100644
--- a/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsMTX.cs
+++ b/tests/TMG-Framework.Test/Saving/TestSaveMatrixAsMTX.cs
@@ -72,7 +72,7 @@ public void SaveMatrixAsMTXAsMatrixAndLoad()
                     {
                         Categories = Helper.CreateParameter(categories)
                     }.Invoke(readStream);
-                    string error = null;
+                    string? error = null;
                     Assert.IsTrue(MatrixHelper.Compare(a, readMatrix, ref error), error);
                 }
             }
diff --git a/tests/TMG-Framework.Test/Saving/TestSaveVectorAsCSV.cs b/tests/TMG-Framework.Test/Saving/TestSaveVectorAsCSV.cs
index 1450639..48b86ea 100644
--- a/tests/TMG-Framework.Test/Saving/TestSaveVectorAsCSV.cs
+++ b/tests/TMG-Framework.Test/Saving/TestSaveVectorAsCSV.cs
@@ -19,6 +19,7 @@ You should have received a copy of the GNU General Public License
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Text;
 using TMG.Saving;
@@ -82,7 +83,7 @@ public void SaveVectorAsCSVAndLoad()
                         MapColumn = Helper.CreateParameter(0),
                         DataColumn = Helper.CreateParameter(1)
                     }.Invoke(readStream);
-                    string error = null;
+                    string? error = null;
                     Assert.IsTrue(Compare(a, readVector, ref error), error);
                 }
             }
@@ -96,7 +97,8 @@ public void SaveVectorAsCSVAndLoad()
             }
         }
 
-        internal static bool Compare(Vector expected, Vector test, ref string error)
+        internal static bool Compare(Vector expected, Vector test, 
+            [NotNullWhen(false)] ref string? error)
         {
             if (expected.Categories != test.Categories)
             {
diff --git a/tests/TMG-Framework.Test/TMG-Framework.Test.csproj b/tests/TMG-Framework.Test/TMG-Framework.Test.csproj
index af1e0ae..c8fe0c2 100644
--- a/tests/TMG-Framework.Test/TMG-Framework.Test.csproj
+++ b/tests/TMG-Framework.Test/TMG-Framework.Test.csproj
@@ -3,6 +3,7 @@
   <PropertyGroup>    
     <TargetFramework>net10.0</TargetFramework>    
     <RootNamespace>TMG.Test</RootNamespace>    
+    <Nullable>enable</Nullable>
     <ApplicationIcon />    
     <OutputTypeEx>library</OutputTypeEx>    
     <StartupObject />
diff --git a/tests/TMG-Framework.Test/Utilities/Helper.cs b/tests/TMG-Framework.Test/Utilities/Helper.cs
index f1ab0e6..852ee37 100644
--- a/tests/TMG-Framework.Test/Utilities/Helper.cs
+++ b/tests/TMG-Framework.Test/Utilities/Helper.cs
@@ -38,7 +38,7 @@ internal static class Helper
         /// <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)
+        internal static IFunction<T> CreateParameter<T>(T value, string? moduleName = null)
         {
             return new BasicParameter<T>()
             {
@@ -69,7 +69,7 @@ public override K Invoke(T context)
         /// <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)
+        internal static IFunction<T, K> CreateModule<T, K>(Func<T, K> innerFunction, string? moduleName = null)
         {
             return new CustomizableModule<T, K>(innerFunction)
             {
@@ -110,12 +110,12 @@ internal static WriteStream CreateWriteStreamFromFile(string fileName)
         /// </summary>
         /// <param name="action"></param>
         /// <param name="expectedExceptionType"></param>
-        public static void ThrowsException(Action action, Type expectedExceptionType = null)
+        public static void ThrowsException(Action action, Type? expectedExceptionType = null)
         {
             try
             {
                 action();
-                Assert.Fail("Expected exception of type " + expectedExceptionType.FullName);
+                Assert.Fail("Expected exception of type " + (expectedExceptionType?.FullName ?? "null"));
             }
             catch (Exception ex)
             {
diff --git a/tests/TMG-Framework.Test/Utilities/MapHelper.cs b/tests/TMG-Framework.Test/Utilities/MapHelper.cs
index d4a5977..716d110 100644
--- a/tests/TMG-Framework.Test/Utilities/MapHelper.cs
+++ b/tests/TMG-Framework.Test/Utilities/MapHelper.cs
@@ -96,8 +96,12 @@ internal static Categories LoadMap(string fileName)
         /// <returns>A new Categories with sparse space in [1..numberOfElements]</returns>
         internal static Categories LoadMap(int numberOfElements)
         {
-            string error = null;
-            return Categories.CreateCategories(Enumerable.Range(1, numberOfElements).ToList(), ref error);
+            string? error = null;
+            if (!Categories.CreateCategories(Enumerable.Range(1, numberOfElements).ToList(), out var categories, ref error))
+            {
+                Assert.Fail(error);
+            }
+            return categories;
         }
     }
 }
diff --git a/tests/TMG-Framework.Test/Utilities/MatrixHelper.cs b/tests/TMG-Framework.Test/Utilities/MatrixHelper.cs
index 6181ea8..7bcbbda 100644
--- a/tests/TMG-Framework.Test/Utilities/MatrixHelper.cs
+++ b/tests/TMG-Framework.Test/Utilities/MatrixHelper.cs
@@ -19,6 +19,7 @@ You should have received a copy of the GNU General Public License
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Text;
 using TMG.Saving;
@@ -34,9 +35,10 @@ internal static string WriteMatrixToCSVMatrix(Categories categories, float[][] d
             try
             {
                 var matrix = new Matrix(categories, categories);
+                
                 for (int i = 0; i < data.Length; i++)
                 {
-                    Array.Copy(data[i], 0, matrix.Data, i * data.Length, data[i].Length);
+                    data[i].AsSpan().CopyTo(matrix.GetRow(i));    
                 }
                 var save = new SaveMatrixAsCSV()
                 {
@@ -67,7 +69,7 @@ internal static string WriteMatrixToCSVThirdNormalized(Categories categories, fl
                 var matrix = new Matrix(categories, categories);
                 for (int i = 0; i < data.Length; i++)
                 {
-                    Array.Copy(data[i], 0, matrix.Data, i * data.Length, data[i].Length);
+                    data[i].AsSpan().CopyTo(matrix.GetRow(i));
                 }
                 var save = new SaveMatrixAsCSV()
                 {
@@ -90,7 +92,8 @@ internal static string WriteMatrixToCSVThirdNormalized(Categories categories, fl
             }
         }
 
-        internal static bool Compare(Matrix expected, Matrix testCase, ref string error)
+        internal static bool Compare(Matrix expected, Matrix testCase, 
+            [NotNullWhen(false)] ref string? error)
         {
             if(expected.ColumnCategories != testCase.ColumnCategories)
             {
@@ -125,7 +128,7 @@ internal static string WriteMatrixToMTX(Categories categories, float[][] data)
                 var matrix = new Matrix(categories, categories);
                 for (int i = 0; i < data.Length; i++)
                 {
-                    Array.Copy(data[i], 0, matrix.Data, i * data.Length, data[i].Length);
+                    data[i].AsSpan().CopyTo(matrix.GetRow(i));
                 }
                 var save = new SaveMatrixAsMTX();
                 using (var writeStream = Helper.CreateWriteStreamFromFile(fileName))
diff --git a/tests/TMG-Framework.Test/Utilities/TestCompiler.cs b/tests/TMG-Framework.Test/Utilities/TestCompiler.cs
index 8d2e43d..a2ac0cb 100644
--- a/tests/TMG-Framework.Test/Utilities/TestCompiler.cs
+++ b/tests/TMG-Framework.Test/Utilities/TestCompiler.cs
@@ -34,9 +34,17 @@ public class TestCompiler
 
         public TestCompiler()
         {
-            string error = null;
-            matrixCategories = Categories.CreateCategories(new List<int>() { 1, 2 }, ref error);
-            vectorCategories = Categories.CreateCategories(new List<int>() { 1, 2, 3, 4 }, ref error);
+            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;
         }
         /// <summary>
         /// Create a new simple matrix for testing.
@@ -77,7 +85,7 @@ private IFunction<Vector> CreateVectorData(string name, float m1, float m2, floa
         }
 
         /// <summary>
-        /// Create a new simple matrix for testing.
+        /// Create a new simple scalar for testing.
         /// </summary>
         /// <param name="name"></param>
         /// <param name="m11"></param>
@@ -617,8 +625,8 @@ public void TestMatrixAddWithTripleBrackets()
         [TestMethod]
         public void TestMatrixSumRows()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("SumRows(A + B)", out Expression ex, ref error));
+            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),
@@ -634,8 +642,8 @@ public void TestMatrixSumRows()
         [TestMethod]
         public void TestMatrixSumColumns()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("SumColumns(A + B)", out Expression ex, ref error));
+            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),
@@ -651,8 +659,8 @@ public void TestMatrixSumColumns()
         [TestMethod]
         public void TestMatrixAsHorizontal()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("AsHorizontal(SumRows(A + B))", out Expression ex, ref error));
+            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),
@@ -668,8 +676,8 @@ public void TestMatrixAsHorizontal()
         [TestMethod]
         public void TestMatrixSum()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("Sum(A + B)", out Expression ex, ref error));
+            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),
@@ -682,8 +690,8 @@ public void TestMatrixSum()
         [TestMethod]
         public void TestVectorSum()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("Sum(SumRows(A + B))", out Expression ex, ref error));
+            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),
@@ -716,8 +724,8 @@ public void TestMatrixAbs()
         [TestMethod]
         public void TestVectorAbs()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("Abs(SumRows(A) - SumRows(B))", out Expression ex, ref error));
+            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),
@@ -732,8 +740,8 @@ public void TestVectorAbs()
         [TestMethod]
         public void TestScalarAbs()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("Abs(Sum(A) - Sum(B))", out Expression ex, ref error));
+            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),
@@ -746,8 +754,8 @@ public void TestScalarAbs()
         [TestMethod]
         public void TestMatrixAvg()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("Avg(A - B)", out Expression ex, ref error));
+            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),
@@ -760,8 +768,8 @@ public void TestMatrixAvg()
         [TestMethod]
         public void TestVectorAvg()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("Avg(SumRows(A) - SumRows(B))", out Expression ex, ref error));
+            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),
@@ -774,8 +782,8 @@ public void TestVectorAvg()
         [TestMethod]
         public void TestMatrixAvgRows()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("AvgRows(A)", out Expression ex, ref error));
+            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),
@@ -791,8 +799,8 @@ public void TestMatrixAvgRows()
         [TestMethod]
         public void TestMatrixAvgColumns()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("AvgColumns(A)", out Expression ex, ref error));
+            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),
@@ -808,8 +816,8 @@ public void TestMatrixAvgColumns()
         [TestMethod]
         public void TestPI()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("PI( )", out Expression ex, ref error));
+            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);
@@ -818,8 +826,8 @@ public void TestPI()
         [TestMethod]
         public void TestE()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("E( )", out Expression ex, ref error));
+            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);
@@ -938,8 +946,8 @@ public void TestOr()
         [TestMethod]
         public void TestMatrixLength()
         {
-            string error = null;
-            Assert.IsTrue(Compiler.Compile("Length(A + 1) + Length(B - 1)", out Expression ex, ref error));
+            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),
@@ -973,8 +981,8 @@ public void TestIdentity()
         [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}");
+            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));
@@ -998,8 +1006,8 @@ public void TestOptimizeFusedMultiplyAdd()
         [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}");
+            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),
@@ -1014,8 +1022,8 @@ public void TestOptimizeAddLiterals()
         [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}");
+            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),
@@ -1030,8 +1038,8 @@ public void TestOptimizeSubtractLiterals()
         [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}");
+            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),
@@ -1046,8 +1054,8 @@ public void TestOptimizeMultiplyLiterals()
         [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}");
+            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),
@@ -1280,9 +1288,9 @@ public void TestNormalizeRows()
         [TestMethod]
         public void TestSubtractionOrder()
         {
-            string error = null;
+            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}");
+            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);
@@ -1293,8 +1301,8 @@ public void TestSubtractionOrder()
         /// </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}");
+            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;
@@ -1310,12 +1318,12 @@ private static Expression CompareMatrix(string equation, IModule[] data, float m
         /// </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}");
+            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);
+                Assert.Fail(result.ErrorMessage ?? "Unknown error");
             }
             Assert.IsTrue(result.IsVectorResult);
             var flat = result.VectorData.Data;
@@ -1331,12 +1339,12 @@ private static Expression CompareVector(string equation, IModule[] data, float m
         /// </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}");
+            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);
+                Assert.Fail(result.ErrorMessage ?? "Unknown error");
             }
             Assert.IsTrue(result.IsValue);
             Assert.AreEqual(m11, result.LiteralValue, 0.00001f);