// // Math.NET Numerics, part of the Math.NET Project // http://numerics.mathdotnet.com // http://github.com/mathnet/mathnet-numerics // http://mathnetnumerics.codeplex.com // // 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 // files (the "Software"), to deal in the Software without // restriction, including without limitation the rights to use, // copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the // Software is furnished to do so, subject to the following // conditions: // // The above copyright notice and this permission notice shall be // included in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR // OTHER DEALINGS IN THE SOFTWARE. // using System; using System.Globalization; using System.IO; using System.IO.Compression; using System.Numerics; using MathNet.Numerics.LinearAlgebra; using MathNet.Numerics.LinearAlgebra.Storage; namespace MathNet.Numerics.Data.Text { /// /// NIST MatrixMarket Format Writer (http://math.nist.gov/MatrixMarket/) /// public static class MatrixMarketWriter { static readonly NumberFormatInfo Format = CultureInfo.InvariantCulture.NumberFormat; public static void WriteMatrix(string filePath, Matrix matrix, Compression compression = Compression.Uncompressed) where T : struct, IEquatable, IFormattable { using (var stream = File.OpenWrite(filePath)) { switch (compression) { case Compression.Uncompressed: using (var writer = new StreamWriter(stream)) { WriteMatrix(writer, matrix); } break; case Compression.GZip: using (var compressed = new GZipStream(stream, CompressionMode.Compress)) using (var buffered = new BufferedStream(compressed, 4096)) using (var writer = new StreamWriter(buffered)) { WriteMatrix(writer, matrix); } break; default: throw new NotSupportedException("Compression not supported: " + compression); } } } public static void WriteVector(string filePath, Vector vector, Compression compression = Compression.Uncompressed) where T : struct, IEquatable, IFormattable { using (var stream = File.OpenRead(filePath)) { switch (compression) { case Compression.Uncompressed: using (var writer = new StreamWriter(stream)) { WriteVector(writer, vector); } break; case Compression.GZip: using (var compressed = new GZipStream(stream, CompressionMode.Compress)) using (var buffered = new BufferedStream(compressed, 4096)) using (var writer = new StreamWriter(buffered)) { WriteVector(writer, vector); } break; default: throw new NotSupportedException("Compression not supported: " + compression); } } } public static void WriteMatrix(Stream stream, Matrix matrix) where T : struct, IEquatable, IFormattable { using (var writer = new StreamWriter(stream)) { WriteMatrix(writer, matrix); } } public static void WriteVector(Stream stream, Vector vector) where T : struct, IEquatable, IFormattable { using (var writer = new StreamWriter(stream)) { WriteVector(writer, vector); } } public static void WriteMatrix(TextWriter writer, Matrix matrix) where T : struct, IEquatable, IFormattable { var complex = typeof (T) == typeof (Complex) || typeof (T) == typeof (Complex32); var format = CreateValueFormatter(); var storage = matrix.Storage; var sparse = storage as SparseCompressedRowMatrixStorage; if (sparse != null) { writer.WriteLine("%%MatrixMarket matrix coordinate {0} general", complex ? "complex" : "real"); writer.WriteLine("{0} {1} {2}", sparse.RowCount, sparse.ColumnCount, sparse.ValueCount); for (int row = 0; row < sparse.RowCount; row++) { var endIndex = sparse.RowPointers[row + 1]; for (var j = sparse.RowPointers[row]; j < endIndex; j++) { writer.WriteLine("{0} {1} {2}", row + 1, sparse.ColumnIndices[j] + 1, format(sparse.Values[j])); } } return; } var diagonal = storage as DiagonalMatrixStorage; if (diagonal != null) { writer.WriteLine("%%MatrixMarket matrix coordinate {0} general", complex ? "complex" : "real"); writer.WriteLine("{0} {1} {2}", diagonal.RowCount, diagonal.ColumnCount, diagonal.Data.Length); for (int k = 0; k < diagonal.Data.Length; k++) { writer.WriteLine("{0} {1} {2}", k + 1, k + 1, format(diagonal.Data[k])); } return; } var dense = storage as DenseColumnMajorMatrixStorage; if (dense != null) { writer.WriteLine("%%MatrixMarket matrix array {0} general", complex ? "complex" : "real"); writer.WriteLine("{0} {1}", dense.RowCount, dense.ColumnCount); foreach (var value in dense.Data) { writer.WriteLine(format(value)); } return; } writer.WriteLine("%%MatrixMarket matrix array {0} general", complex ? "complex" : "real"); writer.WriteLine("{0} {1}", storage.RowCount, storage.ColumnCount); foreach (var value in storage.ToColumnMajorArray()) { writer.WriteLine(format(value)); } } public static void WriteVector(TextWriter writer, Vector vector) where T : struct, IEquatable, IFormattable { var complex = typeof (T) == typeof (Complex) || typeof (T) == typeof (Complex32); var format = CreateValueFormatter(); var storage = vector.Storage; var sparse = storage as SparseVectorStorage; if (sparse != null) { writer.WriteLine("%%MatrixMarket vector coordinate {0}", complex ? "complex" : "real"); writer.WriteLine("{0} {1}", sparse.Length, sparse.ValueCount); for (var k = 0; k < sparse.ValueCount; k++) { writer.WriteLine("{0} {1}", k + 1, format(sparse.Values[k])); } return; } var dense = storage as DenseVectorStorage; if (dense != null) { writer.WriteLine("%%MatrixMarket vector array {0}", complex ? "complex" : "real"); writer.WriteLine("{0}", dense.Length); foreach (var value in dense.Data) { writer.WriteLine(format(value)); } return; } writer.WriteLine("%%MatrixMarket vector array {0}", complex ? "complex" : "real"); writer.WriteLine("{0}", storage.Length); foreach (var value in storage.Enumerate()) { writer.WriteLine(format(value)); } } static Func CreateValueFormatter() where T : IFormattable { if (typeof (T) == typeof (double)) { return value => string.Format(Format, "{0:G14}", value); } if (typeof (T) == typeof (float)) { return value => string.Format(Format, "{0:G7}", value); } if (typeof (T) == typeof (Complex)) { return value => { var c = (Complex)(object)value; return string.Format(Format, "{0:G14} {1:G14}", c.Real, c.Imaginary); }; } if (typeof (T) == typeof (Complex32)) { return value => { var c = (Complex32)(object)value; return string.Format(Format, "{0:G7} {1:G7}", c.Real, c.Imaginary); }; } throw new NotSupportedException(); } } }