ufkc7e3d
/
mathnet-numerics
forked from tsai/mathnet-numerics
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Data: Text: static api only for delimited file reading and writing

provider
Christoph Ruegg 12 years ago
parent
b908592109
commit
9bbbb9124c
8 changed files with 89 additions and 271 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      src/Data/Matlab/Formatter.cs
  2. 42
      src/Data/Matlab/MatlabReader.cs
  3. 42
      src/Data/Matlab/MatlabWriter.cs
  4. 2
      src/Data/Matlab/Parser.cs
  5. 101
      src/Data/Text/DelimitedReader.cs
  6. 108
      src/Data/Text/DelimitedWriter.cs
  7. 35
      src/DataUnitTests/Text/DelimitedReaderTests.cs
  8. 28
      src/DataUnitTests/Text/DelimitedWriterTests.cs

2
src/Data/Matlab/Formatter.cs
View File

@ -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;

42
src/Data/Matlab/MatlabReader.cs
View File

@ -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);
}
}
}

42
src/Data/Matlab/MatlabWriter.cs
View File

@ -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)));
}

2
src/Data/Matlab/Parser.cs
View File

@ -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);
}

101
src/Data/Text/DelimitedReader.cs
View File

@ -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);
}
}

108
src/Data/Text/DelimitedWriter.cs
View File

@ -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);
}
}
}

35
src/DataUnitTests/Text/DelimitedReaderTests.cs
View File

@ -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);

28
src/DataUnitTests/Text/DelimitedWriterTests.cs
View File

@ -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();

Write Preview
Loading…
Cancel
Save