diff --git a/src/main/java/org/flag4j/linalg/decompositions/hess/SymmHess.java b/src/main/java/org/flag4j/linalg/decompositions/hess/SymmHess.java
index 3d1e302ed..0e5870e00 100644
--- a/src/main/java/org/flag4j/linalg/decompositions/hess/SymmHess.java
+++ b/src/main/java/org/flag4j/linalg/decompositions/hess/SymmHess.java
@@ -26,9 +26,7 @@
 
 
 import org.flag4j.dense.Matrix;
-import org.flag4j.linalg.decompositions.Decomposition;
 import org.flag4j.linalg.transformations.Householder;
-import org.flag4j.util.Flag4jConstants;
 import org.flag4j.util.ParameterChecks;
 import org.flag4j.util.exceptions.LinearAlgebraException;
 
@@ -52,7 +50,7 @@
  *      [ 0 0 0 x x ]]</pre>
  * </p>
  */
-public class SymmHess implements Decomposition<Matrix> {
+public class SymmHess extends RealHess {
 
     /**
      * Flag indicating if an explicit check should be made that the matrix to be decomposed is symmetric.
@@ -60,59 +58,11 @@ public class SymmHess implements Decomposition<Matrix> {
     protected boolean enforceSymmetric;
 
     /**
-     * Storage for the symmetric tri-diagonal matrix and if requested, the Householder vectors used to bring the original matrix
-     * into upper Hessenberg form. The symmetric tri-diagonal matrix will be stored in the principle diagonal and the first
-     * super-diagonal (Since the matrix is symmetric there is no need to store the first sub-diagonal). The rows of the strictly
-     * lower-triangular portion of the matrix will be used to store the Householder vectors used to transform the source matrix
-     * to upper Hessenburg form if it is requested via {@link #computeQ}. These can be used to compute the full orthogonal matrix
-     * {@code Q} of the Hessenberg decomposition.
-     */
-    protected Matrix transformMatrix;
-    /**
-     * For storing norms of columns in A when computing Householder reflectors.
-     */
-    double norm;
-    /**
-     * Size of the symmetric matrix to be decomposed. That is, the number of rows and columns.
-     */
-    protected int size;
-    /**
-     * Flag indicating if the orthogonal transformation matrix from the Hessenburg decomposition should be explicitly computed.
-     */
-    protected boolean computeQ;
-    /**
-     * Stores the scalar factor for the current Householder reflector.
-     */
-    double currentFactor;
-    /**
-     * Storage of the scalar factors for the Householder reflectors used in the decomposition.
-     */
-    protected double[] qFactors;
-    /**
-     * For storing a Householder vectors.
-     */
-    protected double[] householderVector;
-    /**
-     * For temporarily storage when applying Householder vectors. This is useful for
-     * avoiding unneeded garbage collection and for improving cache performance when traversing columns.
-     */
-    protected double[] workArray;
-    /**
-     * Flag indicating if a Householder reflector was needed for the current column meaning an update needs to be applied.
-     */
-    protected boolean applyUpdate;
-    /**
-     * Stores the shifted value of the first entry in a Householder vector.
-     */
-    private double shift;
-
-
-    /**
-     * Constructs a Hessenberg decomposer for symmetric matrices. To compute the
+     * Constructs a Hessenberg decomposer for symmetric matrices. By default, the Householder vectors used in the decomposition will be
+     * stored so that the full orthogonal {@code Q} matrix can be formed by calling {@link #getQ()}.
      */
     public SymmHess() {
-        computeQ = false;
-        enforceSymmetric = false;
+        super();
     }
 
 
@@ -122,8 +72,7 @@ public SymmHess() {
      * If true, then the {@code Q} matrix will be computed explicitly.
      */
     public SymmHess(boolean computeQ) {
-        enforceSymmetric = false;
-        this.computeQ = computeQ;
+        super(computeQ);
     }
 
 
@@ -137,8 +86,8 @@ public SymmHess(boolean computeQ) {
      * matrix is not symmetric, then the values in the upper triangular portion of the matrix are taken to be the values.
      */
     public SymmHess(boolean computeQ, boolean enforceSymmetric) {
+        super(computeQ);
         this.enforceSymmetric = enforceSymmetric;
-        this.computeQ = computeQ;
     }
 
 
@@ -150,14 +99,7 @@ public SymmHess(boolean computeQ, boolean enforceSymmetric) {
      */
     @Override
     public SymmHess decompose(Matrix src) {
-        setUp(src);
-        int stop = size-2;
-
-        for(int k=0; k<stop; k++) {
-            computeHouseholder(k+1);
-            if(applyUpdate) updateData(k+1);
-        }
-
+        super.decompose(src);
         return this;
     }
 
@@ -166,17 +108,18 @@ public SymmHess decompose(Matrix src) {
      * Gets the Hessenberg matrix from the decomposition. The matrix will be symmetric tri-diagonal.
      * @return The symmetric tri-diagonal (Hessenberg) matrix from this decomposition.
      */
+    @Override
     public Matrix getH() {
-        Matrix H = new Matrix(size);
+        Matrix H = new Matrix(numRows);
         H.entries[0] = transformMatrix.entries[0];
 
         int idx1;
         int idx0;
-        int rowOffset = H.numRows;
+        int rowOffset = numRows;
 
-        for(int i=1; i<size; i++) {
+        for(int i=1; i<numRows; i++) {
             idx1 = rowOffset + i;
-            idx0 = idx1 - H.numRows;
+            idx0 = idx1 - numRows;
 
             H.entries[idx1] = transformMatrix.entries[idx1]; // extract diagonal value.
 
@@ -186,114 +129,32 @@ public Matrix getH() {
             H.entries[idx1 - 1] = a;
 
             // Update row index.
-            rowOffset += H.numRows;
+            rowOffset += numRows;
         }
 
-        if(size > 1) {
-            int rowColBase = size*size - 1;
+        if(numRows > 1) {
+            int rowColBase = numRows*numRows - 1;
             H.entries[rowColBase] = transformMatrix.entries[rowColBase];
-            H.entries[rowColBase - 1] = transformMatrix.entries[rowColBase - size];
+            H.entries[rowColBase - 1] = transformMatrix.entries[rowColBase - numRows];
         }
 
         return H;
     }
 
 
-    /**
-     * <p>Gets the unitary {@code Q} matrix from the Hessenberg decomposition.</p>
-     *
-     * <p>Note, if the reflectors for this decomposition were not saved, then {@code Q} can not be computed and this method will be
-     * null.</p>
-     *
-     * @return The {@code Q} matrix from the {@code QR} decomposition. Note, if the reflectors for this decomposition were not saved,
-     * then {@code Q} can not be computed and this method will return {@code null}.
-     */
-    public Matrix getQ() {
-        if(!computeQ)
-            return null;
-
-        Matrix Q = Matrix.I(size);
-
-        for(int j=size - 1; j>=1; j--) {
-            householderVector[j] = 1.0; // Ensure first value of reflector is 1.
-
-            for(int i=j + 1; i<size; i++) {
-                householderVector[i] = transformMatrix.entries[i*size + j - 1]; // Extract column containing reflector vector.
-            }
-
-            if(qFactors[j]!=0) { // Otherwise, no reflector to apply.
-                Householder.leftMultReflector(Q, householderVector, qFactors[j], j, j, size, workArray);
-            }
-        }
-
-        return Q;
-    }
-
-
-    /**
-     * Computes the Householder vector for the first column of the sub-matrix with upper left corner at {@code (j, j)}.
-     *
-     * @param j Index of the upper left corner of the sub-matrix for which to compute the Householder vector for the first column.
-     *          That is, a Householder vector will be computed for the portion of column {@code j} below row {@code j}.
-     */
-    protected void computeHouseholder(int j) {
-        // Initialize storage array for Householder vector and compute maximum absolute value in jth column at or below jth row.
-        double maxAbs = findMaxAndInit(j);
-        norm = 0; // Ensure norm is reset.
-
-        applyUpdate = maxAbs >= Flag4jConstants.EPS_F64;
-
-        if(!applyUpdate) {
-            currentFactor = 0;
-        } else {
-            computePhasedNorm(j, maxAbs);
-
-            householderVector[j] = 1.0; // Ensure first value in Householder vector is one.
-            for(int i=j+1; i<size; i++) {
-                householderVector[i] /= shift; // Scale all but first entry of the Householder vector.
-            }
-        }
-
-        qFactors[j] = currentFactor; // Store the factor for the Householder vector.
-    }
-
-
-    /**
-     * Computes the norm of column {@code j} below the {@code j}th row of the matrix to be decomposed. The norm will have the same
-     * parity as the first entry in the sub-column.
-     * @param j Column to compute norm of below the {@code j}th row.
-     * @param maxAbs Maximum absolute value in the column. Used for scaling norm to minimize potential overflow issues.
-     */
-    protected void computePhasedNorm(int j, double maxAbs) {
-        // Computes the 2-norm of the column.
-        for(int i=j; i<size; i++) {
-            householderVector[i] /= maxAbs; // Scale entries of the householder vector to help reduce potential overflow.
-            double scaledValue = householderVector[i];
-            norm += scaledValue*scaledValue;
-        }
-        norm = Math.sqrt(norm); // Finish 2-norm computation for the column.
-
-        // Change sign of norm depending on first entry in column for stability purposes in Householder vector.
-        if(householderVector[j] < 0) norm = -norm;
-
-        shift = householderVector[j] + norm;
-        currentFactor = shift/norm;
-        norm *= maxAbs; // Rescale norm.
-    }
-
-
     /**
      * Finds the maximum value in {@link #transformMatrix} at column {@code j} at or below the {@code j}th row. This method also initializes
      * the first {@code numRows-j} entries of the storage array {@link #householderVector} to the entries of this column.
      * @param j Index of column (and starting row) to compute max of.
      * @return The maximum value in {@link #transformMatrix} at column {@code j} at or below the {@code j}th row.
      */
+    @Override
     protected double findMaxAndInit(int j) {
         double maxAbs = 0;
 
         // Compute max-abs value in row. (Equivalent to max value in column since matrix is symmetric.)
-        int rowU = (j-1)*size;
-        for(int i=j; i<size; i++) {
+        int rowU = (j-1)*numRows;
+        for(int i=j; i<numRows; i++) {
             double d = householderVector[i] = transformMatrix.entries[rowU + i];
             maxAbs = Math.max(Math.abs(d), maxAbs);
         }
@@ -308,17 +169,16 @@ protected double findMaxAndInit(int j) {
      * @throws LinearAlgebraException If the matrix is not symmetric and {@link #enforceSymmetric} is true or if the matrix is not
      * square regardless of the value of {@link #enforceSymmetric}.
      */
+    @Override
     protected void setUp(Matrix src) {
         if(enforceSymmetric && !src.isSymmetric()) // If requested, check the matrix is symmetric.
             throw new LinearAlgebraException("Decomposition only supports symmetric matrices.");
         else
             ParameterChecks.assertSquareMatrix(src.shape); // Otherwise, Just ensure the matrix is square.
 
-        size = src.numRows;
-        householderVector = new double[size];
-        qFactors = new double[size];
-        workArray = new double[size];
-        copyUpperTri(src);
+        numRows = numCols = minAxisSize = src.numRows;
+        copyUpperTri(src);  // Initializes transform matrix.
+        initWorkArrays(numRows);
     }
 
 
@@ -326,13 +186,13 @@ protected void setUp(Matrix src) {
      * Copies the upper triangular portion of a matrix to the working matrix {@link #transformMatrix}.
      * @param src The source matrix to decompose of.
      */
-    protected void copyUpperTri(Matrix src) {
-        transformMatrix = new Matrix(size);
+    private void copyUpperTri(Matrix src) {
+        transformMatrix = new Matrix(numRows);
 
         // Copy upper triangular portion.
-        for(int i=0; i<size; i++) {
-            int pos = i*size + i;
-            System.arraycopy(src.entries, pos, transformMatrix.entries, pos, size - i);
+        for(int i=0; i<numRows; i++) {
+            int pos = i*numRows + i;
+            System.arraycopy(src.entries, pos, transformMatrix.entries, pos, numRows - i);
         }
     }
 
@@ -341,15 +201,16 @@ protected void copyUpperTri(Matrix src) {
      * Updates the {@link #transformMatrix} matrix using the computed Householder vector from {@link #computeHouseholder(int)}.
      * @param j Index of sub-matrix for which the Householder reflector was computed for.
      */
+    @Override
     protected void updateData(int j) {
         Householder.symmLeftRightMultReflector(transformMatrix, householderVector, currentFactor, j, workArray);
 
-        if(j < size) transformMatrix.entries[(j-1)*size + j] = -norm;
-        if(computeQ) {
+        if(j < numRows) transformMatrix.entries[(j-1)*numRows + j] = -norm;
+        if(storeReflectors) {
             // Store the Q matrix in the lower portion of the transformation data matrix.
             int col = j-1;
-            for(int i=j+1; i<size; i++) {
-                transformMatrix.entries[i*size + col] = householderVector[i];
+            for(int i=j+1; i<numRows; i++) {
+                transformMatrix.entries[i*numRows + col] = householderVector[i];
             }
         }
     }
diff --git a/src/main/java/org/flag4j/linalg/decompositions/unitary/RealUnitaryDecomposition.java b/src/main/java/org/flag4j/linalg/decompositions/unitary/RealUnitaryDecomposition.java
index ee8d059f7..fe97960f8 100644
--- a/src/main/java/org/flag4j/linalg/decompositions/unitary/RealUnitaryDecomposition.java
+++ b/src/main/java/org/flag4j/linalg/decompositions/unitary/RealUnitaryDecomposition.java
@@ -44,11 +44,11 @@ public abstract class RealUnitaryDecomposition extends UnitaryDecomposition<Matr
     /**
      * Scalar factor of the currently computed Householder reflector.
      */
-    private double currentFactor;
+    protected double currentFactor;
     /**
      * Stores the shifted value of the first entry in a Householder vector.
      */
-    private double shift;
+    protected double shift;
 
 
     /**
diff --git a/src/main/java/org/flag4j/linalg/decompositions/unitary/UnitaryDecomposition.java b/src/main/java/org/flag4j/linalg/decompositions/unitary/UnitaryDecomposition.java
index 1425c84a0..899648d6b 100644
--- a/src/main/java/org/flag4j/linalg/decompositions/unitary/UnitaryDecomposition.java
+++ b/src/main/java/org/flag4j/linalg/decompositions/unitary/UnitaryDecomposition.java
@@ -132,7 +132,6 @@ public void decomposeBase(T src) {
 
         for(int j=0; j<minAxisSize-offSet; j++) {
             computeHouseholder(j + subDiagonal); // Compute the householder reflector.
-
             if(applyUpdate) updateData(j + subDiagonal); // Update the upper-triangular matrix and store the reflectors.
         }
     }
@@ -173,7 +172,7 @@ public void decomposeBase(T src) {
      * Initializes storage and other parameters for the decomposition.
      * @param src Source matrix to be decomposed.
      */
-    private void setUp(T src) {
+    protected void setUp(T src) {
         transformMatrix = src.copy(); // Initialize QR as the matrix to be decomposed.
         numRows = transformMatrix.numRows();
         numCols = transformMatrix.numCols();
diff --git a/src/main/java/org/flag4j/linalg/solvers/exact/triangular/ComplexBackSolver.java b/src/main/java/org/flag4j/linalg/solvers/exact/triangular/ComplexBackSolver.java
index 05f8eccbf..1ebc3e85b 100644
--- a/src/main/java/org/flag4j/linalg/solvers/exact/triangular/ComplexBackSolver.java
+++ b/src/main/java/org/flag4j/linalg/solvers/exact/triangular/ComplexBackSolver.java
@@ -40,10 +40,6 @@ public class ComplexBackSolver extends BackSolver<CMatrix, CVector, CNumber[]> {
      * For computing determinant of coefficient matrix during solve.
      */
     protected CNumber det;
-    /**
-     * For checking against other values.
-     */
-    private final CNumber z = CNumber.zero();
 
 
     /**
@@ -92,7 +88,7 @@ public CVector solve(CMatrix U, CVector b) {
         int uIndex;
         int n = b.size;
         x = new CVector(U.numRows);
-        det = U.entries[n*n-1];
+        det = U.entries[n*n-1].copy();
 
         x.entries[n-1] = b.entries[n-1].div(det);
 
@@ -134,12 +130,13 @@ public CMatrix solve(CMatrix U, CMatrix B) {
         int uIndex, xIndex;
         int n = B.numRows;
         X = new CMatrix(B.shape);
-        det = U.entries[n*n-1].copy();
+        det = U.entries[U.entries.length-1].copy();
 
         xCol = new CNumber[n];
 
         for(int j=0; j<B.numCols; j++) {
             X.entries[(n-1)*X.numCols + j] = B.entries[(n-1)*X.numCols + j].div(U.entries[n*n-1]);
+            det.multEq(U.entries[j*(n+1)]);
 
             // Store column to improve cache performance on innermost loop.
             for(int k=0; k<n; k++) {
@@ -150,9 +147,9 @@ public CMatrix solve(CMatrix U, CMatrix B) {
                 sum = new CNumber();
                 uIndex = i*U.numCols;
                 xIndex = i*X.numCols + j;
-
                 diag = U.entries[i*(n+1)];
-                det.multEq(diag);
+
+                if(j==0) det.multEq(diag);
 
                 for(int k=i+1; k<n; k++) {
                     sum.addEq(U.entries[uIndex + k].mult(xCol[k]));
@@ -187,12 +184,13 @@ public CMatrix solveIdentity(CMatrix U) {
         int uIndex, xIndex;
         int n = U.numRows;
         X = new CMatrix(U.shape);
-        det = U.entries[n*n-1].copy();
+        det = U.entries[U.entries.length-1].copy();
 
         xCol = new CNumber[n];
         X.entries[X.entries.length-1] = det.multInv();
 
         for(int j=0; j<U.numCols; j++) {
+
             // Store column to improve cache performance on innermost loop.
             for(int k=0; k<n; k++) {
                 xCol[k] = X.entries[k*X.numCols + j];
@@ -205,7 +203,7 @@ public CMatrix solveIdentity(CMatrix U) {
                 uIndex += i+1;
                 diag = U.entries[i*(n+1)];
 
-                det.multEq(diag);
+                if(j==0) det.multEq(diag);
 
                 for(int k=i+1; k<n; k++) {
                     sum.subEq(U.entries[uIndex++].mult(xCol[k]));
@@ -241,7 +239,7 @@ public CMatrix solveLower(CMatrix U, CMatrix L) {
         CNumber uValue = U.entries[n*n-1];
         int rowOffset = (n-1)*n;
         X = new CMatrix(L.shape);
-        det = uValue.copy();
+        det = U.entries[U.entries.length-1].copy();
 
         xCol = new CNumber[n];
 
@@ -259,7 +257,7 @@ public CMatrix solveLower(CMatrix U, CMatrix L) {
                 xIndex = uIndex + j;
                 diag = U.entries[i*(n+1)];
 
-                det.multEq(diag);
+                if(j==0) det.multEq(diag);
 
                 for(int k=i+1; k<n; k++) {
                     sum.addEq(U.entries[uIndex + k].mult(xCol[k]));
diff --git a/src/main/java/org/flag4j/linalg/solvers/exact/triangular/ComplexForwardSolver.java b/src/main/java/org/flag4j/linalg/solvers/exact/triangular/ComplexForwardSolver.java
index 8eb688f06..eff8cd32e 100644
--- a/src/main/java/org/flag4j/linalg/solvers/exact/triangular/ComplexForwardSolver.java
+++ b/src/main/java/org/flag4j/linalg/solvers/exact/triangular/ComplexForwardSolver.java
@@ -237,11 +237,12 @@ private CMatrix solveLowerIdentity(CMatrix L) {
             }
 
             for(int i=1; i<L.numRows; i++) {
+                if(j==0) det.multEq(L.entries[i*L.numCols + i]);
+
                 sum = (i==j) ? CNumber.one() : CNumber.zero();
                 lIndexStart = i*L.numCols;
                 xIndex = lIndexStart + j;
                 diag = L.entries[i*(L.numCols + 1)];
-                det.multEq(diag);
 
                 for(int k=0; k<i; k++) {
                     sum.subEq(L.entries[lIndexStart++].mult(xCol[k]));
@@ -368,7 +369,8 @@ private CMatrix solveLower(CMatrix L, CMatrix B) {
                 lIndexStart = i*L.numCols;
                 xIndex = i*X.numCols + j;
                 diag = L.entries[i*(L.numCols + 1)];
-                det.multEq(diag);
+
+                if(j==0) det.multEq(diag);
 
                 for(int k=0; k<i; k++) {
                     sum.addEq(L.entries[lIndexStart++].mult(xCol[k]));
diff --git a/src/main/java/org/flag4j/linalg/solvers/exact/triangular/RealBackSolver.java b/src/main/java/org/flag4j/linalg/solvers/exact/triangular/RealBackSolver.java
index f7eb0e8f5..0552dac78 100644
--- a/src/main/java/org/flag4j/linalg/solvers/exact/triangular/RealBackSolver.java
+++ b/src/main/java/org/flag4j/linalg/solvers/exact/triangular/RealBackSolver.java
@@ -86,11 +86,11 @@ public Vector solve(Matrix U, Vector b) {
         int uIndex;
         int n = b.size;
         x = new Vector(U.numRows);
-        det = 1;
+        det = U.entries[n*n-1];
 
-        x.entries[n-1] = b.entries[n-1]/U.entries[n*n-1];
+        x.entries[n-1] = b.entries[n-1]/det;
 
-        for(int i=n-2; i>-1; i--) {
+        for(int i=n-2; i>=0; i--) {
             sum = 0;
             uIndex = i*U.numCols;
 
@@ -130,7 +130,7 @@ public Matrix solve(Matrix U, Matrix B) {
         double uValue = U.entries[n*n-1];
         int rowOffset = (n-1)*B.numCols;
         X = new Matrix(B.shape);
-        det = 1;
+        det = U.entries[n*n-1];
 
         xCol = new double[n];
 
@@ -148,7 +148,7 @@ public Matrix solve(Matrix U, Matrix B) {
                 xIndex = i*X.numCols + j;
                 diag = U.entries[i*(n+1)];
 
-                det*=diag;
+                if(j==0) det *= diag;
 
                 for(int k=i+1; k<n; k++) {
                     sum += U.entries[uIndex + k]*xCol[k];
@@ -189,20 +189,20 @@ public Matrix solveIdentity(Matrix U) {
         xCol = new double[n];
         X.entries[X.entries.length-1] = 1.0/det;
 
-        for(int j=0; j<U.numCols; j++) {
+        for(int j=0; j<n; j++) {
             // Store column to improve cache performance on innermost loop.
             for(int k=0; k<n; k++) {
                 xCol[k] = X.entries[k*X.numCols + j];
             }
 
-            for(int i=n-2; i>-1; i--) {
+            for(int i=n-2; i>=0; i--) {
                 sum = (i == j) ? 1 : 0;
-                uIndex = i*U.numCols;
+                uIndex = i*n;
                 xIndex = uIndex + j;
                 uIndex += i+1;
                 diag = U.entries[i*(n+1)];
 
-                det*=diag;
+                if(j==0) det *= diag;
 
                 for(int k=i+1; k<n; k++) {
                     sum -= U.entries[uIndex++]*xCol[k];
@@ -256,9 +256,9 @@ public Matrix solveLower(Matrix U, Matrix L) {
                 sum = 0;
                 uIndex = i*U.numCols;
                 xIndex = uIndex + j;
-
                 diag = U.entries[i*(n+1)];
-                det*=diag;
+
+                if(j==0) det *= diag;
 
                 for(int k=i+1; k<n; k++) {
                     sum += U.entries[uIndex + k]*xCol[k];
diff --git a/src/main/java/org/flag4j/linalg/solvers/exact/triangular/RealForwardSolver.java b/src/main/java/org/flag4j/linalg/solvers/exact/triangular/RealForwardSolver.java
index 91384f593..beeefadf9 100644
--- a/src/main/java/org/flag4j/linalg/solvers/exact/triangular/RealForwardSolver.java
+++ b/src/main/java/org/flag4j/linalg/solvers/exact/triangular/RealForwardSolver.java
@@ -275,7 +275,8 @@ private Matrix solveLower(Matrix L, Matrix B) {
                 xIndex = i*X.numCols + j;
 
                 diag = L.entries[i*(L.numCols + 1)];
-                det *= diag;
+
+                if(j == 0) det *= diag;
 
                 for(int k=0; k<i; k++) {
                     sum += L.entries[lIndexStart++]*xCol[k];
@@ -364,7 +365,8 @@ private Matrix solveLowerIdentity(Matrix L) {
                 lIndexStart = i*L.numCols;
                 xIndex = lIndexStart + j;
                 diag = L.entries[i*(L.numCols + 1)];
-                det*=diag;
+
+                if(j==0) det*=diag;
 
                 for(int k=0; k<i; k++) {
                     sum -= L.entries[lIndexStart++]*xCol[k];
diff --git a/src/test/java/org/flag4j/linalg/MatrixInvertTests.java b/src/test/java/org/flag4j/linalg/MatrixInvertTests.java
new file mode 100644
index 000000000..6ba4a512d
--- /dev/null
+++ b/src/test/java/org/flag4j/linalg/MatrixInvertTests.java
@@ -0,0 +1,164 @@
+package org.flag4j.linalg;
+
+import org.flag4j.dense.Matrix;
+import org.flag4j.io.PrintOptions;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class MatrixInvertTests {
+
+    static Matrix A;
+    static Matrix exp;
+    static double[][] entries;
+    static double[][] expEntries;
+
+    @Test
+    void invTriUTest() {
+        // --------------------- Sub-case 1 ---------------------
+        entries = new double[][]{
+                {0.61158, 0.87596},
+                {0.0, 0.45014}};
+        A = new Matrix(entries);
+        expEntries = new double[][]{
+                {1.6351090617744204, -3.1818770465897748},
+                {0.0, 2.2215310792197984}};
+        exp = new Matrix(expEntries);
+
+        assertEquals(exp, Invert.invTriU(A));
+
+        // --------------------- Sub-case 2 ---------------------
+        entries = new double[][]{
+                {0.76978, 0.27277, 0.90265},
+                {0.0, 0.1561, 0.83679},
+                {0.0, 0.0, 0.00644}};
+        A = new Matrix(entries);
+        expEntries = new double[][]{
+                {1.299072462261945, -2.270006377522042, 112.87436002887036},
+                {0.0, 6.406149903907752, -832.3916425607092},
+                {0.0, 0.0, 155.27950310559004}};
+        exp = new Matrix(expEntries);
+
+        assertEquals(exp, Invert.invTriU(A));
+
+        // --------------------- Sub-case 3 ---------------------
+        entries = new double[][]{
+                {0.31673, 0.69142, 0.08349, 0.07415},
+                {0.0, 0.24664, 0.62689, 0.797},
+                {0.0, 0.0, 0.50857, 0.01702},
+                {0.0, 0.0, 0.0, 0.11526}};
+        A = new Matrix(entries);
+        expEntries = new double[][]{
+                {3.157263284185268, -8.850936506452229, 10.391811697373441, 57.6367923653548},
+                {0.0, 4.05449237755433, -4.997779512289427, -27.29800639954568},
+                {0.0, 0.0, 1.9662976581394893, -0.2903555972716823},
+                {0.0, 0.0, 0.0, 8.676036786395974}};
+        exp = new Matrix(expEntries);
+
+        assertEquals(exp, Invert.invTriU(A));
+
+        // --------------------- Sub-case 4 ---------------------
+        entries = new double[][]{
+                {0.21671, 0.00066, 0.09873, 0.57298, 0.22919, 0.6064, 0.53715, 0.36795, 0.22719, 0.47063},
+                {0.0, 0.77367, 0.70667, 0.43124, 0.64431, 0.77275, 0.30505, 0.83899, 0.3178, 0.50588},
+                {0.0, 0.0, 0.36696, 0.55825, 0.82823, 0.26704, 0.31807, 0.80966, 0.39851, 0.23385},
+                {0.0, 0.0, 0.0, 0.63701, 0.01634, 0.58154, 0.09358, 0.35212, 0.06829, 0.38112},
+                {0.0, 0.0, 0.0, 0.0, 0.22453, 0.3002, 0.44086, 0.68154, 0.74422, 0.2514},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.71469, 0.49553, 0.78324, 0.88894, 0.37997},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.47257, 0.7119, 0.92818, 0.42631},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.29617, 0.65823, 0.28397},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.38876, 0.3932},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.22844}};
+        A = new Matrix(entries);
+        expEntries = new double[][]{
+                {4.614461723040007, -0.0039364906707076725, -1.2339328702132952, -3.0665981398000906, 0.07587526255554107, -0.9865627105790509, -2.8410329779241246, 10.560903663350672, -9.877411328020631, 7.614045866631429},
+                {0.0, 1.2925407473470603, -2.489099002419193, 1.3063283876462979, 5.377473531360279, -3.7892255797235195, -0.46102392303739986, 0.3444759703335606, 0.15302971143503913, -1.9402048857914176},
+                {0.0, 0.0, 2.725092653150207, -2.388161839878657, -9.878327723043597, 5.07433555348961, 2.53335596408712, -1.387453772756238, 1.2342665604944696, -1.5018548065037962},
+                {0.0, 0.0, 0.0, 1.5698340685389556, -0.11424348051452606, -1.229379746977967, 1.0848231049490034, -0.9599035887977831, 1.7892514057757696, -4.359427837733901},
+                {0.0, 0.0, 0.0, 0.0, 4.453747828797933, -1.8707622860333004, -2.193242127527721, -0.029653144272670434, 1.0383508706701416, 0.5528954389871591},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 1.3992080482446934, -1.4671891236148993, -0.1736292487616131, 0.5975192374796691, -0.4019381597331419},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.1160886217914805, -5.086414862590252, 3.5598305330496074, -3.7534839669991142},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.376439207212074, -5.716826780952783, 5.642833341790496},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.5722810988784857, -4.427512379964194},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.377517072316582}};
+        exp = new Matrix(expEntries);
+
+        assertEquals(exp, Invert.invTriU(A));
+    }
+
+
+    @Test
+    void invTriLTest() {
+        PrintOptions.setPrecision(100);
+
+        // --------------------- Sub-case 1 ---------------------
+        entries = new double[][]{
+                {0.61158, 0.87596},
+                {0.0, 0.45014}};
+        A = new Matrix(entries).T();
+        expEntries = new double[][]{
+                {1.6351090617744204, -3.1818770465897748},
+                {0.0, 2.2215310792197984}};
+        exp = new Matrix(expEntries).T();
+
+        assertEquals(exp, Invert.invTriL(A));
+
+        // --------------------- Sub-case 2 ---------------------
+        entries = new double[][]{
+                {0.76978, 0.27277, 0.90265},
+                {0.0, 0.1561, 0.83679},
+                {0.0, 0.0, 0.00644}};
+        A = new Matrix(entries).T();
+        expEntries = new double[][]{
+                {1.299072462261945, -2.270006377522042, 112.87436002887034},
+                {0.0, 6.406149903907752, -832.3916425607092},
+                {0.0, 0.0, 155.27950310559004}};
+        exp = new Matrix(expEntries).T();
+
+        assertEquals(exp, Invert.invTriL(A));
+
+        // --------------------- Sub-case 3 ---------------------
+        entries = new double[][]{
+                {0.31673, 0.69142, 0.08349, 0.07415},
+                {0.0, 0.24664, 0.62689, 0.797},
+                {0.0, 0.0, 0.50857, 0.01702},
+                {0.0, 0.0, 0.0, 0.11526}};
+        A = new Matrix(entries).T();
+        expEntries = new double[][]{
+                {3.157263284185268, -8.85093650645223, 10.391811697373441, 57.63679236535481},
+                {0.0, 4.05449237755433, -4.997779512289427, -27.298006399545677},
+                {0.0, 0.0, 1.9662976581394893, -0.29035559727168236},
+                {0.0, 0.0, 0.0, 8.676036786395974}};
+        exp = new Matrix(expEntries).T();
+
+        assertEquals(exp, Invert.invTriL(A));
+
+        // --------------------- Sub-case 4 ---------------------
+        entries = new double[][]{
+                {0.21671, 0.00066, 0.09873, 0.57298, 0.22919, 0.6064, 0.53715, 0.36795, 0.22719, 0.47063},
+                {0.0, 0.77367, 0.70667, 0.43124, 0.64431, 0.77275, 0.30505, 0.83899, 0.3178, 0.50588},
+                {0.0, 0.0, 0.36696, 0.55825, 0.82823, 0.26704, 0.31807, 0.80966, 0.39851, 0.23385},
+                {0.0, 0.0, 0.0, 0.63701, 0.01634, 0.58154, 0.09358, 0.35212, 0.06829, 0.38112},
+                {0.0, 0.0, 0.0, 0.0, 0.22453, 0.3002, 0.44086, 0.68154, 0.74422, 0.2514},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.71469, 0.49553, 0.78324, 0.88894, 0.37997},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.47257, 0.7119, 0.92818, 0.42631},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.29617, 0.65823, 0.28397},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.38876, 0.3932},
+                {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.22844}};
+        A = new Matrix(entries).T();
+        expEntries = new double[][]{
+                {4.614461723040007, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                {-0.0039364906707076725, 1.2925407473470603, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                {-1.2339328702132955, -2.489099002419193, 2.725092653150207, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                {-3.0665981398000897, 1.3063283876462977, -2.3881618398786566, 1.5698340685389556, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                {0.07587526255554022, 5.377473531360278, -9.878327723043595, -0.11424348051452604, 4.453747828797933, 0.0, 0.0, 0.0, 0.0, 0.0},
+                {-0.9865627105790509, -3.789225579723521, 5.074335553489611, -1.229379746977967, -1.8707622860333004, 1.3992080482446934, 0.0, 0.0, 0.0, 0.0},
+                {-2.8410329779241246, -0.4610239230374004, 2.5333559640871197, 1.0848231049490031, -2.193242127527722, -1.4671891236148993, 2.1160886217914805, 0.0, 0.0, 0.0},
+                {10.56090366335067, 0.34447597033356486, -1.3874537727562395, -0.9599035887977826, -0.029653144272668908, -0.1736292487616129, -5.086414862590252, 3.376439207212074, 0.0, 0.0},
+                {-9.877411328020631, 0.15302971143503333, 1.2342665604944718, 1.7892514057757691, 1.0383508706701405, 0.5975192374796684, 3.559830533049607, -5.716826780952782, 2.5722810988784857, 0.0},
+                {7.614045866631427, -1.940204885791414, -1.5018548065037949, -4.359427837733902, 0.552895438987158, -0.40193815973314095, -3.753483966999114, 5.642833341790497, -4.4275123799641944, 4.377517072316582}};
+        exp = new Matrix(expEntries);
+
+        assertEquals(exp, Invert.invTriL(A));
+    }
+}
diff --git a/src/test/java/org/flag4j/linalg/decompositions/RealHessenburgTests.java b/src/test/java/org/flag4j/linalg/decompositions/RealHessenburgTests.java
index 3f84896f4..13d23ed3e 100644
--- a/src/test/java/org/flag4j/linalg/decompositions/RealHessenburgTests.java
+++ b/src/test/java/org/flag4j/linalg/decompositions/RealHessenburgTests.java
@@ -30,12 +30,6 @@ void hessDecompTestCase() {
 
         Assertions.assertEquals(new Matrix(A.shape.copy()).round(), A.sub(A_hat).round());
 
-        // ----------------------- Sub-case 1.1 -----------------------
-        hess = new RealHess();
-        hess.decompose(A);
-
-        Assertions.assertEquals(H, hess.getH());
-
         // ----------------------- Sub-case 2 -----------------------
         aEntries = new double[][]{
                 {1.44, 5.26, -35, 1.9},
diff --git a/src/test/java/org/flag4j/linalg/decompositions/RealSymmHessTests.java b/src/test/java/org/flag4j/linalg/decompositions/RealSymmHessTests.java
new file mode 100644
index 000000000..bbc43064e
--- /dev/null
+++ b/src/test/java/org/flag4j/linalg/decompositions/RealSymmHessTests.java
@@ -0,0 +1,83 @@
+package org.flag4j.linalg.decompositions;
+
+
+import org.flag4j.dense.Matrix;
+import org.flag4j.linalg.decompositions.hess.SymmHess;
+import org.flag4j.util.exceptions.LinearAlgebraException;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class RealSymmHessTests {
+
+    double[][] aEntries;
+    Matrix A, Q, H, A_hat;
+    SymmHess hess;
+
+    @Test
+    void symmHessDecompTestCase() {
+        // ----------------------- Sub-case 2 -----------------------
+        aEntries = new double[][]{
+                {100.2345, -8.1445},
+                {-8.1445, 100.2345}};
+        A = new Matrix(aEntries);
+        hess = new SymmHess(true).decompose(A);
+
+        H = hess.getH();
+        Q = hess.getQ();
+        A_hat = Q.mult(H).multTranspose(Q);
+
+        Assertions.assertEquals(new Matrix(A.shape.copy()), A.sub(A_hat).round());
+
+        // ----------------------- Sub-case 2 -----------------------
+        aEntries = new double[][]{
+                {1, 2, 3},
+                {2, 5, 6},
+                {3, 6, 9}};
+        A = new Matrix(aEntries);
+        hess = new SymmHess(true).decompose(A);
+
+        H = hess.getH();
+        Q = hess.getQ();
+        A_hat = Q.mult(H).multTranspose(Q);
+
+        Assertions.assertEquals(new Matrix(A.shape.copy()), A.sub(A_hat).round());
+
+        // ----------------------- Sub-case 3 -----------------------
+        aEntries = new double[][]{
+                {1,  -4,   2.5, 15, 0   },
+                {-4,  2,   8.1, 4,  1   },
+                {2.5, 8.1, 4,  -9,  8.25},
+                {15,  4,  -9, 10.3, 6   },
+                {0,   1,  8.25, 6, -18.5}};
+        A = new Matrix(aEntries);
+        hess = new SymmHess(true).decompose(A);
+
+        H = hess.getH();
+        Q = hess.getQ();
+        A_hat = Q.mult(H).multTranspose(Q);
+
+        Assertions.assertEquals(new Matrix(A.shape.copy()), A.sub(A_hat).round());
+
+        // ----------------------- Sub-case 4 -----------------------
+        aEntries = new double[][]{
+                {1.4, -0.002, 14.51},
+                {-0.002, 4.501, -9.14},
+                {14.51, -9.14, 16.5}};
+        A = new Matrix(aEntries);
+        hess = new SymmHess(true).decompose(A);
+        H = hess.getH();
+        Q = hess.getQ();
+        A_hat = Q.mult(H).multTranspose(Q);
+
+        Assertions.assertEquals(new Matrix(A.shape.copy()), A.sub(A_hat).round());
+
+        // ----------------------- Sub-case 5 -----------------------
+        aEntries = new double[][]{
+                {1.4, 5, 14.51},
+                {-0.002, 4.501, -9.14},
+                {11, -9.14, 16.5}};
+        A = new Matrix(aEntries);
+        hess = new SymmHess(true, true);
+        Assertions.assertThrows(LinearAlgebraException.class, ()->hess.decompose(A));
+    }
+}
diff --git a/src/test/java/org/flag4j/linalg/solvers/ComplexForwardSolverTests.java b/src/test/java/org/flag4j/linalg/solvers/ComplexForwardSolverTests.java
index 0016ab247..ad56f746d 100644
--- a/src/test/java/org/flag4j/linalg/solvers/ComplexForwardSolverTests.java
+++ b/src/test/java/org/flag4j/linalg/solvers/ComplexForwardSolverTests.java
@@ -125,7 +125,7 @@ void solveMatrixTestCase() {
         lEntries = new CNumber[][]{
                 {new CNumber(1.25, -9.25), new CNumber(), new CNumber()},
                 {new CNumber(-815.5, 1.444), new CNumber(2.45, 15.5), new CNumber()},
-                {new CNumber(0, -9.256), new CNumber(2.45, -83.2), new CNumber()}
+                {new CNumber(0, -9.256), new CNumber(2.45, -83.2), new CNumber(1)}
         };
         L = new CMatrix(lEntries);
         bEntries = new CNumber[][]{
diff --git a/target/flag4j-v0.0.1-beta.jar b/target/flag4j-v0.0.1-beta.jar
index 0e63e9921..bd0e3e4c4 100644
Binary files a/target/flag4j-v0.0.1-beta.jar and b/target/flag4j-v0.0.1-beta.jar differ