LA: rename matrix Data property for consistency (non-breaking)

src/Numerics/LinearAlgebra/Complex/DenseMatrix.cs

@@ -156,11 +156,21 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         /// Gets the matrix's data.
         /// </summary>
         /// <value>The matrix's data.</value>
+        [Obsolete("Use Values instead. Will be removed in future versions.")]
         public Complex[] Data
         {
             get { return _values; }
         }
 
+        /// <summary>
+        /// Gets the matrix's data.
+        /// </summary>
+        /// <value>The matrix's data.</value>
+        public Complex[] Values
+        {
+            get { return _values; }
+        }
+
         /// <summary>
         /// Creates a <c>DenseMatrix</c> for the given number of rows and columns.
         /// </summary>

src/Numerics/LinearAlgebra/Complex/Factorization/DenseCholesky.cs

@@ -69,7 +69,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
             // Create a new matrix for the Cholesky factor, then perform factorization (while overwriting).
             var factor = (DenseMatrix)matrix.Clone();
-            Control.LinearAlgebraProvider.CholeskyFactor(factor.Data, factor.RowCount);
+            Control.LinearAlgebraProvider.CholeskyFactor(factor.Values, factor.RowCount);
             CholeskyFactor = factor;
         }
 
@@ -120,11 +120,11 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
             }
 
             // Copy the contents of input to result.
-            CommonParallel.For(0, dinput.Data.Length, index => dresult.Data[index] = dinput.Data[index]);
+            CommonParallel.For(0, dinput.Values.Length, index => dresult.Values[index] = dinput.Values[index]);
 
             // Cholesky solve by overwriting result.
             var dfactor = (DenseMatrix)CholeskyFactor;
-            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Data, dfactor.RowCount, dresult.Data, dresult.ColumnCount);
+            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Values, dfactor.RowCount, dresult.Values, dresult.ColumnCount);
         }
 
         /// <summary>
@@ -173,7 +173,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
             // Cholesky solve by overwriting result.
             var dfactor = (DenseMatrix)CholeskyFactor;
-            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Data, dfactor.RowCount, dresult.Values, 1);
+            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Values, dfactor.RowCount, dresult.Values, 1);
         }
     }
 }

src/Numerics/LinearAlgebra/Complex/Factorization/DenseEvd.cs

@@ -95,8 +95,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                 var e = new double[order];
 
                 SymmetricTridiagonalize(matrixCopy, d, e, tau, order);
-                SymmetricDiagonalize(((DenseMatrix)MatrixEv).Data, d, e, order);
-                SymmetricUntridiagonalize(((DenseMatrix)MatrixEv).Data, matrixCopy, tau, order);
+                SymmetricDiagonalize(((DenseMatrix)MatrixEv).Values, d, e, order);
+                SymmetricUntridiagonalize(((DenseMatrix)MatrixEv).Values, matrixCopy, tau, order);
 
                 for (var i = 0; i < order; i++)
                 {
@@ -106,8 +106,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
             else
             {
                 var matrixH = matrix.ToArray();
-                NonsymmetricReduceToHessenberg(((DenseMatrix)MatrixEv).Data, matrixH, order);
-                NonsymmetricReduceHessenberToRealSchur(((DenseVector)VectorEv).Values, ((DenseMatrix)MatrixEv).Data, matrixH, order);
+                NonsymmetricReduceToHessenberg(((DenseMatrix)MatrixEv).Values, matrixH, order);
+                NonsymmetricReduceHessenberToRealSchur(((DenseVector)VectorEv).Values, ((DenseMatrix)MatrixEv).Values, matrixH, order);
             }
 
             MatrixD.SetDiagonal(VectorEv);
@@ -853,7 +853,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                         {
                             for (var i = 0; i < order; i++)
                             {
-                                value += ((DenseMatrix)MatrixEv).Data[(j * order) + i].Conjugate() * input.At(i, k);
+                                value += ((DenseMatrix)MatrixEv).Values[(j * order) + i].Conjugate() * input.At(i, k);
                             }
 
                             value /= VectorEv[j].Real;
@@ -867,7 +867,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                         Complex value = 0.0;
                         for (var i = 0; i < order; i++)
                         {
-                            value += ((DenseMatrix)MatrixEv).Data[(i * order) + j] * tmp[i];
+                            value += ((DenseMatrix)MatrixEv).Values[(i * order) + j] * tmp[i];
                         }
 
                         result.At(j, k, value);
@@ -924,7 +924,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                     {
                         for (var i = 0; i < order; i++)
                         {
-                            value += ((DenseMatrix)MatrixEv).Data[(j * order) + i].Conjugate() * input[i];
+                            value += ((DenseMatrix)MatrixEv).Values[(j * order) + i].Conjugate() * input[i];
                         }
 
                         value /= VectorEv[j].Real;
@@ -938,7 +938,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                     value = 0;
                     for (int i = 0; i < order; i++)
                     {
-                        value += ((DenseMatrix)MatrixEv).Data[(i * order) + j] * tmp[i];
+                        value += ((DenseMatrix)MatrixEv).Values[(i * order) + j] * tmp[i];
                     }
 
                     result[j] = value;

src/Numerics/LinearAlgebra/Complex/Factorization/DenseGramSchmidt.cs

@@ -71,7 +71,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
             MatrixQ = matrix.Clone();
             MatrixR = matrix.CreateMatrix(matrix.ColumnCount, matrix.ColumnCount);
-            Factorize(((DenseMatrix)MatrixQ).Data, MatrixQ.RowCount, MatrixQ.ColumnCount, ((DenseMatrix)MatrixR).Data);
+            Factorize(((DenseMatrix)MatrixQ).Values, MatrixQ.RowCount, MatrixQ.ColumnCount, ((DenseMatrix)MatrixR).Values);
         }
 
         /// <summary>
@@ -172,7 +172,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                 throw new NotSupportedException("Can only do GramSchmidt factorization for dense matrices at the moment.");
             }
 
-            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Data, input.ColumnCount, dresult.Data);
+            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Values, input.ColumnCount, dresult.Values);
         }
 
         /// <summary>
@@ -217,7 +217,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                 throw new NotSupportedException("Can only do GramSchmidt factorization for dense vectors at the moment.");
             }
 
-            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Values, 1, dresult.Values);
+            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Values, 1, dresult.Values);
         }
     }
 }

src/Numerics/LinearAlgebra/Complex/Factorization/DenseLU.cs

@@ -70,7 +70,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
             // Create a new matrix for the LU factors, then perform factorization (while overwriting).
             var factors = (DenseMatrix)matrix.Clone();
-            Control.LinearAlgebraProvider.LUFactor(factors.Data, factors.RowCount, Pivots);
+            Control.LinearAlgebraProvider.LUFactor(factors.Values, factors.RowCount, Pivots);
             Factors = factors;
         }
 
@@ -121,11 +121,11 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
             }
 
             // Copy the contents of input to result.
-            CommonParallel.For(0, dinput.Data.Length, index => dresult.Data[index] = dinput.Data[index]);
+            CommonParallel.For(0, dinput.Values.Length, index => dresult.Values[index] = dinput.Values[index]);
 
             // LU solve by overwriting result.
             var dfactors = (DenseMatrix)Factors;
-            Control.LinearAlgebraProvider.LUSolveFactored(input.ColumnCount, dfactors.Data, dfactors.RowCount, Pivots, dresult.Data);
+            Control.LinearAlgebraProvider.LUSolveFactored(input.ColumnCount, dfactors.Values, dfactors.RowCount, Pivots, dresult.Values);
         }
 
         /// <summary>
@@ -174,7 +174,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
             // LU solve by overwriting result.
             var dfactors = (DenseMatrix)Factors;
-            Control.LinearAlgebraProvider.LUSolveFactored(1, dfactors.Data, dfactors.RowCount, Pivots, dresult.Values);
+            Control.LinearAlgebraProvider.LUSolveFactored(1, dfactors.Values, dfactors.RowCount, Pivots, dresult.Values);
         }
 
         /// <summary>
@@ -184,7 +184,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
         public override Matrix<Complex> Inverse()
         {
             var result = (DenseMatrix)Factors.Clone();
-            Control.LinearAlgebraProvider.LUInverseFactored(result.Data, result.RowCount, Pivots);
+            Control.LinearAlgebraProvider.LUInverseFactored(result.Values, result.RowCount, Pivots);
             return result;
         }
     }

src/Numerics/LinearAlgebra/Complex/Factorization/DenseQR.cs

@@ -83,15 +83,15 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
             {
                 MatrixR = matrix.Clone();
                 MatrixQ = new DenseMatrix(matrix.RowCount);
-                Control.LinearAlgebraProvider.QRFactor(((DenseMatrix)MatrixR).Data, matrix.RowCount, matrix.ColumnCount,
-                                                       ((DenseMatrix)MatrixQ).Data, Tau);
+                Control.LinearAlgebraProvider.QRFactor(((DenseMatrix)MatrixR).Values, matrix.RowCount, matrix.ColumnCount,
+                                                       ((DenseMatrix)MatrixQ).Values, Tau);
             }
             else
             {
                 MatrixQ = matrix.Clone();
                 MatrixR = new DenseMatrix(matrix.ColumnCount);
-                Control.LinearAlgebraProvider.ThinQRFactor(((DenseMatrix)MatrixQ).Data, matrix.RowCount, matrix.ColumnCount,
-                                                       ((DenseMatrix)MatrixR).Data, Tau);
+                Control.LinearAlgebraProvider.ThinQRFactor(((DenseMatrix)MatrixQ).Values, matrix.RowCount, matrix.ColumnCount,
+                                                       ((DenseMatrix)MatrixR).Values, Tau);
             }
         }
 
@@ -143,7 +143,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                 throw new NotSupportedException("Can only do QR factorization for dense matrices at the moment.");
             }
 
-            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Data, input.ColumnCount, dresult.Data);
+            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Values, input.ColumnCount, dresult.Values);
         }
 
         /// <summary>
@@ -188,7 +188,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                 throw new NotSupportedException("Can only do QR factorization for dense vectors at the moment.");
             }
 
-            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Values, 1, dresult.Values);
+            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Values, 1, dresult.Values);
         }
     }
 }

src/Numerics/LinearAlgebra/Complex/Factorization/DenseSvd.cs

@@ -70,7 +70,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
             VectorS = new DenseVector(nm);
             MatrixU = new DenseMatrix(matrix.RowCount);
             MatrixVT = new DenseMatrix(matrix.ColumnCount);
-            Control.LinearAlgebraProvider.SingularValueDecomposition(computeVectors, ((DenseMatrix)matrix.Clone()).Data, matrix.RowCount, matrix.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Data, ((DenseMatrix)MatrixVT).Data);
+            Control.LinearAlgebraProvider.SingularValueDecomposition(computeVectors, ((DenseMatrix)matrix.Clone()).Values, matrix.RowCount, matrix.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Values, ((DenseMatrix)MatrixVT).Values);
         }
 
         /// <summary>
@@ -126,7 +126,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                 throw new NotSupportedException("Can only do SVD factorization for dense matrices at the moment.");
             }
 
-            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Data, ((DenseMatrix)MatrixVT).Data, dinput.Data, input.ColumnCount, dresult.Data);
+            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Values, ((DenseMatrix)MatrixVT).Values, dinput.Values, input.ColumnCount, dresult.Values);
         }
 
         /// <summary>
@@ -176,7 +176,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                 throw new NotSupportedException("Can only do SVD factorization for dense vectors at the moment.");
             }
 
-            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Data, ((DenseMatrix)MatrixVT).Data, dinput.Values, 1, dresult.Values);
+            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Values, ((DenseMatrix)MatrixVT).Values, dinput.Values, 1, dresult.Values);
         }
     }
 }

src/Numerics/LinearAlgebra/Complex32/DenseMatrix.cs

@@ -156,11 +156,21 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// Gets the matrix's data.
         /// </summary>
         /// <value>The matrix's data.</value>
+        [Obsolete("Use Values instead. Will be removed in future versions.")]
         public Complex32[] Data
         {
             get { return _values; }
         }
 
+        /// <summary>
+        /// Gets the matrix's data.
+        /// </summary>
+        /// <value>The matrix's data.</value>
+        public Complex32[] Values
+        {
+            get { return _values; }
+        }
+
         /// <summary>
         /// Creates a <c>DenseMatrix</c> for the given number of rows and columns.
         /// </summary>

src/Numerics/LinearAlgebra/Complex32/Factorization/DenseCholesky.cs

@@ -69,7 +69,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
             // Create a new matrix for the Cholesky factor, then perform factorization (while overwriting).
             var factor = (DenseMatrix)matrix.Clone();
-            Control.LinearAlgebraProvider.CholeskyFactor(factor.Data, factor.RowCount);
+            Control.LinearAlgebraProvider.CholeskyFactor(factor.Values, factor.RowCount);
             CholeskyFactor = factor;
         }
 
@@ -120,11 +120,11 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
             }
 
             // Copy the contents of input to result.
-            CommonParallel.For(0, dinput.Data.Length, index => dresult.Data[index] = dinput.Data[index]);
+            CommonParallel.For(0, dinput.Values.Length, index => dresult.Values[index] = dinput.Values[index]);
 
             // Cholesky solve by overwriting result.
             var dfactor = (DenseMatrix)CholeskyFactor;
-            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Data, dfactor.RowCount, dresult.Data, dresult.ColumnCount);
+            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Values, dfactor.RowCount, dresult.Values, dresult.ColumnCount);
         }
 
         /// <summary>
@@ -173,7 +173,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
             // Cholesky solve by overwriting result.
             var dfactor = (DenseMatrix)CholeskyFactor;
-            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Data, dfactor.RowCount, dresult.Values, 1);
+            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Values, dfactor.RowCount, dresult.Values, 1);
         }
     }
 }

src/Numerics/LinearAlgebra/Complex32/Factorization/DenseEvd.cs

@@ -96,8 +96,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 var e = new float[order];
 
                 SymmetricTridiagonalize(matrixCopy, d, e, tau, order);
-                SymmetricDiagonalize(((DenseMatrix)MatrixEv).Data, d, e, order);
-                SymmetricUntridiagonalize(((DenseMatrix)MatrixEv).Data, matrixCopy, tau, order);
+                SymmetricDiagonalize(((DenseMatrix)MatrixEv).Values, d, e, order);
+                SymmetricUntridiagonalize(((DenseMatrix)MatrixEv).Values, matrixCopy, tau, order);
 
                 for (var i = 0; i < order; i++)
                 {
@@ -107,8 +107,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
             else
             {
                 var matrixH = matrix.ToArray();
-                NonsymmetricReduceToHessenberg(((DenseMatrix)MatrixEv).Data, matrixH, order);
-                NonsymmetricReduceHessenberToRealSchur(((LinearAlgebra.Complex.DenseVector)VectorEv).Values, ((DenseMatrix)MatrixEv).Data, matrixH, order);
+                NonsymmetricReduceToHessenberg(((DenseMatrix)MatrixEv).Values, matrixH, order);
+                NonsymmetricReduceHessenberToRealSchur(((LinearAlgebra.Complex.DenseVector)VectorEv).Values, ((DenseMatrix)MatrixEv).Values, matrixH, order);
             }
 
             for (var i = 0; i < VectorEv.Count; i++)
@@ -857,7 +857,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                         {
                             for (var i = 0; i < order; i++)
                             {
-                                value += ((DenseMatrix)MatrixEv).Data[(j * order) + i].Conjugate() * input.At(i, k);
+                                value += ((DenseMatrix)MatrixEv).Values[(j * order) + i].Conjugate() * input.At(i, k);
                             }
 
                             value /= (float)VectorEv[j].Real;
@@ -871,7 +871,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                         Complex32 value = 0.0f;
                         for (var i = 0; i < order; i++)
                         {
-                            value += ((DenseMatrix)MatrixEv).Data[(i * order) + j] * tmp[i];
+                            value += ((DenseMatrix)MatrixEv).Values[(i * order) + j] * tmp[i];
                         }
 
                         result.At(j, k, value);
@@ -928,7 +928,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                     {
                         for (var i = 0; i < order; i++)
                         {
-                            value += ((DenseMatrix)MatrixEv).Data[(j * order) + i].Conjugate() * input[i];
+                            value += ((DenseMatrix)MatrixEv).Values[(j * order) + i].Conjugate() * input[i];
                         }
 
                         value /= (float)VectorEv[j].Real;
@@ -942,7 +942,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                     value = 0;
                     for (int i = 0; i < order; i++)
                     {
-                        value += ((DenseMatrix)MatrixEv).Data[(i * order) + j] * tmp[i];
+                        value += ((DenseMatrix)MatrixEv).Values[(i * order) + j] * tmp[i];
                     }
 
                     result[j] = value;

src/Numerics/LinearAlgebra/Complex32/Factorization/DenseGramSchmidt.cs

@@ -71,7 +71,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
             MatrixQ = matrix.Clone();
             MatrixR = matrix.CreateMatrix(matrix.ColumnCount, matrix.ColumnCount);
-            Factorize(((DenseMatrix)MatrixQ).Data, MatrixQ.RowCount, MatrixQ.ColumnCount, ((DenseMatrix)MatrixR).Data);
+            Factorize(((DenseMatrix)MatrixQ).Values, MatrixQ.RowCount, MatrixQ.ColumnCount, ((DenseMatrix)MatrixR).Values);
         }
 
         /// <summary>
@@ -172,7 +172,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 throw new NotSupportedException("Can only do GramSchmidt factorization for dense matrices at the moment.");
             }
 
-            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Data, input.ColumnCount, dresult.Data);
+            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Values, input.ColumnCount, dresult.Values);
         }
 
         /// <summary>
@@ -217,7 +217,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 throw new NotSupportedException("Can only do GramSchmidt factorization for dense vectors at the moment.");
             }
 
-            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Values, 1, dresult.Values);
+            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Values, 1, dresult.Values);
         }
     }
 }

src/Numerics/LinearAlgebra/Complex32/Factorization/DenseLU.cs

@@ -70,7 +70,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
             // Create a new matrix for the LU factors, then perform factorization (while overwriting).
             var factors = (DenseMatrix)matrix.Clone();
-            Control.LinearAlgebraProvider.LUFactor(factors.Data, factors.RowCount, Pivots);
+            Control.LinearAlgebraProvider.LUFactor(factors.Values, factors.RowCount, Pivots);
             Factors = factors;
         }
 
@@ -121,11 +121,11 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
             }
 
             // Copy the contents of input to result.
-            CommonParallel.For(0, dinput.Data.Length, index => dresult.Data[index] = dinput.Data[index]);
+            CommonParallel.For(0, dinput.Values.Length, index => dresult.Values[index] = dinput.Values[index]);
 
             // LU solve by overwriting result.
             var dfactors = (DenseMatrix)Factors;
-            Control.LinearAlgebraProvider.LUSolveFactored(input.ColumnCount, dfactors.Data, dfactors.RowCount, Pivots, dresult.Data);
+            Control.LinearAlgebraProvider.LUSolveFactored(input.ColumnCount, dfactors.Values, dfactors.RowCount, Pivots, dresult.Values);
         }
 
         /// <summary>
@@ -174,7 +174,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
             // LU solve by overwriting result.
             var dfactors = (DenseMatrix)Factors;
-            Control.LinearAlgebraProvider.LUSolveFactored(1, dfactors.Data, dfactors.RowCount, Pivots, dresult.Values);
+            Control.LinearAlgebraProvider.LUSolveFactored(1, dfactors.Values, dfactors.RowCount, Pivots, dresult.Values);
         }
 
         /// <summary>
@@ -184,7 +184,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         public override Matrix<Complex32> Inverse()
         {
             var result = (DenseMatrix)Factors.Clone();
-            Control.LinearAlgebraProvider.LUInverseFactored(result.Data, result.RowCount, Pivots);
+            Control.LinearAlgebraProvider.LUInverseFactored(result.Values, result.RowCount, Pivots);
             return result;
         }
     }

src/Numerics/LinearAlgebra/Complex32/Factorization/DenseQR.cs

@@ -83,15 +83,15 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
             {
                 MatrixR = matrix.Clone();
                 MatrixQ = new DenseMatrix(matrix.RowCount);
-                Control.LinearAlgebraProvider.QRFactor(((DenseMatrix)MatrixR).Data, matrix.RowCount, matrix.ColumnCount,
-                                                       ((DenseMatrix)MatrixQ).Data, Tau);
+                Control.LinearAlgebraProvider.QRFactor(((DenseMatrix)MatrixR).Values, matrix.RowCount, matrix.ColumnCount,
+                                                       ((DenseMatrix)MatrixQ).Values, Tau);
             }
             else
             {
                 MatrixQ = matrix.Clone();
                 MatrixR = new DenseMatrix(matrix.ColumnCount);
-                Control.LinearAlgebraProvider.ThinQRFactor(((DenseMatrix)MatrixQ).Data, matrix.RowCount, matrix.ColumnCount,
-                                                       ((DenseMatrix)MatrixR).Data, Tau);
+                Control.LinearAlgebraProvider.ThinQRFactor(((DenseMatrix)MatrixQ).Values, matrix.RowCount, matrix.ColumnCount,
+                                                       ((DenseMatrix)MatrixR).Values, Tau);
             }
         }
 
@@ -143,7 +143,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 throw new NotSupportedException("Can only do QR factorization for dense matrices at the moment.");
             }
 
-            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Data, input.ColumnCount, dresult.Data);
+            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Values, input.ColumnCount, dresult.Values);
         }
 
         /// <summary>
@@ -188,7 +188,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 throw new NotSupportedException("Can only do QR factorization for dense vectors at the moment.");
             }
 
-            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Values, 1, dresult.Values);
+            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Values, 1, dresult.Values);
         }
     }
 }

src/Numerics/LinearAlgebra/Complex32/Factorization/DenseSvd.cs

@@ -70,7 +70,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
             VectorS = new DenseVector(nm);
             MatrixU = new DenseMatrix(matrix.RowCount);
             MatrixVT = new DenseMatrix(matrix.ColumnCount);
-            Control.LinearAlgebraProvider.SingularValueDecomposition(computeVectors, ((DenseMatrix)matrix.Clone()).Data, matrix.RowCount, matrix.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Data, ((DenseMatrix)MatrixVT).Data);
+            Control.LinearAlgebraProvider.SingularValueDecomposition(computeVectors, ((DenseMatrix)matrix.Clone()).Values, matrix.RowCount, matrix.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Values, ((DenseMatrix)MatrixVT).Values);
         }
 
         /// <summary>
@@ -126,7 +126,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 throw new NotSupportedException("Can only do SVD factorization for dense matrices at the moment.");
             }
 
-            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Data, ((DenseMatrix)MatrixVT).Data, dinput.Data, input.ColumnCount, dresult.Data);
+            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Values, ((DenseMatrix)MatrixVT).Values, dinput.Values, input.ColumnCount, dresult.Values);
         }
 
         /// <summary>
@@ -176,7 +176,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 throw new NotSupportedException("Can only do SVD factorization for dense vectors at the moment.");
             }
 
-            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Data, ((DenseMatrix)MatrixVT).Data, dinput.Values, 1, dresult.Values);
+            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Values, ((DenseMatrix)MatrixVT).Values, dinput.Values, 1, dresult.Values);
         }
     }
 }

src/Numerics/LinearAlgebra/Double/DenseMatrix.cs

@@ -156,11 +156,21 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         /// Gets the matrix's data.
         /// </summary>
         /// <value>The matrix's data.</value>
+        [Obsolete("Use Values instead. Will be removed in future versions.")]
         public double[] Data
         {
             get { return _values; }
         }
 
+        /// <summary>
+        /// Gets the matrix's data.
+        /// </summary>
+        /// <value>The matrix's data.</value>
+        public double[] Values
+        {
+            get { return _values; }
+        }
+
         /// <summary>
         /// Creates a <c>DenseMatrix</c> for the given number of rows and columns.
         /// </summary>

src/Numerics/LinearAlgebra/Double/Factorization/DenseCholesky.cs

@@ -67,7 +67,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 
             // Create a new matrix for the Cholesky factor, then perform factorization (while overwriting).
             var factor = (DenseMatrix)matrix.Clone();
-            Control.LinearAlgebraProvider.CholeskyFactor(factor.Data, factor.RowCount);
+            Control.LinearAlgebraProvider.CholeskyFactor(factor.Values, factor.RowCount);
             CholeskyFactor = factor;
         }
 
@@ -118,11 +118,11 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
             }
 
             // Copy the contents of input to result.
-            Buffer.BlockCopy(dinput.Data, 0, dresult.Data, 0, dinput.Data.Length * Constants.SizeOfDouble);
+            Buffer.BlockCopy(dinput.Values, 0, dresult.Values, 0, dinput.Values.Length * Constants.SizeOfDouble);
 
             // Cholesky solve by overwriting result.
             var dfactor = (DenseMatrix)CholeskyFactor;
-            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Data, dfactor.RowCount, dresult.Data, dresult.ColumnCount);
+            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Values, dfactor.RowCount, dresult.Values, dresult.ColumnCount);
         }
 
         /// <summary>
@@ -171,7 +171,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 
             // Cholesky solve by overwriting result.
             var dfactor = (DenseMatrix)CholeskyFactor;
-            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Data, dfactor.RowCount, dresult.Values, 1);
+            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Values, dfactor.RowCount, dresult.Values, 1);
         }
     }
 }

src/Numerics/LinearAlgebra/Double/Factorization/DenseEvd.cs

@@ -95,15 +95,15 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                 matrix.CopyTo(MatrixEv);
                 d = MatrixEv.Row(order - 1).ToArray();
 
-                SymmetricTridiagonalize(((DenseMatrix)MatrixEv).Data, d, e, order);
-                SymmetricDiagonalize(((DenseMatrix)MatrixEv).Data, d, e, order);
+                SymmetricTridiagonalize(((DenseMatrix)MatrixEv).Values, d, e, order);
+                SymmetricDiagonalize(((DenseMatrix)MatrixEv).Values, d, e, order);
             }
             else
             {
                 var matrixH = matrix.ToArray();
 
-                NonsymmetricReduceToHessenberg(((DenseMatrix)MatrixEv).Data, matrixH, order);
-                NonsymmetricReduceHessenberToRealSchur(((DenseMatrix)MatrixEv).Data, matrixH, d, e, order);
+                NonsymmetricReduceToHessenberg(((DenseMatrix)MatrixEv).Values, matrixH, order);
+                NonsymmetricReduceHessenberToRealSchur(((DenseMatrix)MatrixEv).Values, matrixH, d, e, order);
             }
 
             for (var i = 0; i < order; i++)
@@ -1125,7 +1125,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                         {
                             for (var i = 0; i < order; i++)
                             {
-                                value += ((DenseMatrix)MatrixEv).Data[(j * order) + i] * input.At(i, k);
+                                value += ((DenseMatrix)MatrixEv).Values[(j * order) + i] * input.At(i, k);
                             }
 
                             value /= VectorEv[j].Real;
@@ -1139,7 +1139,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                         double value = 0;
                         for (var i = 0; i < order; i++)
                         {
-                            value += ((DenseMatrix)MatrixEv).Data[(i * order) + j] * tmp[i];
+                            value += ((DenseMatrix)MatrixEv).Values[(i * order) + j] * tmp[i];
                         }
 
                         result.At(j, k, value);
@@ -1196,7 +1196,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                     {
                         for (var i = 0; i < order; i++)
                         {
-                            value += ((DenseMatrix)MatrixEv).Data[(j * order) + i] * input[i];
+                            value += ((DenseMatrix)MatrixEv).Values[(j * order) + i] * input[i];
                         }
 
                         value /= VectorEv[j].Real;
@@ -1210,7 +1210,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                     value = 0;
                     for (int i = 0; i < order; i++)
                     {
-                        value += ((DenseMatrix)MatrixEv).Data[(i * order) + j] * tmp[i];
+                        value += ((DenseMatrix)MatrixEv).Values[(i * order) + j] * tmp[i];
                     }
 
                     result[j] = value;

src/Numerics/LinearAlgebra/Double/Factorization/DenseGramSchmidt.cs

@@ -70,7 +70,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 
             MatrixQ = matrix.Clone();
             MatrixR = matrix.CreateMatrix(matrix.ColumnCount, matrix.ColumnCount);
-            Factorize(((DenseMatrix)MatrixQ).Data, MatrixQ.RowCount, MatrixQ.ColumnCount, ((DenseMatrix)MatrixR).Data);
+            Factorize(((DenseMatrix)MatrixQ).Values, MatrixQ.RowCount, MatrixQ.ColumnCount, ((DenseMatrix)MatrixR).Values);
         }
 
         /// <summary>
@@ -171,7 +171,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                 throw new NotSupportedException("Can only do GramSchmidt factorization for dense matrices at the moment.");
             }
 
-            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixR.RowCount, MatrixR.ColumnCount, null, dinput.Data, input.ColumnCount, dresult.Data);
+            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixR.RowCount, MatrixR.ColumnCount, null, dinput.Values, input.ColumnCount, dresult.Values);
         }
 
         /// <summary>
@@ -216,7 +216,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                 throw new NotSupportedException("Can only do GramSchmidt factorization for dense vectors at the moment.");
             }
 
-            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Values, 1, dresult.Values);
+            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Values, 1, dresult.Values);
         }
     }
 }

src/Numerics/LinearAlgebra/Double/Factorization/DenseLU.cs

@@ -68,7 +68,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 
             // Create a new matrix for the LU factors, then perform factorization (while overwriting).
             var factors = (DenseMatrix)matrix.Clone();
-            Control.LinearAlgebraProvider.LUFactor(factors.Data, factors.RowCount, Pivots);
+            Control.LinearAlgebraProvider.LUFactor(factors.Values, factors.RowCount, Pivots);
             Factors = factors;
         }
 
@@ -119,11 +119,11 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
             }
 
             // Copy the contents of input to result.
-            Buffer.BlockCopy(dinput.Data, 0, dresult.Data, 0, dinput.Data.Length * Constants.SizeOfDouble);
+            Buffer.BlockCopy(dinput.Values, 0, dresult.Values, 0, dinput.Values.Length * Constants.SizeOfDouble);
 
             // LU solve by overwriting result.
             var dfactors = (DenseMatrix)Factors;
-            Control.LinearAlgebraProvider.LUSolveFactored(input.ColumnCount, dfactors.Data, dfactors.RowCount, Pivots,  dresult.Data);
+            Control.LinearAlgebraProvider.LUSolveFactored(input.ColumnCount, dfactors.Values, dfactors.RowCount, Pivots,  dresult.Values);
         }
 
         /// <summary>
@@ -172,7 +172,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 
             // LU solve by overwriting result.
             var dfactors = (DenseMatrix)Factors;
-            Control.LinearAlgebraProvider.LUSolveFactored(1, dfactors.Data, dfactors.RowCount, Pivots, dresult.Values);
+            Control.LinearAlgebraProvider.LUSolveFactored(1, dfactors.Values, dfactors.RowCount, Pivots, dresult.Values);
         }
 
         /// <summary>
@@ -182,7 +182,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
         public override Matrix<double> Inverse()
         {
             var result = (DenseMatrix)Factors.Clone();
-            Control.LinearAlgebraProvider.LUInverseFactored(result.Data, result.RowCount, Pivots);
+            Control.LinearAlgebraProvider.LUInverseFactored(result.Values, result.RowCount, Pivots);
             return result;
         }
     }

src/Numerics/LinearAlgebra/Double/Factorization/DenseQR.cs

@@ -82,16 +82,16 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
             {
                 MatrixR = matrix.Clone();
                 MatrixQ = new DenseMatrix(matrix.RowCount);
-                Control.LinearAlgebraProvider.QRFactor(((DenseMatrix)MatrixR).Data, matrix.RowCount, matrix.ColumnCount,
-                                                       ((DenseMatrix)MatrixQ).Data, Tau);
+                Control.LinearAlgebraProvider.QRFactor(((DenseMatrix)MatrixR).Values, matrix.RowCount, matrix.ColumnCount,
+                                                       ((DenseMatrix)MatrixQ).Values, Tau);
             }
             else
             {
                 MatrixQ = matrix.Clone();
                 MatrixR = new DenseMatrix(matrix.ColumnCount);
-                Control.LinearAlgebraProvider.ThinQRFactor(((DenseMatrix) MatrixQ).Data, matrix.RowCount,
+                Control.LinearAlgebraProvider.ThinQRFactor(((DenseMatrix) MatrixQ).Values, matrix.RowCount,
                                                            matrix.ColumnCount,
-                                                           ((DenseMatrix) MatrixR).Data, Tau);
+                                                           ((DenseMatrix) MatrixR).Values, Tau);
             }
         }
 
@@ -143,7 +143,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                 throw new NotSupportedException("Can only do QR factorization for dense matrices at the moment.");
             }
 
-            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Data, input.ColumnCount, dresult.Data);
+            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Values, input.ColumnCount, dresult.Values);
         }
 
         /// <summary>
@@ -188,7 +188,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                 throw new NotSupportedException("Can only do QR factorization for dense vectors at the moment.");
             }
 
-            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Values, 1, dresult.Values);
+            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Values, 1, dresult.Values);
         }
     }
 }

src/Numerics/LinearAlgebra/Double/Factorization/DenseSvd.cs

@@ -69,7 +69,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
             VectorS = new DenseVector(nm);
             MatrixU = new DenseMatrix(matrix.RowCount);
             MatrixVT = new DenseMatrix(matrix.ColumnCount);
-            Control.LinearAlgebraProvider.SingularValueDecomposition(computeVectors, ((DenseMatrix)matrix.Clone()).Data, matrix.RowCount, matrix.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Data, ((DenseMatrix)MatrixVT).Data);
+            Control.LinearAlgebraProvider.SingularValueDecomposition(computeVectors, ((DenseMatrix)matrix.Clone()).Values, matrix.RowCount, matrix.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Values, ((DenseMatrix)MatrixVT).Values);
         }
 
         /// <summary>
@@ -125,7 +125,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                 throw new NotSupportedException("Can only do SVD factorization for dense matrices at the moment.");
             }
 
-            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Data, ((DenseMatrix)MatrixVT).Data, dinput.Data, input.ColumnCount, dresult.Data);
+            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Values, ((DenseMatrix)MatrixVT).Values, dinput.Values, input.ColumnCount, dresult.Values);
         }
 
         /// <summary>
@@ -175,7 +175,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                 throw new NotSupportedException("Can only do SVD factorization for dense vectors at the moment.");
             }
 
-            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Data, ((DenseMatrix)MatrixVT).Data, dinput.Values, 1, dresult.Values);
+            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Values, ((DenseMatrix)MatrixVT).Values, dinput.Values, 1, dresult.Values);
         }
     }
 }

src/Numerics/LinearAlgebra/Single/DenseMatrix.cs

@@ -156,11 +156,21 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         /// Gets the matrix's data.
         /// </summary>
         /// <value>The matrix's data.</value>
+        [Obsolete("Use Values instead. Will be removed in future versions.")]
         public float[] Data
         {
             get { return _values; }
         }
 
+        /// <summary>
+        /// Gets the matrix's data.
+        /// </summary>
+        /// <value>The matrix's data.</value>
+        public float[] Values
+        {
+            get { return _values; }
+        }
+
         /// <summary>
         /// Creates a <c>DenseMatrix</c> for the given number of rows and columns.
         /// </summary>

src/Numerics/LinearAlgebra/Single/Factorization/DenseCholesky.cs

@@ -67,7 +67,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 
             // Create a new matrix for the Cholesky factor, then perform factorization (while overwriting).
             var factor = (DenseMatrix)matrix.Clone();
-            Control.LinearAlgebraProvider.CholeskyFactor(factor.Data, factor.RowCount);
+            Control.LinearAlgebraProvider.CholeskyFactor(factor.Values, factor.RowCount);
             CholeskyFactor = factor;
         }
 
@@ -118,11 +118,11 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
             }
 
             // Copy the contents of input to result.
-            Buffer.BlockCopy(dinput.Data, 0, dresult.Data, 0, dinput.Data.Length * Constants.SizeOfFloat);
+            Buffer.BlockCopy(dinput.Values, 0, dresult.Values, 0, dinput.Values.Length * Constants.SizeOfFloat);
 
             // Cholesky solve by overwriting result.
             var dfactor = (DenseMatrix)CholeskyFactor;
-            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Data, dfactor.RowCount, dresult.Data, dresult.ColumnCount);
+            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Values, dfactor.RowCount, dresult.Values, dresult.ColumnCount);
         }
 
         /// <summary>
@@ -171,7 +171,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 
             // Cholesky solve by overwriting result.
             var dfactor = (DenseMatrix)CholeskyFactor;
-            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Data, dfactor.RowCount, dresult.Values, 1);
+            Control.LinearAlgebraProvider.CholeskySolveFactored(dfactor.Values, dfactor.RowCount, dresult.Values, 1);
         }
     }
 }

src/Numerics/LinearAlgebra/Single/Factorization/DenseEvd.cs

@@ -96,15 +96,15 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                 matrix.CopyTo(MatrixEv);
                 d = MatrixEv.Row(order - 1).ToArray();
 
-                SymmetricTridiagonalize(((DenseMatrix)MatrixEv).Data, d, e, order);
-                SymmetricDiagonalize(((DenseMatrix)MatrixEv).Data, d, e, order);
+                SymmetricTridiagonalize(((DenseMatrix)MatrixEv).Values, d, e, order);
+                SymmetricDiagonalize(((DenseMatrix)MatrixEv).Values, d, e, order);
             }
             else
             {
                 var matrixH = matrix.ToArray();
 
-                NonsymmetricReduceToHessenberg(((DenseMatrix)MatrixEv).Data, matrixH, order);
-                NonsymmetricReduceHessenberToRealSchur(((DenseMatrix)MatrixEv).Data, matrixH, d, e, order);
+                NonsymmetricReduceToHessenberg(((DenseMatrix)MatrixEv).Values, matrixH, order);
+                NonsymmetricReduceHessenberToRealSchur(((DenseMatrix)MatrixEv).Values, matrixH, d, e, order);
             }
 
             for (var i = 0; i < order; i++)
@@ -1126,7 +1126,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                         {
                             for (var i = 0; i < order; i++)
                             {
-                                value += ((DenseMatrix)MatrixEv).Data[(j * order) + i] * input.At(i, k);
+                                value += ((DenseMatrix)MatrixEv).Values[(j * order) + i] * input.At(i, k);
                             }
 
                             value /= (float)VectorEv[j].Real;
@@ -1140,7 +1140,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                         float value = 0;
                         for (var i = 0; i < order; i++)
                         {
-                            value += ((DenseMatrix)MatrixEv).Data[(i * order) + j] * tmp[i];
+                            value += ((DenseMatrix)MatrixEv).Values[(i * order) + j] * tmp[i];
                         }
 
                         result.At(j, k, value);
@@ -1197,7 +1197,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                     {
                         for (var i = 0; i < order; i++)
                         {
-                            value += ((DenseMatrix)MatrixEv).Data[(j * order) + i] * input[i];
+                            value += ((DenseMatrix)MatrixEv).Values[(j * order) + i] * input[i];
                         }
 
                         value /= (float)VectorEv[j].Real;
@@ -1211,7 +1211,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                     value = 0;
                     for (int i = 0; i < order; i++)
                     {
-                        value += ((DenseMatrix)MatrixEv).Data[(i * order) + j] * tmp[i];
+                        value += ((DenseMatrix)MatrixEv).Values[(i * order) + j] * tmp[i];
                     }
 
                     result[j] = value;

src/Numerics/LinearAlgebra/Single/Factorization/DenseGramSchmidt.cs

@@ -70,7 +70,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 
             MatrixQ = matrix.Clone();
             MatrixR = matrix.CreateMatrix(matrix.ColumnCount, matrix.ColumnCount);
-            Factorize(((DenseMatrix)MatrixQ).Data, MatrixQ.RowCount, MatrixQ.ColumnCount, ((DenseMatrix)MatrixR).Data);
+            Factorize(((DenseMatrix)MatrixQ).Values, MatrixQ.RowCount, MatrixQ.ColumnCount, ((DenseMatrix)MatrixR).Values);
         }
 
         /// <summary>
@@ -171,7 +171,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                 throw new NotSupportedException("Can only do GramSchmidt factorization for dense matrices at the moment.");
             }
 
-            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Data, input.ColumnCount, dresult.Data);
+            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Values, input.ColumnCount, dresult.Values);
         }
 
         /// <summary>
@@ -216,7 +216,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                 throw new NotSupportedException("Can only do GramSchmidt factorization for dense vectors at the moment.");
             }
 
-            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Values, 1, dresult.Values);
+            _provider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixQ.RowCount, MatrixQ.ColumnCount, null, dinput.Values, 1, dresult.Values);
         }
     }
 }

src/Numerics/LinearAlgebra/Single/Factorization/DenseLU.cs

@@ -68,7 +68,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 
             // Create a new matrix for the LU factors, then perform factorization (while overwriting).
             var factors = (DenseMatrix)matrix.Clone();
-            Control.LinearAlgebraProvider.LUFactor(factors.Data, factors.RowCount, Pivots);
+            Control.LinearAlgebraProvider.LUFactor(factors.Values, factors.RowCount, Pivots);
             Factors = factors;
         }
 
@@ -119,11 +119,11 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
             }
 
             // Copy the contents of input to result.
-            Buffer.BlockCopy(dinput.Data, 0, dresult.Data, 0, dinput.Data.Length * Constants.SizeOfFloat);
+            Buffer.BlockCopy(dinput.Values, 0, dresult.Values, 0, dinput.Values.Length * Constants.SizeOfFloat);
 
             // LU solve by overwriting result.
             var dfactors = (DenseMatrix)Factors;
-            Control.LinearAlgebraProvider.LUSolveFactored(input.ColumnCount, dfactors.Data, dfactors.RowCount, Pivots, dresult.Data);
+            Control.LinearAlgebraProvider.LUSolveFactored(input.ColumnCount, dfactors.Values, dfactors.RowCount, Pivots, dresult.Values);
         }
 
         /// <summary>
@@ -172,7 +172,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 
             // LU solve by overwriting result.
             var dfactors = (DenseMatrix)Factors;
-            Control.LinearAlgebraProvider.LUSolveFactored(1, dfactors.Data, dfactors.RowCount, Pivots, dresult.Values);
+            Control.LinearAlgebraProvider.LUSolveFactored(1, dfactors.Values, dfactors.RowCount, Pivots, dresult.Values);
         }
 
         /// <summary>
@@ -182,7 +182,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
         public override Matrix<float> Inverse()
         {
             var result = (DenseMatrix)Factors.Clone();
-            Control.LinearAlgebraProvider.LUInverseFactored(result.Data, result.RowCount, Pivots);
+            Control.LinearAlgebraProvider.LUInverseFactored(result.Values, result.RowCount, Pivots);
             return result;
         }
     }

src/Numerics/LinearAlgebra/Single/Factorization/DenseQR.cs

@@ -82,15 +82,15 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
             {
                 MatrixR = matrix.Clone();
                 MatrixQ = new DenseMatrix(matrix.RowCount);
-                Control.LinearAlgebraProvider.QRFactor(((DenseMatrix)MatrixR).Data, matrix.RowCount, matrix.ColumnCount,
-                                                       ((DenseMatrix)MatrixQ).Data, Tau);
+                Control.LinearAlgebraProvider.QRFactor(((DenseMatrix)MatrixR).Values, matrix.RowCount, matrix.ColumnCount,
+                                                       ((DenseMatrix)MatrixQ).Values, Tau);
             }
             else
             {
                 MatrixQ = matrix.Clone();
                 MatrixR = new DenseMatrix(matrix.ColumnCount);
-                Control.LinearAlgebraProvider.ThinQRFactor(((DenseMatrix)MatrixQ).Data, matrix.RowCount, matrix.ColumnCount,
-                                                       ((DenseMatrix)MatrixR).Data, Tau);
+                Control.LinearAlgebraProvider.ThinQRFactor(((DenseMatrix)MatrixQ).Values, matrix.RowCount, matrix.ColumnCount,
+                                                       ((DenseMatrix)MatrixR).Values, Tau);
             }
         }
 
@@ -142,7 +142,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                 throw new NotSupportedException("Can only do QR factorization for dense matrices at the moment.");
             }
 
-            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Data, input.ColumnCount, dresult.Data);
+            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Values, input.ColumnCount, dresult.Values);
         }
 
         /// <summary>
@@ -187,7 +187,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                 throw new NotSupportedException("Can only do QR factorization for dense vectors at the moment.");
             }
 
-            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Data, ((DenseMatrix)MatrixR).Data, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Values, 1, dresult.Values);
+            Control.LinearAlgebraProvider.QRSolveFactored(((DenseMatrix)MatrixQ).Values, ((DenseMatrix)MatrixR).Values, MatrixR.RowCount, MatrixR.ColumnCount, Tau, dinput.Values, 1, dresult.Values);
         }
     }
 }

src/Numerics/LinearAlgebra/Single/Factorization/DenseSvd.cs

@@ -69,7 +69,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
             VectorS = new DenseVector(nm);
             MatrixU = new DenseMatrix(matrix.RowCount);
             MatrixVT = new DenseMatrix(matrix.ColumnCount);
-            Control.LinearAlgebraProvider.SingularValueDecomposition(computeVectors, ((DenseMatrix)matrix.Clone()).Data, matrix.RowCount, matrix.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Data, ((DenseMatrix)MatrixVT).Data);
+            Control.LinearAlgebraProvider.SingularValueDecomposition(computeVectors, ((DenseMatrix)matrix.Clone()).Values, matrix.RowCount, matrix.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Values, ((DenseMatrix)MatrixVT).Values);
         }
 
         /// <summary>
@@ -125,7 +125,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                 throw new NotSupportedException("Can only do SVD factorization for dense matrices at the moment.");
             }
 
-            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Data, ((DenseMatrix)MatrixVT).Data, dinput.Data, input.ColumnCount, dresult.Data);
+            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Values, ((DenseMatrix)MatrixVT).Values, dinput.Values, input.ColumnCount, dresult.Values);
         }
 
         /// <summary>
@@ -175,7 +175,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                 throw new NotSupportedException("Can only do SVD factorization for dense vectors at the moment.");
             }
 
-            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Data, ((DenseMatrix)MatrixVT).Data, dinput.Values, 1, dresult.Values);
+            Control.LinearAlgebraProvider.SvdSolveFactored(MatrixU.RowCount, MatrixVT.ColumnCount, ((DenseVector)VectorS).Values, ((DenseMatrix)MatrixU).Values, ((DenseMatrix)MatrixVT).Values, dinput.Values, 1, dresult.Values);
         }
     }
 }

src/UnitTests/LinearAlgebraProviderTests/Complex/LinearAlgebraProviderTests.cs

@@ -189,7 +189,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var work = new double[matrix.RowCount];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work);
             AssertHelpers.AlmostEqual(12.1, norm, 6);
         }
 
@@ -201,7 +201,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var work = new double[matrix.RowCount];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work);
             AssertHelpers.AlmostEqual(10.777754868246, norm, 8);
         }
 
@@ -213,7 +213,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var work = new double[matrix.RowCount];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work);
             Assert.AreEqual(16.5, norm.Real);
         }
 
@@ -224,7 +224,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         public void CanComputeMatrixL1NormWithWorkArray()
         {
             var matrix = _matrices["Square3x3"];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values);
             AssertHelpers.AlmostEqual(12.1, norm, 6);
         }
 
@@ -235,7 +235,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         public void CanComputeMatrixFrobeniusNormWithWorkArray()
         {
             var matrix = _matrices["Square3x3"];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values);
             AssertHelpers.AlmostEqual(10.777754868246, norm, 8);
         }
 
@@ -246,7 +246,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         public void CanComputeMatrixInfinityNormWithWorkArray()
         {
             var matrix = _matrices["Square3x3"];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values);
             Assert.AreEqual(16.5, norm.Real);
         }
 
@@ -260,7 +260,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
             var y = _matrices["Square3x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiply(x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -281,7 +281,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
             var y = _matrices["Tall3x2"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiply(x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -302,7 +302,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
             var y = _matrices["Wide2x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiply(x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -323,7 +323,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
             var y = _matrices["Square3x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, 1.0, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -344,7 +344,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
             var y = _matrices["Tall3x2"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, 1.0, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -365,7 +365,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
             var y = _matrices["Wide2x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, 1.0, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -384,7 +384,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
 
@@ -412,7 +412,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount);
 
@@ -436,7 +436,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
 
@@ -463,7 +463,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var work = new Complex[matrix.RowCount];
             Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount, work);
@@ -488,7 +488,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
 
@@ -516,7 +516,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0 };
             Control.LinearAlgebraProvider.LUSolve(2, a, matrix.RowCount, b);
@@ -539,7 +539,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
             Control.LinearAlgebraProvider.LUFactor(a, matrix.RowCount, ipiv);
@@ -632,7 +632,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var r = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new Complex[3];
             var q = new Complex[matrix.RowCount * matrix.RowCount];
@@ -659,7 +659,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var r = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new Complex[3];
             var q = new Complex[matrix.RowCount * matrix.RowCount];
@@ -686,7 +686,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Wide2x3"];
             var r = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new Complex[3];
             var q = new Complex[matrix.RowCount * matrix.RowCount];
@@ -713,7 +713,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var r = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new Complex[3];
             var q = new Complex[matrix.RowCount * matrix.RowCount];
@@ -741,7 +741,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var r = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new Complex[3];
             var q = new Complex[matrix.RowCount * matrix.RowCount];
@@ -769,7 +769,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Wide2x3"];
             var r = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new Complex[3];
             var q = new Complex[matrix.RowCount * matrix.RowCount];
@@ -799,7 +799,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
             var r = new Complex[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new Complex[3];
             var q = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau);
 
@@ -826,7 +826,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
             var r = new Complex[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new Complex[3];
             var q = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau);
 
@@ -853,7 +853,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
             var r = new Complex[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new Complex[3];
             var q = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             var work = new Complex[matrix.RowCount * matrix.ColumnCount];
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau, work);
@@ -881,7 +881,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
             var r = new Complex[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new Complex[3];
             var q = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             var work = new Complex[matrix.RowCount * matrix.ColumnCount];
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau, work);
@@ -906,7 +906,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new Complex[matrix.ColumnCount * 2];
@@ -933,7 +933,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new Complex[matrix.ColumnCount * 2];
@@ -959,7 +959,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new Complex[matrix.ColumnCount * 2];
@@ -988,7 +988,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new Complex[matrix.ColumnCount * 2];
@@ -1015,7 +1015,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex[matrix.ColumnCount];
             var q = new Complex[matrix.ColumnCount * matrix.ColumnCount];
@@ -1045,7 +1045,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex[matrix.ColumnCount];
             var q = new Complex[matrix.RowCount * matrix.RowCount];
@@ -1073,7 +1073,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex[matrix.ColumnCount];
             var q = new Complex[matrix.ColumnCount * matrix.ColumnCount];
@@ -1104,7 +1104,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex[matrix.ColumnCount];
             var q = new Complex[matrix.RowCount * matrix.RowCount];
@@ -1132,7 +1132,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new Complex[matrix.ColumnCount * 2];
@@ -1159,7 +1159,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new Complex[matrix.ColumnCount * 2];
@@ -1185,7 +1185,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new Complex[matrix.ColumnCount * 2];
@@ -1214,7 +1214,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new Complex[matrix.ColumnCount * 2];
@@ -1241,7 +1241,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex[matrix.ColumnCount];
             var r = new Complex[matrix.ColumnCount * matrix.ColumnCount];
@@ -1271,7 +1271,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex[matrix.ColumnCount];
             var r = new Complex[matrix.ColumnCount * matrix.ColumnCount];
@@ -1299,7 +1299,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex[matrix.ColumnCount];
             var r = new Complex[matrix.ColumnCount * matrix.ColumnCount];
@@ -1330,7 +1330,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex[matrix.ColumnCount];
             var r = new Complex[matrix.ColumnCount * matrix.ColumnCount];
@@ -1358,7 +1358,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex[matrix.RowCount];
             var u = new Complex[matrix.RowCount * matrix.RowCount];
@@ -1395,7 +1395,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex[matrix.ColumnCount];
             var u = new Complex[matrix.RowCount * matrix.RowCount];
@@ -1429,7 +1429,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Wide2x3"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex[matrix.RowCount];
             var u = new Complex[matrix.RowCount * matrix.RowCount];
@@ -1464,7 +1464,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex[matrix.RowCount];
             var u = new Complex[matrix.RowCount * matrix.RowCount];
@@ -1503,7 +1503,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex[matrix.ColumnCount];
             var u = new Complex[matrix.RowCount * matrix.RowCount];
@@ -1539,7 +1539,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Wide2x3"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex[matrix.RowCount];
             var u = new Complex[matrix.RowCount * matrix.RowCount];
@@ -1574,7 +1574,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new Complex[matrix.ColumnCount * 2];
@@ -1601,7 +1601,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex(1.0, 0), 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new Complex[matrix.ColumnCount * 2];
@@ -1627,7 +1627,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex[matrix.RowCount];
             var u = new Complex[matrix.RowCount * matrix.RowCount];
@@ -1659,7 +1659,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex[matrix.ColumnCount];
             var u = new Complex[matrix.RowCount * matrix.RowCount];

src/UnitTests/LinearAlgebraProviderTests/Complex32/LinearAlgebraProviderTests.cs

@@ -190,7 +190,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var work = new float[matrix.RowCount];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work);
             AssertHelpers.AlmostEqual(12.1f, norm, 6);
         }
 
@@ -202,7 +202,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var work = new float[matrix.RowCount];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work);
             AssertHelpers.AlmostEqual(10.777754868246f, norm, 6);
         }
 
@@ -214,7 +214,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var work = new float[matrix.RowCount];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work);
             Assert.AreEqual(16.5, norm.Real);
         }
 
@@ -225,7 +225,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         public void CanComputeMatrixL1NormWithWorkArray()
         {
             var matrix = _matrices["Square3x3"];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values);
             AssertHelpers.AlmostEqual(12.1f, norm, 6);
         }
 
@@ -236,7 +236,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         public void CanComputeMatrixFrobeniusNormWithWorkArray()
         {
             var matrix = _matrices["Square3x3"];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values);
             AssertHelpers.AlmostEqual(10.777754868246f, norm, 8);
         }
 
@@ -247,7 +247,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         public void CanComputeMatrixInfinityNormWithWorkArray()
         {
             var matrix = _matrices["Square3x3"];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values);
             Assert.AreEqual(16.5, norm.Real);
         }
 
@@ -261,7 +261,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
             var y = _matrices["Square3x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiply(x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -282,7 +282,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
             var y = _matrices["Tall3x2"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiply(x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -303,7 +303,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
             var y = _matrices["Wide2x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiply(x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -324,7 +324,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
             var y = _matrices["Square3x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2f, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0f, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2f, x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, 1.0f, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -345,7 +345,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
             var y = _matrices["Tall3x2"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2f, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0f, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2f, x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, 1.0f, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -366,7 +366,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
             var y = _matrices["Wide2x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2f, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0f, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2f, x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, 1.0f, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -393,7 +393,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
 
@@ -421,7 +421,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount);
 
@@ -445,7 +445,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
 
@@ -472,7 +472,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var work = new Complex32[matrix.RowCount];
             Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount, work);
@@ -497,7 +497,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
 
@@ -525,7 +525,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             Control.LinearAlgebraProvider.LUSolve(2, a, matrix.RowCount, b);
@@ -548,7 +548,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
             Control.LinearAlgebraProvider.LUFactor(a, matrix.RowCount, ipiv);
@@ -641,7 +641,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var r = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new Complex32[3];
             var q = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -668,7 +668,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var r = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new Complex32[3];
             var q = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -695,7 +695,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Wide2x3"];
             var r = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new Complex32[3];
             var q = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -722,7 +722,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var r = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new Complex32[3];
             var q = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -750,7 +750,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var r = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new Complex32[3];
             var q = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -778,7 +778,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Wide2x3"];
             var r = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new Complex32[3];
             var q = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -808,7 +808,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
             var r = new Complex32[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new Complex32[3];
             var q = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau);
 
@@ -835,7 +835,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
             var r = new Complex32[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new Complex32[3];
             var q = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau);
 
@@ -862,7 +862,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
             var r = new Complex32[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new Complex32[3];
             var q = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             var work = new Complex32[matrix.RowCount * matrix.ColumnCount];
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau, work);
@@ -890,7 +890,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
             var r = new Complex32[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new Complex32[3];
             var q = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             var work = new Complex32[matrix.RowCount * matrix.ColumnCount];
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau, work);
@@ -915,7 +915,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new Complex32[matrix.ColumnCount * 2];
@@ -942,7 +942,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new Complex32[matrix.ColumnCount * 2];
@@ -968,7 +968,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new Complex32[matrix.ColumnCount * 2];
@@ -997,7 +997,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new Complex32[matrix.ColumnCount * 2];
@@ -1024,7 +1024,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex32[matrix.ColumnCount];
             var q = new Complex32[matrix.ColumnCount * matrix.ColumnCount];
@@ -1054,7 +1054,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex32[matrix.ColumnCount];
             var q = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -1082,7 +1082,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex32[matrix.ColumnCount];
             var q = new Complex32[matrix.ColumnCount * matrix.ColumnCount];
@@ -1113,7 +1113,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex32[matrix.ColumnCount];
             var q = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -1141,7 +1141,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new Complex32[matrix.ColumnCount * 2];
@@ -1168,7 +1168,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new Complex32[matrix.ColumnCount * 2];
@@ -1194,7 +1194,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new Complex32[matrix.ColumnCount * 2];
@@ -1223,7 +1223,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new Complex32[matrix.ColumnCount * 2];
@@ -1250,7 +1250,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex32[matrix.ColumnCount];
             var r = new Complex32[matrix.ColumnCount * matrix.ColumnCount];
@@ -1280,7 +1280,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex32[matrix.ColumnCount];
             var r = new Complex32[matrix.ColumnCount * matrix.ColumnCount];
@@ -1308,7 +1308,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex32[matrix.ColumnCount];
             var r = new Complex32[matrix.ColumnCount * matrix.ColumnCount];
@@ -1339,7 +1339,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new Complex32[matrix.ColumnCount];
             var r = new Complex32[matrix.ColumnCount * matrix.ColumnCount];
@@ -1367,7 +1367,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex32[matrix.RowCount];
             var u = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -1404,7 +1404,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex32[matrix.ColumnCount];
             var u = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -1438,7 +1438,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Wide2x3"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex32[matrix.RowCount];
             var u = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -1473,7 +1473,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex32[matrix.RowCount];
             var u = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -1512,7 +1512,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex32[matrix.ColumnCount];
             var u = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -1548,7 +1548,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Wide2x3"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex32[matrix.RowCount];
             var u = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -1583,7 +1583,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new Complex32[matrix.ColumnCount * 2];
@@ -1610,7 +1610,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { new Complex32(1.0f, 0.0f), 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new Complex32[matrix.ColumnCount * 2];
@@ -1636,7 +1636,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Square3x3"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex32[matrix.RowCount];
             var u = new Complex32[matrix.RowCount * matrix.RowCount];
@@ -1668,7 +1668,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Complex32
         {
             var matrix = _matrices["Tall3x2"];
             var a = new Complex32[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new Complex32[matrix.ColumnCount];
             var u = new Complex32[matrix.RowCount * matrix.RowCount];

src/UnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs

@@ -189,7 +189,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var work = new double[matrix.RowCount];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work);
             AssertHelpers.AlmostEqual(12.1, norm, 6);
         }
 
@@ -201,7 +201,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var work = new double[matrix.RowCount];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work);
             AssertHelpers.AlmostEqual(10.777754868246, norm, 8);
         }
 
@@ -213,7 +213,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var work = new double[matrix.RowCount];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work);
             Assert.AreEqual(16.5, norm);
         }
 
@@ -224,7 +224,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         public void CanComputeMatrixL1NormWithWorkArray()
         {
             var matrix = _matrices["Square3x3"];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values);
             AssertHelpers.AlmostEqual(12.1, norm, 6);
         }
 
@@ -235,7 +235,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         public void CanComputeMatrixFrobeniusNormWithWorkArray()
         {
             var matrix = _matrices["Square3x3"];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values);
             AssertHelpers.AlmostEqual(10.777754868246, norm, 8);
         }
 
@@ -246,7 +246,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         public void CanComputeMatrixInfinityNormWithWorkArray()
         {
             var matrix = _matrices["Square3x3"];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values);
             Assert.AreEqual(16.5, norm);
         }
 
@@ -260,7 +260,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
             var y = _matrices["Square3x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiply(x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -281,7 +281,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
             var y = _matrices["Tall3x2"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiply(x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -302,7 +302,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
             var y = _matrices["Wide2x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiply(x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -323,7 +323,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
             var y = _matrices["Square3x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, 1.0, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -344,7 +344,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
             var y = _matrices["Tall3x2"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, 1.0, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -365,7 +365,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
             var y = _matrices["Wide2x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, 1.0, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -384,7 +384,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
 
@@ -412,7 +412,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount);
 
@@ -436,7 +436,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
 
@@ -463,7 +463,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var work = new double[matrix.RowCount];
             Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount, work);
@@ -488,7 +488,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
 
@@ -516,7 +516,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
             Control.LinearAlgebraProvider.LUSolve(2, a, matrix.RowCount, b);
@@ -539,7 +539,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
             Control.LinearAlgebraProvider.LUFactor(a, matrix.RowCount, ipiv);
@@ -632,7 +632,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var r = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new double[3];
             var q = new double[matrix.RowCount * matrix.RowCount];
@@ -659,7 +659,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var r = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new double[3];
             var q = new double[matrix.RowCount * matrix.RowCount];
@@ -686,7 +686,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Wide2x3"];
             var r = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new double[3];
             var q = new double[matrix.RowCount * matrix.RowCount];
@@ -713,7 +713,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var r = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new double[3];
             var q = new double[matrix.RowCount * matrix.RowCount];
@@ -741,7 +741,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var r = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new double[3];
             var q = new double[matrix.RowCount * matrix.RowCount];
@@ -769,7 +769,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Wide2x3"];
             var r = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new double[3];
             var q = new double[matrix.RowCount * matrix.RowCount];
@@ -799,7 +799,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
             var r = new double[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new double[3];
             var q = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau);
 
@@ -826,7 +826,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
             var r = new double[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new double[3];
             var q = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau);
 
@@ -853,7 +853,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
             var r = new double[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new double[3];
             var q = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             var work = new double[matrix.ColumnCount * Control.BlockSize];
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau, work);
@@ -882,7 +882,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
             var r = new double[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new double[3];
             var q = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             var work = new double[matrix.ColumnCount * Control.BlockSize];
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau, work);
@@ -907,7 +907,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new double[matrix.ColumnCount * 2];
@@ -934,7 +934,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new double[matrix.ColumnCount * 2];
@@ -960,7 +960,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new double[matrix.ColumnCount * 2];
@@ -989,7 +989,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new double[matrix.ColumnCount * 2];
@@ -1016,7 +1016,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new double[matrix.ColumnCount];
             var q = new double[matrix.ColumnCount * matrix.ColumnCount];
@@ -1046,7 +1046,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new double[matrix.ColumnCount];
             var q = new double[matrix.RowCount * matrix.RowCount];
@@ -1074,7 +1074,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new double[matrix.ColumnCount];
             var q = new double[matrix.ColumnCount * matrix.ColumnCount];
@@ -1105,7 +1105,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new double[matrix.ColumnCount];
             var q = new double[matrix.RowCount * matrix.RowCount];
@@ -1133,7 +1133,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new double[matrix.ColumnCount * 2];
@@ -1160,7 +1160,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new double[matrix.ColumnCount * 2];
@@ -1186,7 +1186,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new double[matrix.ColumnCount * 2];
@@ -1215,7 +1215,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new double[matrix.ColumnCount * 2];
@@ -1242,7 +1242,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new double[matrix.ColumnCount];
             var r = new double[matrix.ColumnCount * matrix.ColumnCount];
@@ -1272,7 +1272,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new double[matrix.ColumnCount];
             var r = new double[matrix.ColumnCount * matrix.ColumnCount];
@@ -1300,7 +1300,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new double[matrix.ColumnCount];
             var r = new double[matrix.ColumnCount * matrix.ColumnCount];
@@ -1331,7 +1331,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new double[matrix.ColumnCount];
             var r = new double[matrix.ColumnCount * matrix.ColumnCount];
@@ -1359,7 +1359,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new double[matrix.RowCount];
             var u = new double[matrix.RowCount * matrix.RowCount];
@@ -1396,7 +1396,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new double[matrix.ColumnCount];
             var u = new double[matrix.RowCount * matrix.RowCount];
@@ -1430,7 +1430,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Wide2x3"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new double[matrix.RowCount];
             var u = new double[matrix.RowCount * matrix.RowCount];
@@ -1465,7 +1465,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new double[matrix.RowCount];
             var u = new double[matrix.RowCount * matrix.RowCount];
@@ -1504,7 +1504,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new double[matrix.ColumnCount];
             var u = new double[matrix.RowCount * matrix.RowCount];
@@ -1540,7 +1540,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Wide2x3"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new double[matrix.RowCount];
             var u = new double[matrix.RowCount * matrix.RowCount];
@@ -1575,7 +1575,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new double[matrix.ColumnCount * 2];
@@ -1602,7 +1602,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
             var x = new double[matrix.ColumnCount * 2];
@@ -1628,7 +1628,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Square3x3"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new double[matrix.RowCount];
             var u = new double[matrix.RowCount * matrix.RowCount];
@@ -1660,7 +1660,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         {
             var matrix = _matrices["Tall3x2"];
             var a = new double[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new double[matrix.ColumnCount];
             var u = new double[matrix.RowCount * matrix.RowCount];

src/UnitTests/LinearAlgebraProviderTests/Single/LinearAlgebraProviderTests.cs

@@ -189,7 +189,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var work = new float[matrix.RowCount];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work);
             AssertHelpers.AlmostEqual(12.1, norm, 6);
         }
 
@@ -201,7 +201,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var work = new float[matrix.RowCount];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work);
             AssertHelpers.AlmostEqual(10.777754868246, norm, 8);
         }
 
@@ -213,7 +213,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var work = new float[matrix.RowCount];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values, work);
             Assert.AreEqual(16.5, norm);
         }
 
@@ -224,7 +224,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         public void CanComputeMatrixL1NormWithWorkArray()
         {
             var matrix = _matrices["Square3x3"];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values);
             AssertHelpers.AlmostEqual(12.1, norm, 6);
         }
 
@@ -235,7 +235,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         public void CanComputeMatrixFrobeniusNormWithWorkArray()
         {
             var matrix = _matrices["Square3x3"];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values);
             AssertHelpers.AlmostEqual(10.777754868246, norm, 8);
         }
 
@@ -246,7 +246,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         public void CanComputeMatrixInfinityNormWithWorkArray()
         {
             var matrix = _matrices["Square3x3"];
-            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data);
+            var norm = Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Values);
             Assert.AreEqual(16.5, norm);
         }
 
@@ -260,7 +260,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
             var y = _matrices["Square3x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiply(x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -281,7 +281,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
             var y = _matrices["Tall3x2"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiply(x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -302,7 +302,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
             var y = _matrices["Wide2x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiply(x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -323,7 +323,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
             var y = _matrices["Square3x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2f, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0f, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2f, x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, 1.0f, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -344,7 +344,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
             var y = _matrices["Tall3x2"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2f, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0f, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2f, x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, 1.0f, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -365,7 +365,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
             var y = _matrices["Wide2x3"];
             var c = new DenseMatrix(x.RowCount, y.ColumnCount);
 
-            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2f, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0f, c.Data);
+            Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2f, x.Values, x.RowCount, x.ColumnCount, y.Values, y.RowCount, y.ColumnCount, 1.0f, c.Values);
 
             for (var i = 0; i < c.RowCount; i++)
             {
@@ -392,7 +392,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
 
@@ -420,7 +420,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount);
 
@@ -444,7 +444,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
 
@@ -471,7 +471,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var work = new float[matrix.RowCount];
             Control.LinearAlgebraProvider.LUInverse(a, matrix.RowCount, work);
@@ -496,7 +496,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
 
@@ -524,7 +524,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             Control.LinearAlgebraProvider.LUSolve(2, a, matrix.RowCount, b);
@@ -547,7 +547,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var ipiv = new int[matrix.RowCount];
             Control.LinearAlgebraProvider.LUFactor(a, matrix.RowCount, ipiv);
@@ -640,7 +640,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var r = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new float[3];
             var q = new float[matrix.RowCount * matrix.RowCount];
@@ -667,7 +667,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var r = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new float[3];
             var q = new float[matrix.RowCount * matrix.RowCount];
@@ -694,7 +694,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Wide2x3"];
             var r = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new float[3];
             var q = new float[matrix.RowCount * matrix.RowCount];
@@ -721,7 +721,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var r = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new float[3];
             var q = new float[matrix.RowCount * matrix.RowCount];
@@ -749,7 +749,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var r = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new float[3];
             var q = new float[matrix.RowCount * matrix.RowCount];
@@ -777,7 +777,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Wide2x3"];
             var r = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, r, r.Length);
+            Array.Copy(matrix.Values, r, r.Length);
 
             var tau = new float[3];
             var q = new float[matrix.RowCount * matrix.RowCount];
@@ -807,7 +807,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
             var r = new float[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new float[3];
             var q = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau);
 
@@ -834,7 +834,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
             var r = new float[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new float[3];
             var q = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau);
 
@@ -861,7 +861,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
             var r = new float[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new float[3];
             var q = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             var work = new float[matrix.RowCount * matrix.ColumnCount];
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau, work);
@@ -889,7 +889,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
             var r = new float[matrix.ColumnCount * matrix.ColumnCount];
             var tau = new float[3];
             var q = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, q, q.Length);
+            Array.Copy(matrix.Values, q, q.Length);
 
             var work = new float[matrix.RowCount * matrix.ColumnCount];
             Control.LinearAlgebraProvider.ThinQRFactor(q, matrix.RowCount, matrix.ColumnCount, r, tau, work);
@@ -914,7 +914,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new float[matrix.ColumnCount * 2];
@@ -941,7 +941,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new float[matrix.ColumnCount * 2];
@@ -967,7 +967,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new float[matrix.ColumnCount * 2];
@@ -996,7 +996,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new float[matrix.ColumnCount * 2];
@@ -1023,7 +1023,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new float[matrix.ColumnCount];
             var q = new float[matrix.ColumnCount * matrix.ColumnCount];
@@ -1053,7 +1053,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new float[matrix.ColumnCount];
             var q = new float[matrix.RowCount * matrix.RowCount];
@@ -1081,7 +1081,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.RowCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new float[matrix.ColumnCount];
             var q = new float[matrix.ColumnCount * matrix.ColumnCount];
@@ -1112,7 +1112,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new float[matrix.ColumnCount];
             var q = new float[matrix.RowCount * matrix.RowCount];
@@ -1140,7 +1140,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new float[matrix.ColumnCount * 2];
@@ -1167,7 +1167,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new float[matrix.ColumnCount * 2];
@@ -1193,7 +1193,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new float[matrix.ColumnCount * 2];
@@ -1222,7 +1222,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new float[matrix.ColumnCount * 2];
@@ -1249,7 +1249,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new float[matrix.ColumnCount];
             var r = new float[matrix.ColumnCount * matrix.ColumnCount];
@@ -1279,7 +1279,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new float[matrix.ColumnCount];
             var r = new float[matrix.ColumnCount * matrix.ColumnCount];
@@ -1307,7 +1307,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new float[matrix.ColumnCount];
             var r = new float[matrix.ColumnCount * matrix.ColumnCount];
@@ -1338,7 +1338,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var tau = new float[matrix.ColumnCount];
             var r = new float[matrix.ColumnCount * matrix.ColumnCount];
@@ -1366,7 +1366,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new float[matrix.RowCount];
             var u = new float[matrix.RowCount * matrix.RowCount];
@@ -1403,7 +1403,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new float[matrix.ColumnCount];
             var u = new float[matrix.RowCount * matrix.RowCount];
@@ -1437,7 +1437,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Wide2x3"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new float[matrix.RowCount];
             var u = new float[matrix.RowCount * matrix.RowCount];
@@ -1472,7 +1472,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new float[matrix.RowCount];
             var u = new float[matrix.RowCount * matrix.RowCount];
@@ -1511,7 +1511,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new float[matrix.ColumnCount];
             var u = new float[matrix.RowCount * matrix.RowCount];
@@ -1547,7 +1547,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Wide2x3"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new float[matrix.RowCount];
             var u = new float[matrix.RowCount * matrix.RowCount];
@@ -1582,7 +1582,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new float[matrix.ColumnCount * 2];
@@ -1609,7 +1609,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var b = new[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
             var x = new float[matrix.ColumnCount * 2];
@@ -1635,7 +1635,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Square3x3"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new float[matrix.RowCount];
             var u = new float[matrix.RowCount * matrix.RowCount];
@@ -1667,7 +1667,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Single
         {
             var matrix = _matrices["Tall3x2"];
             var a = new float[matrix.RowCount * matrix.ColumnCount];
-            Array.Copy(matrix.Data, a, a.Length);
+            Array.Copy(matrix.Values, a, a.Length);
 
             var s = new float[matrix.ColumnCount];
             var u = new float[matrix.RowCount * matrix.RowCount];