diff --git a/src/Data/Matlab/Formatter.cs b/src/Data/Matlab/Formatter.cs
index b62637de..6b8df327 100644
--- a/src/Data/Matlab/Formatter.cs
+++ b/src/Data/Matlab/Formatter.cs
@@ -234,7 +234,7 @@ namespace MathNet.Numerics.Data.Matlab
             where T : struct, IEquatable<T>, IFormattable
         {
             var transposed = matrix.Transpose();
-            var storage = ((SparseCompressedRowMatrixStorage<T>)transposed.Storage);
+            var storage = (SparseCompressedRowMatrixStorage<T>)transposed.Storage;
 
             bool smallBlock;
             int nzcount = storage.ValueCount;
diff --git a/src/Data/Matlab/MatlabReader.cs b/src/Data/Matlab/MatlabReader.cs
index eb4a6cf0..c8c1fc54 100644
--- a/src/Data/Matlab/MatlabReader.cs
+++ b/src/Data/Matlab/MatlabReader.cs
@@ -63,25 +63,25 @@ namespace MathNet.Numerics.Data.Matlab
         /// <summary>
         /// Unpacks the matrix of a MATLAB matrix data object.
         /// </summary>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static Matrix<TDataType> Unpack<TDataType>(MatlabMatrix matrixData)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static Matrix<T> Unpack<T>(MatlabMatrix matrixData)
+            where T : struct, IEquatable<T>, IFormattable
         {
-            return Parser.ParseMatrix<TDataType>(matrixData.Data);
+            return Parser.ParseMatrix<T>(matrixData.Data);
         }
 
         /// <summary>
         /// Read the first or a specific matrix from a MATLAB file stream.
         /// </summary>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static Matrix<TDataType> Read<TDataType>(Stream stream, string matrixName = null)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static Matrix<T> Read<T>(Stream stream, string matrixName = null)
+            where T : struct, IEquatable<T>, IFormattable
         {
             var matrices = List(stream);
 
             if (string.IsNullOrEmpty(matrixName))
             {
-                return Unpack<TDataType>(matrices.First());
+                return Unpack<T>(matrices.First());
             }
 
             var matrix = matrices.Find(m => m.Name == matrixName);
@@ -90,45 +90,45 @@ namespace MathNet.Numerics.Data.Matlab
                 throw new KeyNotFoundException("Matrix with the provided name was not found.");
             }
 
-            return Unpack<TDataType>(matrix);
+            return Unpack<T>(matrix);
         }
 
         /// <summary>
         /// Read the first or a specific matrix from a MATLAB file.
         /// </summary>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static Matrix<TDataType> Read<TDataType>(string filePath, string matrixName = null)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static Matrix<T> Read<T>(string filePath, string matrixName = null)
+            where T : struct, IEquatable<T>, IFormattable
         {
             using (var stream = File.OpenRead(filePath))
             {
-                return Read<TDataType>(stream, matrixName);
+                return Read<T>(stream, matrixName);
             }
         }
 
         /// <summary>
         /// Read all matrices or those with matching name from a MATLAB file stream.
         /// </summary>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static Dictionary<string, Matrix<TDataType>> ReadAll<TDataType>(Stream stream, params string[] matrixNames)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static Dictionary<string, Matrix<T>> ReadAll<T>(Stream stream, params string[] matrixNames)
+            where T : struct, IEquatable<T>, IFormattable
         {
             var names = new HashSet<string>(matrixNames);
             return List(stream)
                 .Where(m => names.Count == 0 || names.Contains(m.Name))
-                .ToDictionary(m => m.Name, Unpack<TDataType>);
+                .ToDictionary(m => m.Name, Unpack<T>);
         }
 
         /// <summary>
         /// Read all matrices or those with matching name from a MATLAB file.
         /// </summary>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static Dictionary<string, Matrix<TDataType>> ReadAll<TDataType>(string filePath, params string[] matrixNames)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static Dictionary<string, Matrix<T>> ReadAll<T>(string filePath, params string[] matrixNames)
+            where T : struct, IEquatable<T>, IFormattable
         {
             using (var stream = File.OpenRead(filePath))
             {
-                return ReadAll<TDataType>(stream, matrixNames);
+                return ReadAll<T>(stream, matrixNames);
             }
         }
     }
diff --git a/src/Data/Matlab/MatlabWriter.cs b/src/Data/Matlab/MatlabWriter.cs
index ece9edbd..8c552f64 100644
--- a/src/Data/Matlab/MatlabWriter.cs
+++ b/src/Data/Matlab/MatlabWriter.cs
@@ -54,30 +54,30 @@ namespace MathNet.Numerics.Data.Matlab
             }
         }
 
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static MatlabMatrix Pack<TDataType>(Matrix<TDataType> matrix, string matrixName)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static MatlabMatrix Pack<T>(Matrix<T> matrix, string matrixName)
+            where T : struct, IEquatable<T>, IFormattable
         {
             return Formatter.FormatMatrix(matrix, matrixName);
         }
 
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static void Write<TDataType>(Stream stream, Matrix<TDataType> matrix, string matrixName)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static void Write<T>(Stream stream, Matrix<T> matrix, string matrixName)
+            where T : struct, IEquatable<T>, IFormattable
         {
             Store(stream, new[] { Pack(matrix, matrixName) });
         }
 
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static void Write<TDataType>(string filePath, Matrix<TDataType> matrix, string matrixName)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static void Write<T>(string filePath, Matrix<T> matrix, string matrixName)
+            where T : struct, IEquatable<T>, IFormattable
         {
             Store(filePath, new[] { Pack(matrix, matrixName) });
         }
 
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static void Write<TDataType>(Stream stream, IList<Matrix<TDataType>> matrices, IList<string> names)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static void Write<T>(Stream stream, IList<Matrix<T>> matrices, IList<string> names)
+            where T : struct, IEquatable<T>, IFormattable
         {
             if (matrices.Count != names.Count)
             {
@@ -87,9 +87,9 @@ namespace MathNet.Numerics.Data.Matlab
             Store(stream, matrices.Zip(names, Pack));
         }
 
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static void Write<TDataType>(string filePath, IList<Matrix<TDataType>> matrices, IList<string> names)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static void Write<T>(string filePath, IList<Matrix<T>> matrices, IList<string> names)
+            where T : struct, IEquatable<T>, IFormattable
         {
             if (matrices.Count != names.Count)
             {
@@ -99,16 +99,16 @@ namespace MathNet.Numerics.Data.Matlab
             Store(filePath, matrices.Zip(names, Pack));
         }
 
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static void Write<TDataType>(Stream stream, IEnumerable<KeyValuePair<string, Matrix<TDataType>>> matrices)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static void Write<T>(Stream stream, IEnumerable<KeyValuePair<string, Matrix<T>>> matrices)
+            where T : struct, IEquatable<T>, IFormattable
         {
             Store(stream, matrices.Select(kv => Pack(kv.Value, kv.Key)));
         }
 
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static void Write<TDataType>(string filePath, IEnumerable<KeyValuePair<string, Matrix<TDataType>>> matrices)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static void Write<T>(string filePath, IEnumerable<KeyValuePair<string, Matrix<T>>> matrices)
+            where T : struct, IEquatable<T>, IFormattable
         {
             Store(filePath, matrices.Select(kv => Pack(kv.Value, kv.Key)));
         }
diff --git a/src/Data/Matlab/Parser.cs b/src/Data/Matlab/Parser.cs
index 909f4dba..1d9dbfde 100644
--- a/src/Data/Matlab/Parser.cs
+++ b/src/Data/Matlab/Parser.cs
@@ -218,7 +218,7 @@ namespace MathNet.Numerics.Data.Matlab
             ReadElementTag(reader, out type, out size, out smallBlock);
 
             // direct copy if possible
-            if (type == DataType.Double && dataType == typeof(double) || type == DataType.Single && dataType == typeof(float))
+            if ((type == DataType.Double && dataType == typeof(double)) || (type == DataType.Single && dataType == typeof(float)))
             {
                 Buffer.BlockCopy(reader.ReadBytes(size), 0, data, 0, size);
             }
diff --git a/src/Data/Text/DelimitedReader.cs b/src/Data/Text/DelimitedReader.cs
index 3f54bad3..d5f7b08c 100644
--- a/src/Data/Text/DelimitedReader.cs
+++ b/src/Data/Text/DelimitedReader.cs
@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2013 Math.NET
+// Copyright (c) 2009-2014 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -44,7 +44,7 @@ namespace MathNet.Numerics.Data.Text
     /// Creates a <see cref="Matrix{T}"/> from a delimited text file. If the user does not
     /// specify a delimiter, then any whitespace is used.
     /// </summary>
-    public class DelimitedReader
+    public static class DelimitedReader
     {
         /// <summary>
         /// The base regular expression.
@@ -56,83 +56,18 @@ namespace MathNet.Numerics.Data.Text
         /// </summary>
         static readonly ConcurrentDictionary<string, Regex> RegexCache = new ConcurrentDictionary<string, Regex>();
 
-        /// <summary>
-        /// The delimiter to use for parsing. Defaults to any whitespace.
-        /// </summary>
-        public string Delimiter { get; set; }
-
-        /// <summary>
-        /// Whether to create sparse matrices or not. Defaults to false.
-        /// </summary>
-        public bool Sparse { get; set; }
-
-        /// <summary>
-        /// Gets or sets a value indicating whether the files has a header row.
-        /// </summary>
-        /// <value>
-        /// <c>true</c> if this instance has a header row; otherwise, <c>false</c>.
-        /// </value>
-        /// <remarks>Defaults to <see langword="false"/>.</remarks>
-        public bool HasHeaderRow { get; set; }
-
-        /// <summary>
-        /// Gets or sets the <see cref="FormatProvider"/> to use when parsing the numbers.
-        /// </summary>
-        /// <value>The culture info.</value>
-        /// <remarks>Defaults to <c>CultureInfo.CurrentCulture</c>.</remarks>
-        public IFormatProvider FormatProvider { get; set; }
-
-        /// <summary>
-        /// Performs the actual reading.
-        /// </summary>
-        /// <param name="filePath">The path and name of the file to read the matrix from.</param>
-        /// <returns>
-        /// A matrix containing the data from the <see cref="Stream"/>.
-        /// </returns>
-        public Matrix<TDataType> ReadMatrix<TDataType>(string filePath)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
-        {
-            return ReadFile<TDataType>(filePath, Sparse, Delimiter, HasHeaderRow, FormatProvider);
-        }
-
-        /// <summary>
-        /// Performs the actual reading.
-        /// </summary>
-        /// <param name="stream">The <see cref="Stream"/> to read the matrix from.</param>
-        /// <returns>
-        /// A matrix containing the data from the <see cref="Stream"/>.
-        /// </returns>
-        public Matrix<TDataType> ReadMatrix<TDataType>(Stream stream)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
-        {
-            return ReadStream<TDataType>(stream, Sparse, Delimiter, HasHeaderRow, FormatProvider);
-        }
-
-        /// <summary>
-        /// Performs the actual reading.
-        /// </summary>
-        /// <param name="reader">The <see cref="TextReader"/> to read the matrix from.</param>
-        /// <returns>
-        /// A matrix containing the data from the <see cref="Stream"/>.
-        /// </returns>
-        public Matrix<TDataType> ReadMatrix<TDataType>(TextReader reader)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
-        {
-            return Read<TDataType>(reader, Sparse, Delimiter, HasHeaderRow, FormatProvider);
-        }
-
         /// <summary>
         /// Reads a <see cref="Matrix{TDataType}"/> from the given <see cref="TextReader"/>.
         /// </summary>
         /// <param name="reader">The <see cref="TextReader"/> to read the matrix from.</param>
-        /// <param name="sparse">Whether the the returned matrix should be constructed as sparse (true) or dense (false). Default: false.</param>
+        /// <param name="sparse">Whether the returned matrix should be constructed as sparse (true) or dense (false). Default: false.</param>
         /// <param name="delimiter">Number delimiter between numbers of the same line. Supports Regex groups. Default: "\s" (white space).</param>
         /// <param name="hasHeaders">Whether the first row contains column headers or not. Default: false.</param>
         /// <param name="formatProvider">The culture to use. Default: null.</param>
         /// <returns>A matrix containing the data from the <see cref="TextReader"/>.</returns>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static Matrix<TDataType> Read<TDataType>(TextReader reader, bool sparse = false, string delimiter = @"\s", bool hasHeaders = false, IFormatProvider formatProvider = null)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static Matrix<T> Read<T>(TextReader reader, bool sparse = false, string delimiter = @"\s", bool hasHeaders = false, IFormatProvider formatProvider = null)
+            where T : struct, IEquatable<T>, IFormattable
         {
             if (string.IsNullOrEmpty(delimiter))
             {
@@ -173,8 +108,8 @@ namespace MathNet.Numerics.Data.Text
                 line = reader.ReadLine();
             }
 
-            var parse = CreateParser<TDataType>(formatProvider);
-            var matrix = sparse ? Matrix<TDataType>.Build.Sparse(data.Count, max) : Matrix<TDataType>.Build.Dense(data.Count, max);
+            var parse = CreateParser<T>(formatProvider);
+            var matrix = sparse ? Matrix<T>.Build.Sparse(data.Count, max) : Matrix<T>.Build.Dense(data.Count, max);
             var storage = matrix.Storage;
 
             for (var i = 0; i < data.Count; i++)
@@ -198,18 +133,18 @@ namespace MathNet.Numerics.Data.Text
         /// Reads a <see cref="Matrix{TDataType}"/> from the given file.
         /// </summary>
         /// <param name="filePath">The path and name of the file to read the matrix from.</param>
-        /// <param name="sparse">Whether the the returned matrix should be constructed as sparse (true) or dense (false). Default: false.</param>
+        /// <param name="sparse">Whether the returned matrix should be constructed as sparse (true) or dense (false). Default: false.</param>
         /// <param name="delimiter">Number delimiter between numbers of the same line. Supports Regex groups. Default: "\s" (white space).</param>
         /// <param name="hasHeaders">Whether the first row contains column headers or not. Default: false.</param>
         /// <param name="formatProvider">The culture to use. Default: null.</param>
         /// <returns>A matrix containing the data from the <see cref="TextReader"/>.</returns>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static Matrix<TDataType> ReadFile<TDataType>(string filePath, bool sparse = false, string delimiter = @"\s", bool hasHeaders = false, IFormatProvider formatProvider = null)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static Matrix<T> Read<T>(string filePath, bool sparse = false, string delimiter = @"\s", bool hasHeaders = false, IFormatProvider formatProvider = null)
+            where T : struct, IEquatable<T>, IFormattable
         {
             using (var reader = new StreamReader(filePath))
             {
-                return Read<TDataType>(reader, sparse, delimiter, hasHeaders, formatProvider);
+                return Read<T>(reader, sparse, delimiter, hasHeaders, formatProvider);
             }
         }
 
@@ -217,18 +152,18 @@ namespace MathNet.Numerics.Data.Text
         /// Reads a <see cref="Matrix{TDataType}"/> from the given <see cref="Stream"/>.
         /// </summary>
         /// <param name="stream">The <see cref="Stream"/> to read the matrix from.</param>
-        /// <param name="sparse">Whether the the returned matrix should be constructed as sparse (true) or dense (false). Default: false.</param>
+        /// <param name="sparse">Whether the returned matrix should be constructed as sparse (true) or dense (false). Default: false.</param>
         /// <param name="delimiter">Number delimiter between numbers of the same line. Supports Regex groups. Default: "\s" (white space).</param>
         /// <param name="hasHeaders">Whether the first row contains column headers or not. Default: false.</param>
         /// <param name="formatProvider">The culture to use. Default: null.</param>
         /// <returns>A matrix containing the data from the <see cref="TextReader"/>.</returns>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public static Matrix<TDataType> ReadStream<TDataType>(Stream stream, bool sparse = false, string delimiter = @"\s", bool hasHeaders = false, IFormatProvider formatProvider = null)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
+        public static Matrix<T> Read<T>(Stream stream, bool sparse = false, string delimiter = @"\s", bool hasHeaders = false, IFormatProvider formatProvider = null)
+            where T : struct, IEquatable<T>, IFormattable
         {
             using (var reader = new StreamReader(stream))
             {
-                return Read<TDataType>(reader, sparse, delimiter, hasHeaders, formatProvider);
+                return Read<T>(reader, sparse, delimiter, hasHeaders, formatProvider);
             }
         }
 
diff --git a/src/Data/Text/DelimitedWriter.cs b/src/Data/Text/DelimitedWriter.cs
index fa88c6a6..42e09012 100644
--- a/src/Data/Text/DelimitedWriter.cs
+++ b/src/Data/Text/DelimitedWriter.cs
@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2013 Math.NET
+// Copyright (c) 2009-2014 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -39,97 +39,21 @@ namespace MathNet.Numerics.Data.Text
     /// Writes an <see cref="Matrix{TDataType}"/> to delimited text file. If the user does not
     /// specify a delimiter, a tab separator is used.
     /// </summary>
-    public class DelimitedWriter
+    public static class DelimitedWriter
     {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DelimitedWriter"/> class, using a tabulator as the delimiter.
-        /// </summary>
-        public DelimitedWriter()
-        {
-            Delimiter = "\t";
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DelimitedWriter"/> class, using the given delimiter.
-        /// </summary>
-        public DelimitedWriter(string delimiter)
-        {
-            Delimiter = delimiter;
-        }
-
-        /// <summary>
-        /// The delimiter to use.
-        /// </summary>
-        public string Delimiter { get; private set; }
-
-        /// <summary>
-        /// Gets or sets column headers. Headers are only written if the header list is neither <c>null</c> nor empty.
-        /// </summary>
-        public IList<string> ColumnHeaders { get; set; }
-
-        /// <summary>
-        /// Gets or sets the number format to use when writing numbers.
-        /// </summary>
-        public string Format { get; set; }
-
-        /// <summary>
-        /// Gets or sets the number format culture provider to use when writing numbers.
-        /// </summary>
-        public IFormatProvider FormatProvider { get; set; }
-
-        /// <summary>
-        /// Writes the given <see cref="Matrix{DataType}"/> to the given file. If the file already exists, 
-        /// the file will be overwritten.
-        /// </summary>
-        /// <param name="matrix">The matrix to write.</param>
-        /// <param name="filePath">The file to write the matrix to.</param>
-        /// <exception cref="ArgumentNullException">If either <paramref name="matrix"/> or <paramref name="filePath"/> is <c>null</c>.</exception>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public void WriteMatrix<TDataType>(Matrix<TDataType> matrix, string filePath)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
-        {
-            WriteFile(matrix, filePath, Delimiter, ColumnHeaders, Format, FormatProvider);
-        }
-
-        /// <summary>
-        /// Writes the given <see cref="Matrix{DataType}"/> to the given stream.
-        /// </summary>
-        /// <param name="matrix">The matrix to write.</param>
-        /// <param name="stream">The <see cref="Stream"/> to write the matrix to.</param>
-        /// <exception cref="ArgumentNullException">If either <paramref name="matrix"/> or <paramref name="stream"/> is <c>null</c>.</exception>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public void WriteMatrix<TDataType>(Matrix<TDataType> matrix, Stream stream)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
-        {
-            WriteStream(matrix, stream, Delimiter, ColumnHeaders, Format, FormatProvider);
-        }
-
-        /// <summary>
-        /// Writes the given <see cref="Matrix{TDataType}"/> to the given <see cref="TextWriter"/>.
-        /// </summary>
-        /// <param name="matrix">The matrix to write.</param>
-        /// <param name="writer">The <see cref="TextWriter"/> to write the matrix to.</param>
-        /// <exception cref="ArgumentNullException">If either <paramref name="matrix"/> or <paramref name="writer"/> is <c>null</c>.</exception>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: double, float, Complex, or Complex32.</typeparam>
-        public void WriteMatrix<TDataType>(Matrix<TDataType> matrix, TextWriter writer)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
-        {
-            Write(matrix, writer, Delimiter, ColumnHeaders, Format, FormatProvider);
-        }
-
         /// <summary>
         /// Writes a matrix to the given TextWriter. Optionally accepts custom column headers, delimiter, number format and culture.
         /// </summary>
-        /// <param name="matrix">The matrix to write.</param>
         /// <param name="writer">The <see cref="TextWriter"/> to write the matrix to.</param>
+        /// <param name="matrix">The matrix to write.</param>
         /// <param name="delimiter">Number delimiter to write between numbers of the same line. Default:  "\t" (tabulator).</param>
         /// <param name="columnHeaders">Custom column header. Headers are only written if non-null and non-empty headers are provided. Default: null.</param>
         /// <param name="format">The number format to use on each element. Default: null.</param>
         /// <param name="formatProvider">The culture to use. Default: null.</param>
         /// <exception cref="ArgumentNullException">If either <paramref name="matrix"/> or <paramref name="writer"/> is <c>null</c>.</exception>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: Double, Single, Complex, or Complex32.</typeparam>
-        public static void Write<TDataType>(Matrix<TDataType> matrix, TextWriter writer, string delimiter = "\t", IList<string> columnHeaders = null, string format = null, IFormatProvider formatProvider = null)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: Double, Single, Complex, or Complex32.</typeparam>
+        public static void Write<T>(TextWriter writer, Matrix<T> matrix, string delimiter = "\t", IList<string> columnHeaders = null, string format = null, IFormatProvider formatProvider = null)
+            where T : struct, IEquatable<T>, IFormattable
         {
             if (matrix == null)
             {
@@ -175,40 +99,40 @@ namespace MathNet.Numerics.Data.Text
         /// <summary>
         /// Writes a matrix to the given file. Optionally accepts custom column headers, delimiter, number format and culture.
         /// </summary>
-        /// <param name="matrix">The matrix to write.</param>
         /// <param name="filePath">The path and name of the file to write the matrix to. If the file already exists, the file will be overwritten.</param>
+        /// <param name="matrix">The matrix to write.</param>
         /// <param name="delimiter">Number delimiter to write between numbers of the same line. Default:  "\t" (tabulator).</param>
         /// <param name="columnHeaders">Custom column header. Headers are only written if non-null and non-empty headers are provided. Default: null.</param>
         /// <param name="format">The number format to use on each element. Default: null.</param>
         /// <param name="formatProvider">The culture to use. Default: null.</param>
         /// <exception cref="ArgumentNullException">If either <paramref name="matrix"/> or <paramref name="filePath"/> is <c>null</c>.</exception>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: Double, Single, Complex, or Complex32.</typeparam>
-        public static void WriteFile<TDataType>(Matrix<TDataType> matrix, string filePath, string delimiter = "\t", IList<string> columnHeaders = null, string format = null, IFormatProvider formatProvider = null)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: Double, Single, Complex, or Complex32.</typeparam>
+        public static void Write<T>(string filePath, Matrix<T> matrix, string delimiter = "\t", IList<string> columnHeaders = null, string format = null, IFormatProvider formatProvider = null)
+            where T : struct, IEquatable<T>, IFormattable
         {
             using (var writer = new StreamWriter(filePath))
             {
-                Write(matrix, writer, delimiter, columnHeaders, format, formatProvider);
+                Write(writer, matrix, delimiter: delimiter, columnHeaders: columnHeaders, format: format, formatProvider: formatProvider);
             }
         }
 
         /// <summary>
         /// Writes a matrix to the given stream. Optionally accepts custom column headers, delimiter, number format and culture.
         /// </summary>
-        /// <param name="matrix">The matrix to write.</param>
         /// <param name="stream">The <see cref="Stream"/> to write the matrix to.</param>
+        /// <param name="matrix">The matrix to write.</param>
         /// <param name="delimiter">Number delimiter to write between numbers of the same line. Default: "\t" (tabulator).</param>
         /// <param name="columnHeaders">Custom column header. Headers are only written if non-null and non-empty headers are provided. Default: null.</param>
         /// <param name="format">The number format to use on each element. Default: null.</param>
         /// <param name="formatProvider">The culture to use. Default: null.</param>
         /// <exception cref="ArgumentNullException">If either <paramref name="matrix"/> or <paramref name="stream"/> is <c>null</c>.</exception>
-        /// <typeparam name="TDataType">The data type of the Matrix. It can be either: Double, Single, Complex, or Complex32.</typeparam>
-        public static void WriteStream<TDataType>(Matrix<TDataType> matrix, Stream stream, string delimiter = "\t", IList<string> columnHeaders = null, string format = null, IFormatProvider formatProvider = null)
-            where TDataType : struct, IEquatable<TDataType>, IFormattable
+        /// <typeparam name="T">The data type of the Matrix. It can be either: Double, Single, Complex, or Complex32.</typeparam>
+        public static void Write<T>(Stream stream, Matrix<T> matrix, string delimiter = "\t", IList<string> columnHeaders = null, string format = null, IFormatProvider formatProvider = null)
+            where T : struct, IEquatable<T>, IFormattable
         {
             using (var writer = new StreamWriter(stream))
             {
-                Write(matrix, writer, delimiter, columnHeaders, format, formatProvider);
+                Write(writer, matrix, delimiter: delimiter, columnHeaders: columnHeaders, format: format, formatProvider: formatProvider);
             }
         }
     }
diff --git a/src/DataUnitTests/Text/DelimitedReaderTests.cs b/src/DataUnitTests/Text/DelimitedReaderTests.cs
index 49ffafd1..08483857 100644
--- a/src/DataUnitTests/Text/DelimitedReaderTests.cs
+++ b/src/DataUnitTests/Text/DelimitedReaderTests.cs
@@ -55,14 +55,7 @@ namespace MathNet.Numerics.Data.UnitTests.Text
                        + "\"2.2\",0.3e1" + Environment.NewLine
                        + "'4',5,6" + Environment.NewLine;
 
-            var reader = new DelimitedReader
-                {
-                    Delimiter = ",",
-                    HasHeaderRow = true,
-                    FormatProvider = CultureInfo.InvariantCulture
-                };
-
-            var matrix = reader.ReadMatrix<double>(new MemoryStream(Encoding.UTF8.GetBytes(data)));
+            var matrix = DelimitedReader.Read<double>(new MemoryStream(Encoding.UTF8.GetBytes(data)), delimiter: ",", hasHeaders: true, formatProvider: CultureInfo.InvariantCulture);
             Assert.AreEqual(3, matrix.RowCount);
             Assert.AreEqual(3, matrix.ColumnCount);
             Assert.AreEqual(1.0, matrix[0, 0]);
@@ -86,7 +79,7 @@ namespace MathNet.Numerics.Data.UnitTests.Text
                        + "\"2.2\"\t\t0.3e1" + Environment.NewLine
                        + "'4'\t5\t6";
 
-            var matrix = DelimitedReader.ReadStream<float>(new MemoryStream(Encoding.UTF8.GetBytes(data)), delimiter: "\t", formatProvider: CultureInfo.InvariantCulture);
+            var matrix = DelimitedReader.Read<float>(new MemoryStream(Encoding.UTF8.GetBytes(data)), delimiter: "\t", formatProvider: CultureInfo.InvariantCulture);
             Assert.AreEqual(3, matrix.RowCount);
             Assert.AreEqual(3, matrix.ColumnCount);
             Assert.AreEqual(1.0f, matrix[0, 0]);
@@ -110,12 +103,7 @@ namespace MathNet.Numerics.Data.UnitTests.Text
                        + "\"2.2\" 0.3e1" + Environment.NewLine
                        + "'4'   5      6" + Environment.NewLine;
 
-            var reader = new DelimitedReader
-                {
-                    FormatProvider = CultureInfo.InvariantCulture
-                };
-
-            var matrix = reader.ReadMatrix<float>(new MemoryStream(Encoding.UTF8.GetBytes(data)));
+            var matrix = DelimitedReader.Read<float>(new MemoryStream(Encoding.UTF8.GetBytes(data)), formatProvider: CultureInfo.InvariantCulture);
             Assert.AreEqual(3, matrix.RowCount);
             Assert.AreEqual(3, matrix.ColumnCount);
             Assert.AreEqual(1.0f, matrix[0, 0]);
@@ -140,13 +128,7 @@ namespace MathNet.Numerics.Data.UnitTests.Text
                        + "\"2,2\".0,3e1" + Environment.NewLine
                        + "'4,0'.5,0.6,0" + Environment.NewLine;
 
-            var reader = new DelimitedReader
-                {
-                    Delimiter = ".",
-                    HasHeaderRow = true,
-                    FormatProvider = new CultureInfo("tr-TR")
-                };
-            var matrix = reader.ReadMatrix<double>(new MemoryStream(Encoding.UTF8.GetBytes(data)));
+            var matrix = DelimitedReader.Read<double>(new MemoryStream(Encoding.UTF8.GetBytes(data)), delimiter: ".", hasHeaders: true, formatProvider: new CultureInfo("tr-TR"));
             Assert.AreEqual(3, matrix.RowCount);
             Assert.AreEqual(3, matrix.ColumnCount);
             Assert.AreEqual(1.0, matrix[0, 0]);
@@ -199,14 +181,7 @@ namespace MathNet.Numerics.Data.UnitTests.Text
                        + "\"2.2\",0.3e1" + Environment.NewLine
                        + "'(4,-5)',5,6" + Environment.NewLine;
 
-            var reader = new DelimitedReader
-            {
-                Delimiter = ",",
-                HasHeaderRow = true,
-                FormatProvider = CultureInfo.InvariantCulture
-            };
-
-            var matrix = reader.ReadMatrix<Complex32>(new MemoryStream(Encoding.UTF8.GetBytes(data)));
+            var matrix = DelimitedReader.Read<Complex32>(new MemoryStream(Encoding.UTF8.GetBytes(data)), delimiter: ",", hasHeaders: true, formatProvider: CultureInfo.InvariantCulture);
             Assert.AreEqual(3, matrix.RowCount);
             Assert.AreEqual(3, matrix.ColumnCount);
             Assert.AreEqual(1.0f, matrix[0, 0].Real);
diff --git a/src/DataUnitTests/Text/DelimitedWriterTests.cs b/src/DataUnitTests/Text/DelimitedWriterTests.cs
index 66c3ce3a..bc364ff3 100644
--- a/src/DataUnitTests/Text/DelimitedWriterTests.cs
+++ b/src/DataUnitTests/Text/DelimitedWriterTests.cs
@@ -54,12 +54,8 @@ namespace MathNet.Numerics.Data.UnitTests.Text
                         {new Complex32(4.4f, 4.4f), new Complex32(5.5f, 5.5f), new Complex32(6.6f, 6.6f)},
                         {new Complex32(7.7f, 7.7f), new Complex32(8.8f, 8.8f), new Complex32(9.9f, 9.9f)}
                     });
-            var writer = new DelimitedWriter(",")
-                {
-                    FormatProvider = CultureInfo.InvariantCulture
-                };
             var stream = new MemoryStream();
-            writer.WriteMatrix(matrix, stream);
+            DelimitedWriter.Write(stream, matrix, ",", formatProvider: CultureInfo.InvariantCulture);
             var data = stream.ToArray();
             var reader = new StreamReader(new MemoryStream(data));
             var text = reader.ReadToEnd();
@@ -79,12 +75,8 @@ namespace MathNet.Numerics.Data.UnitTests.Text
                         {new Complex(4.4, 4.4), new Complex(5.5, 5.5), new Complex(6.6, 6.6)},
                         {new Complex(7.7, 7.7), new Complex(8.8, 8.8), new Complex(9.9, 9.9)}
                     });
-            var writer = new DelimitedWriter(",")
-                {
-                    FormatProvider = CultureInfo.InvariantCulture
-                };
             var stream = new MemoryStream();
-            writer.WriteMatrix(matrix, stream);
+            DelimitedWriter.Write(stream, matrix, ",", formatProvider: CultureInfo.InvariantCulture);
             var data = stream.ToArray();
             var reader = new StreamReader(new MemoryStream(data));
             var text = reader.ReadToEnd();
@@ -98,12 +90,8 @@ namespace MathNet.Numerics.Data.UnitTests.Text
         public void CanWriteCommaDelimitedDoubleData()
         {
             var matrix = DenseMatrix.OfArray(new[,] {{1.1, 2.2, 3.3}, {4.4, 5.5, 6.6}, {7.7, 8.8, 9.9}});
-            var writer = new DelimitedWriter(",")
-                {
-                    FormatProvider = CultureInfo.InvariantCulture
-                };
             var stream = new MemoryStream();
-            writer.WriteMatrix(matrix, stream);
+            DelimitedWriter.Write(stream, matrix, ",", formatProvider: CultureInfo.InvariantCulture);
             var data = stream.ToArray();
             var reader = new StreamReader(new MemoryStream(data));
             var text = reader.ReadToEnd();
@@ -117,12 +105,8 @@ namespace MathNet.Numerics.Data.UnitTests.Text
         public void CanWriteCommaDelimitedSingleData()
         {
             var matrix = LinearAlgebra.Single.DenseMatrix.OfArray(new[,] {{1.1f, 2.2f, 3.3f}, {4.4f, 5.5f, 6.6f}, {7.7f, 8.8f, 9.9f}});
-            var writer = new DelimitedWriter(",")
-                {
-                    FormatProvider = CultureInfo.InvariantCulture
-                };
             var stream = new MemoryStream();
-            writer.WriteMatrix(matrix, stream);
+            DelimitedWriter.Write(stream, matrix, ",", formatProvider: CultureInfo.InvariantCulture);
             var data = stream.ToArray();
             var reader = new StreamReader(new MemoryStream(data));
             var text = reader.ReadToEnd();
@@ -140,7 +124,7 @@ namespace MathNet.Numerics.Data.UnitTests.Text
         {
             var matrix = DenseMatrix.OfArray(new[,] {{1.1, 2.2, 3.3}, {4.4, 5.5, 6.6}, {7.7, 8.8, 9.9}});
             var stream = new MemoryStream();
-            DelimitedWriter.WriteStream(matrix, stream, ".", formatProvider: new CultureInfo("tr-TR"));
+            DelimitedWriter.Write(stream, matrix, delimiter: ".", formatProvider: new CultureInfo("tr-TR"));
             var data = stream.ToArray();
             var reader = new StreamReader(new MemoryStream(data));
             var text = reader.ReadToEnd();
@@ -158,7 +142,7 @@ namespace MathNet.Numerics.Data.UnitTests.Text
         {
             var matrix = SparseMatrix.OfArray(new[,] {{1.1, 0, 0}, {0, 5.5, 0}, {0, 0, 9.9}});
             var stream = new MemoryStream();
-            DelimitedWriter.WriteStream(matrix, stream, " ");
+            DelimitedWriter.Write(stream, matrix, " ");
             var data = stream.ToArray();
             var reader = new StreamReader(new MemoryStream(data));
             var text = reader.ReadToEnd();