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