public void ConstructorTest() { MemoryStream file = new MemoryStream(Resources.simplestruct); // Create a new MAT file reader var reader = new MatReader(file); // Extract some basic information about the file: string description = reader.Description; // "MATLAB 5.0 MAT-file, Platform: PCWIN" int version = reader.Version; // 256 bool bigEndian = reader.BigEndian; // false // Enumerate the fields in the file foreach (var field in reader.Fields) Console.WriteLine(field.Key); // "structure" // We have the single following field var structure = reader["structure"]; // Enumerate the fields in the structure foreach (var field in structure.Fields) Console.WriteLine(field.Key); // "a", "string" // Check the type for the field "a" var aType = structure["a"].ValueType; // byte[,] // Retrieve the field "a" from the file var a = structure["a"].GetValue<byte[,]>(); // We can also do directly if we know the type in advance var s = reader["structure"]["string"].GetValue<string>(); Assert.AreEqual(typeof(byte[,]), aType); Assert.AreEqual(typeof(string), reader["structure"]["string"].ValueType); Assert.AreEqual( "MATLAB 5.0 MAT-file, Platform: PCWIN, Created on: Thu Feb 22 01:39:50 2007", reader.Description); Assert.AreEqual(256, reader.Version); Assert.IsFalse(reader.BigEndian); byte[,] expected = { { 1, 2, 3 }, { 4, 5, 6 }, }; Assert.IsTrue(expected.IsEqual(a)); Assert.AreEqual("ala ma kota", s); }
internal unsafe MatNode(MatReader matReader, BinaryReader reader, long offset, MatDataTag tag, bool lazy) { // TODO: Completely refactor this method. this.matReader = matReader; // int originalBytes = tag.NumberOfBytes; contents = new Dictionary <string, MatNode>(); this.startOffset = offset; this.reader = reader; if (tag.DataType == MatDataType.miCOMPRESSED) { compressed = true; // Read zlib's streams with Deflate using a little trick // http://george.chiramattel.com/blog/2007/09/deflatestream-block-length-does-not-match.html reader.ReadBytes(2); // ignore zlib headers reader = new BinaryReader(new DeflateStream(reader.BaseStream, CompressionMode.Decompress, true)); readBytes += 8; if (!reader.Read(out tag)) { throw new NotSupportedException("Invalid reader at position " + readBytes + "."); } } if (tag.DataType != MatDataType.miMATRIX) { throw new NotSupportedException("Unexpected data type at position " + readBytes + "."); } readBytes += 8; MatDataTag flagsTag; if (!reader.Read(out flagsTag)) { throw new NotSupportedException("Invalid flags tag at position " + readBytes + "."); } if (flagsTag.DataType != MatDataType.miUINT32) { throw new NotSupportedException("Unexpected flags data type at position " + readBytes + "."); } readBytes += 8; ArrayFlags flagsElement; if (!reader.Read(out flagsElement)) { throw new NotSupportedException("Invalid flags element at position " + readBytes + "."); } if (flagsElement.Class == MatArrayType.mxOBJECT_CLASS) { throw new NotSupportedException("Unexpected object class flag at position " + readBytes + "."); } readBytes += 8; MatDataTag dimensionsTag; if (!reader.Read(out dimensionsTag)) { throw new NotSupportedException("Invalid dimensions tag at position " + readBytes + "."); } if (dimensionsTag.DataType != MatDataType.miINT32) { throw new NotSupportedException("Invalid dimensions data type at position " + readBytes + "."); } int numberOfDimensions = (int)dimensionsTag.NumberOfBytes / 4; dimensions = new int[numberOfDimensions]; for (int i = dimensions.Length - 1; i >= 0; i--) { dimensions[i] = reader.ReadInt32(); } readBytes += dimensions.Length * 4; readBytes += 8; MatDataTag nameTag; if (!reader.Read(out nameTag)) { throw new NotSupportedException("Invalid name tag at position " + readBytes + "."); } if (nameTag.DataType != MatDataType.miINT8) { throw new NotSupportedException("Invalid name data type at position " + readBytes + "."); } if (nameTag.IsSmallFormat) { #if NETSTANDARD1_4 Name = new String((char *)nameTag.SmallData_Value, 0, nameTag.SmallData_NumberOfBytes); #else Name = new String((sbyte *)nameTag.SmallData_Value, 0, nameTag.SmallData_NumberOfBytes); #endif } else { readBytes += nameTag.NumberOfBytes; Name = new String(reader.ReadChars((int)nameTag.NumberOfBytes)); align(reader, nameTag.NumberOfBytes); } Name = Name.Trim(); if (flagsElement.Class == MatArrayType.mxSPARSE_CLASS) { readBytes += 8; MatDataTag irTag; if (!reader.Read(out irTag)) { throw new NotSupportedException("Invalid sparse row tag at position " + readBytes + "."); } // read ir int[] ir = new int[irTag.NumberOfBytes / 4]; for (int i = 0; i < ir.Length; i++) { ir[i] = reader.ReadInt32(); } align(reader, irTag.NumberOfBytes); readBytes += 8; MatDataTag icTag; if (!reader.Read(out icTag)) { throw new NotSupportedException("Invalid sparse column tag at position " + readBytes + "."); } // read ic int[] ic = new int[icTag.NumberOfBytes / 4]; for (int i = 0; i < ic.Length; i++) { ic[i] = reader.ReadInt32(); } align(reader, icTag.NumberOfBytes); // read values readBytes += 8; MatDataTag valuesTag; if (!reader.Read(out valuesTag)) { throw new NotSupportedException("Invalid values tag at position " + readBytes + "."); } MatDataType matType = valuesTag.DataType; type = MatReader.Translate(matType); #pragma warning disable 618 // SizeOf would be Obsolete typeSize = Marshal.SizeOf(type); #pragma warning restore 618 // SizeOf would be Obsolete length = valuesTag.NumberOfBytes / typeSize; bytes = valuesTag.NumberOfBytes; byte[] rawData = reader.ReadBytes(bytes); align(reader, rawData.Length); if (matType == MatDataType.miINT64 || matType == MatDataType.miUINT64) { for (int i = 7; i < rawData.Length; i += 8) { byte b = rawData[i]; bool bit = (b & (1 << 6)) != 0; if (bit) { rawData[i] |= 1 << 7; } else { rawData[i] = (byte)(b & ~(1 << 7)); } } } Array array = Array.CreateInstance(type, length); Buffer.BlockCopy(rawData, 0, array, 0, rawData.Length); value = new MatSparse(ir, ic, array); } else if (flagsElement.Class == MatArrayType.mxCELL_CLASS) { int readBytes2 = 0; int toRead = tag.NumberOfBytes - readBytes; int cellI = 0; while (readBytes2 < toRead) { // Read first MAT data element MatDataTag elementTag; if (!reader.Read(out elementTag)) { throw new NotSupportedException("Invalid element tag at position " + readBytes + "."); } // Create a new node from the current position MatNode node = new MatNode(matReader, reader, offset, elementTag, false); node.Name = (cellI++).ToString(); contents.Add(node.Name, node); readBytes2 += elementTag.NumberOfBytes + 8; } } else if (flagsElement.Class == MatArrayType.mxSTRUCT_CLASS) { MatDataTag fieldNameLengthTag; if (!reader.Read(out fieldNameLengthTag)) { throw new NotSupportedException("Invalid struct field name length tag at position " + readBytes + "."); } if (!fieldNameLengthTag.IsSmallFormat) { throw new NotSupportedException("Small format struct field name length is not supported at position " + readBytes + "."); } int fieldNameLength = *(int *)fieldNameLengthTag.SmallData_Value; if (fieldNameLengthTag.DataType != MatDataType.miINT32) { throw new NotSupportedException("Unexpected struct field name length data type at position " + readBytes + "."); } MatDataTag fieldNameTag; if (!reader.Read(out fieldNameTag)) { throw new NotSupportedException("Invalid struct field name at position " + readBytes + "."); } if (fieldNameTag.DataType != MatDataType.miINT8) { throw new NotSupportedException("Unexpected struct field name data type at position " + readBytes + "."); } int fields = fieldNameTag.NumberOfBytes / fieldNameLength; string[] names = new string[fields]; for (int i = 0; i < names.Length; i++) { char[] charNames = reader.ReadChars(fieldNameLength); int terminator = Array.IndexOf(charNames, '\0'); names[i] = new String(charNames, 0, terminator); } align(reader, fieldNameTag.NumberOfBytes); for (int i = 0; i < names.Length; i++) { Debug.WriteLine("reading " + names[i]); // Read first MAT data element MatDataTag elementTag; if (!reader.Read(out elementTag)) { throw new NotSupportedException("Invalid struct element at position " + readBytes + "."); } if (elementTag.DataType == MatDataType.miINT32) { throw new NotSupportedException("Unexpected struct element data type at position " + readBytes + "."); } // Create a new node from the current position MatNode node = new MatNode(matReader, reader, offset, elementTag, false); node.Name = names[i]; contents.Add(node.Name, node); } } else { readBytes += 8; MatDataTag contentsTag; if (!reader.Read(out contentsTag)) { throw new NotSupportedException("Invalid contents tag at position " + readBytes + "."); } if (contentsTag.IsSmallFormat) { matType = contentsTag.SmallData_Type; if (matType == MatDataType.miUTF8) { #if NETSTANDARD1_4 value = new String((char *)contentsTag.SmallData_Value, 0, contentsTag.SmallData_NumberOfBytes); #else value = new String((sbyte *)contentsTag.SmallData_Value, 0, contentsTag.SmallData_NumberOfBytes); #endif } else { type = MatReader.Translate(matType); #pragma warning disable 618 // SizeOf would be Obsolete typeSize = Marshal.SizeOf(type); #pragma warning restore 618 // SizeOf would be Obsolete length = 1; for (int i = 0; i < dimensions.Length; i++) { length *= dimensions[i]; } var array = Array.CreateInstance(type, dimensions); byte[] rawData = new byte[4]; for (int i = 0; i < rawData.Length; i++) { rawData[i] = contentsTag.SmallData_Value[i]; } Buffer.BlockCopy(rawData, 0, array, 0, length); if (matReader.Transpose) { array = array.Transpose(Accord.Math.Vector.Interval(dimensions.Length - 1, 0)); } value = array; } } else { matType = contentsTag.DataType; if (matType == MatDataType.miMATRIX) { // Create a new node from the current position value = new MatNode(matReader, reader, offset, contentsTag, false); } else if (matType == MatDataType.miUTF8) { char[] utf8 = reader.ReadChars(contentsTag.NumberOfBytes); value = new String(utf8); align(reader, utf8.Length); } else { type = MatReader.Translate(matType); #pragma warning disable 618 // SizeOf would be Obsolete typeSize = Marshal.SizeOf(type); #pragma warning restore 618 // SizeOf would be Obsolete length = contentsTag.NumberOfBytes / typeSize; bytes = contentsTag.NumberOfBytes; if (!lazy) { value = read(reader); } } } } if (!compressed && lazy) { matrixOffset = reader.BaseStream.Position; } }
public void readInt8() { MemoryStream file = new MemoryStream(Resources.int8); MatReader reader = new MatReader(file); Assert.AreEqual( "MATLAB 5.0 MAT-file, Platform: PCWIN, Created on: Wed Jun 27 17:40:39 2007", reader.Description); Assert.AreEqual(256, reader.Version); Assert.IsFalse(reader.BigEndian); var node = reader["arr"]; var value = node.Value as sbyte[,]; sbyte[,] expected = { { -128, 127 }, }; Assert.IsTrue(expected.IsEqual(value)); }
public void readCell() { MemoryStream file = new MemoryStream(Resources.cell); MatReader reader = new MatReader(file); Assert.AreEqual( "MATLAB 5.0 MAT-file, Platform: PCWIN, Created on: Thu Feb 22 03:12:25 2007", reader.Description); Assert.AreEqual(256, reader.Version); Assert.IsFalse(reader.BigEndian); var cel = reader["cel"]; Assert.IsNotNull(cel["xBF"]); Assert.IsNotNull(cel["xY"]); Assert.IsNotNull(cel["nscan"]); Assert.IsNotNull(cel["Sess"]); Assert.IsNotNull(cel["xX"]); var xBF = cel["xBF"]; Assert.AreEqual("xBF", xBF.Name); Assert.AreEqual(9, xBF.Count); var T = xBF["T"]; var T0 = xBF["T0"]; var dt = xBF["dt"]; var UNITS = xBF["UNITS"]; var name = xBF["name"]; var order = xBF["order"]; var bf = xBF["bf"]; Assert.AreEqual(16, (T.Value as byte[,])[0, 0]); Assert.AreEqual(1, (T0.Value as byte[,])[0, 0]); Assert.AreEqual(0.1875, (dt.Value as double[,])[0, 0]); Assert.AreEqual("scans", UNITS.Value as string); Assert.AreEqual("hrf (with time derivative)", name.Value as string); Assert.AreEqual(2, (order.Value as byte[,])[0, 0]); Assert.IsTrue(expectedBfValues.IsEqual(bf.Value as double[,], 1e-15)); var nscan = cel["nscan"]; Assert.AreEqual(0, nscan.Count); Assert.AreEqual(96, (nscan.Value as byte[,])[0, 0]); var xY = cel["xY"]; Assert.AreEqual("xY", xY.Name); Assert.AreEqual(1, xY.Count); var RT = xY["RT"]; Assert.AreEqual(3, (RT.Value as byte[,])[0, 0]); var xX = cel["xX"]; Assert.AreEqual("xX", xX.Name); Assert.AreEqual(6, xX.Count); var X = xX["X"]; var iH = xX["iH"]; var iC = xX["iC"]; var iB = xX["iB"]; var iG = xX["iG"]; var xname = xX["name"]; Assert.IsTrue(expectedxXValues.IsEqual(X.Value as double[,], 1e-15)); Assert.AreEqual("Sn(1) test*bf(1)", xname["0"].Value); Assert.AreEqual("Sn(1) test*bf(2)", xname["1"].Value); Assert.AreEqual("Sn(1) constant", xname["2"].Value); var Sess = cel["Sess"]; Assert.AreEqual(5, Sess.Count); var U = Sess["U"]; Assert.AreEqual(7, U.Count); var Uname = U["name"]; var Uons = U["ons"]; var Udur = U["dur"]; var Udt = U["dt"]; var Uu = U["u"]; var Upst = U["pst"]; var P = U["P"]; Assert.AreEqual("test", (Uname["0"] as MatNode).Value as string); Assert.AreEqual(8.00000000000000e+00, (Uons.Value as byte[,])[0, 0]); Assert.AreEqual(2.40000000000000e+01, (Uons.Value as byte[,])[1, 0]); Assert.AreEqual(4.00000000000000e+01, (Uons.Value as byte[,])[2, 0]); Assert.AreEqual(5.60000000000000e+01, (Uons.Value as byte[,])[3, 0]); Assert.AreEqual(7.20000000000000e+01, (Uons.Value as byte[,])[4, 0]); Assert.AreEqual(8.80000000000000e+01, (Uons.Value as byte[,])[5, 0]); for (int i = 0; i < 6; i++) Assert.AreEqual(8, (Udur.Value as byte[,])[i, 0]); Assert.AreEqual(1.87500000000000e-01, (Udt.Value as double[,])[0, 0]); var sparse = Uu.Value as MatSparse; Assert.AreEqual(774, sparse.Rows.Length); Assert.AreEqual(2, sparse.Columns.Length); Assert.AreEqual(774, sparse.Values.Length); int j = 0; for (int i = 160; i <= 288; i++, j++) Assert.AreEqual(i - 1, sparse.Rows[j]); for (int i = 416; i <= 544; i++, j++) Assert.AreEqual(i - 1, sparse.Rows[j]); for (int i = 672; i <= 800; i++, j++) Assert.AreEqual(i - 1, sparse.Rows[j]); for (int i = 928; i <= 1056; i++, j++) Assert.AreEqual(i - 1, sparse.Rows[j]); for (int i = 1184; i <= 1312; i++, j++) Assert.AreEqual(i - 1, sparse.Rows[j]); for (int i = 1440; i <= 1568; i++, j++) Assert.AreEqual(i - 1, sparse.Rows[j]); Assert.AreEqual(774, j); for (int i = 0; i < sparse.Values.Length; i++) Assert.AreEqual(1.0, sparse.Values.GetValue(i)); Assert.AreEqual(2, sparse.Columns.Length); Assert.AreEqual(0, sparse.Columns[0]); Assert.AreEqual(774, sparse.Columns[1]); Assert.AreEqual(-21, (Upst.Value as short[,])[0, 0]); Assert.AreEqual(24, (Upst.Value as short[,])[0, 95]); var Pname = P["name"]; var PP = P["P"]; var Ph = P["h"]; var Pi = P["i"]; Assert.AreEqual("none", Pname.Value); var ppv = PP.Value as ushort[,]; Assert.AreEqual(6, ppv.Length); Assert.AreEqual(2.40000000000000e+01, ppv[0, 0]); Assert.AreEqual(7.20000000000000e+01, ppv[1, 0]); Assert.AreEqual(1.20000000000000e+02, ppv[2, 0]); Assert.AreEqual(1.68000000000000e+02, ppv[3, 0]); Assert.AreEqual(2.16000000000000e+02, ppv[4, 0]); Assert.AreEqual(2.64000000000000e+02, ppv[5, 0]); Assert.AreEqual(0, (Ph.Value as byte[,])[0, 0]); Assert.AreEqual(1, (Pi.Value as byte[,])[0, 0]); var C = Sess["C"]; Assert.AreEqual(2, C.Count); Assert.AreEqual(0, (C["C"].Value as byte[,]).Length); Assert.IsNull(C["name"].Value); var row = Sess["row"]; for (int i = 0; i < 96; i++) Assert.AreEqual(i + 1, (row.Value as byte[,])[0, i]); var col = Sess["col"]; Assert.AreEqual(1, (col.Value as byte[,])[0, 0]); Assert.AreEqual(2, (col.Value as byte[,])[0, 1]); var Fc = Sess["Fc"]; var Fci = Fc["i"]; var Fname = Fc["name"]; Assert.AreEqual(1, (Fci.Value as byte[,])[0, 0]); Assert.AreEqual(2, (Fci.Value as byte[,])[0, 1]); Assert.AreEqual("test", Fname.Value); }
public void readLogical() { MemoryStream file = new MemoryStream(Resources.logical); MatReader reader = new MatReader(file); Assert.AreEqual( "MATLAB 5.0 MAT-file, Platform: PCWIN, Created on: Mon Feb 25 20:07:08 2013", reader.Description); Assert.AreEqual(256, reader.Version); Assert.IsFalse(reader.BigEndian); var node = reader["bool"]; var value = node.Value as byte[,]; byte[,] expected = { { 1, 0 }, }; Assert.IsTrue(expected.IsEqual(value)); }
public void readStruct() { MemoryStream file = new MemoryStream(Resources.simplestruct); MatReader reader = new MatReader(file); Assert.AreEqual( "MATLAB 5.0 MAT-file, Platform: PCWIN, Created on: Thu Feb 22 01:39:50 2007", reader.Description); Assert.AreEqual(256, reader.Version); Assert.IsFalse(reader.BigEndian); var node = reader["structure"]; var value1 = node["a"]; var value2 = node["string"]; Assert.AreEqual("a", value1.Name); var a = value1.Value as byte[,]; byte[,] expected = { { 1, 2, 3 }, { 4, 5, 6 }, }; Assert.IsTrue(expected.IsEqual(a)); Assert.AreEqual("string", value2.Name); var s = value2.Value as string; Assert.AreEqual("ala ma kota", s); }
public void readDouble() { MemoryStream file = new MemoryStream(Resources.matnativedouble); MatReader reader = new MatReader(file); Assert.AreEqual( "MATLAB 5.0 MAT-file, Platform: PCWIN, Created on: Wed Feb 21 18:57:45 2007", reader.Description); Assert.AreEqual(256, reader.Version); Assert.IsFalse(reader.BigEndian); var node = reader["arr"]; var value = node.Value as byte[,]; byte[,] expected = { { 1, 4 }, { 2, 5 }, { 3, 6 } }; Assert.IsTrue(expected.IsEqual(value)); }
public void readDouble2() { MemoryStream file = new MemoryStream(Resources.matnativedouble2); MatReader reader = new MatReader(file); Assert.AreEqual( "MATLAB 5.0 MAT-file, Platform: PCWIN, Created on: Fri Mar 02 12:35:43 2007", reader.Description); Assert.AreEqual(256, reader.Version); Assert.IsFalse(reader.BigEndian); var node = reader["arr"]; var value = node.Value as double[,]; double[,] expected = { { 1.1, 4.4 }, { 2.2, 5.5 }, { 3.3, 6.6 } }; Assert.IsTrue(expected.IsEqual(value)); }
public void readUInt64() { MemoryStream file = new MemoryStream(Resources.uint64); MatReader reader = new MatReader(file); Assert.AreEqual( "MATLAB 5.0 MAT-file, Platform: PCWIN, Created on: Wed Jun 27 17:43:04 2007", reader.Description); Assert.AreEqual(256, reader.Version); Assert.IsFalse(reader.BigEndian); var node = reader["arr"]; var value = node.Value as ulong[,]; System.UInt64[,] expected = { { 0, unchecked ((System.UInt64)(-1)) }, }; Assert.IsTrue(expected.IsEqual(value)); }
public void readSingle() { MemoryStream file = new MemoryStream(Resources.single); MatReader reader = new MatReader(file); Assert.AreEqual( "MATLAB 5.0 MAT-file, Platform: PCWIN, Created on: Wed Jun 04 13:29:10 2008", reader.Description); Assert.AreEqual(256, reader.Version); Assert.IsFalse(reader.BigEndian); var node = reader["arr"]; var value = node.Value as float[,]; float[,] expected = { { 1.1f, 2.2f, 3.3f } }; Assert.IsTrue(expected.IsEqual(value)); }
public void readInt64_2() { MemoryStream file = new MemoryStream(Resources.a64); MatReader reader = new MatReader(file); Assert.AreEqual( "MATLAB 5.0 MAT-file, written by Octave 3.8.1, 2014-07-14 10:52:44 UTC", reader.Description); Assert.AreEqual(256, reader.Version); Assert.IsFalse(reader.BigEndian); var node = reader["A64"]; var value = node.Value as long[,]; long[,] expected = { { -83, -91, -92, -93, -1, 92, -78, 42, -92, 25 }, { -79, -60, 96, -23, -85, -44, 85, 48, 71, -17 }, { 42, 57, -13, -39, 54, -18, 6, 23, 98, 51 }, { -62, 63, 43, 41, -22, -38, 22, -93, 22, 34 }, { 79, 64, 32, -73, -53, -8, 75, 77, 23, 8 }, }; Assert.IsTrue(expected.IsEqual(value)); }
public void readInt32() { MemoryStream file = new MemoryStream(Resources.int32); MatReader reader = new MatReader(file); Assert.AreEqual( "MATLAB 5.0 MAT-file, Platform: PCWIN, Created on: Tue Dec 04 11:46:17 2012", reader.Description); Assert.AreEqual(256, reader.Version); Assert.IsFalse(reader.BigEndian); var node = reader["a"]; var value = node.Value as int[,]; int[,] expected = { { 1, 2, 3, 4 }, }; Assert.IsTrue(expected.IsEqual(value)); }
/// <summary> /// Reads the specified file or stream into a table. /// </summary> /// public DataTable Read(Stream stream) { var reader = new MatReader(new BinaryReader(stream), true); var matrix = reader[0].GetValue<double[,]>(); return matrix.ToTable(); }
public static DataTable Load(Stream stream, TableFormat format) { switch (format) { case TableFormat.SerializedXml: { XmlSerializer serializer = new XmlSerializer(typeof(DataTable)); return((DataTable)serializer.Deserialize(stream)); } case TableFormat.SerializedBin: { BinaryFormatter serializer = new BinaryFormatter(); return((DataTable)serializer.Deserialize(stream)); } case TableFormat.OctaveMatFile: { MatReader reader = new MatReader(stream); return(reader.Fields.First().Value.GetValue <double[, ]>().ToTable()); } case TableFormat.OpenDocument: { ExcelReader reader = new ExcelReader(stream, true); string ws = reader.GetWorksheetList().First(); return(reader.GetWorksheet(ws)); } case TableFormat.OlderExcel: { ExcelReader reader = new ExcelReader(stream, false); string ws = reader.GetWorksheetList().First(); return(reader.GetWorksheet(ws)); } case TableFormat.Csv: { CsvReader reader = new CsvReader(stream, true); return(reader.ToTable()); } case TableFormat.Tsv: { CsvReader reader = new CsvReader(stream, true, '\t'); return(reader.ToTable()); } case TableFormat.LibSVM: { SparseReader reader = new SparseReader(stream); return(reader.ToTable()); } case TableFormat.Idx: { IdxReader reader = new IdxReader(stream); return(reader.ReadToEndAsVectors().ToTable()); } case TableFormat.CSharp: throw new NotSupportedException(); } }
public static DataTable Load(Stream stream, TableFormat format) { switch (format) { case TableFormat.SerializedXml: { XmlSerializer serializer = new XmlSerializer(typeof(DataTable)); return (DataTable)serializer.Deserialize(stream); } case TableFormat.SerializedBin: { BinaryFormatter serializer = new BinaryFormatter(); return (DataTable)serializer.Deserialize(stream); } case TableFormat.OctaveMatFile: { MatReader reader = new MatReader(stream); return reader.Fields.First().Value.GetValue<double[,]>().ToTable(); } case TableFormat.OpenDocument: { ExcelReader reader = new ExcelReader(stream, true); string ws = reader.GetWorksheetList().First(); return reader.GetWorksheet(ws); } case TableFormat.OlderExcel: { ExcelReader reader = new ExcelReader(stream, false); string ws = reader.GetWorksheetList().First(); return reader.GetWorksheet(ws); } case TableFormat.Csv: { CsvReader reader = new CsvReader(stream, true); return reader.ToTable(); } case TableFormat.Tsv: { CsvReader reader = new CsvReader(stream, true, '\t'); return reader.ToTable(); } case TableFormat.LibSVM: { SparseReader reader = new SparseReader(stream); return reader.ToTable(); } case TableFormat.Idx: { IdxReader reader = new IdxReader(stream); return reader.ReadToEndAsVectors().ToTable(); } case TableFormat.CSharp: throw new NotSupportedException(); } }