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 matrix_test_bytes()
{
string localPath = Path.Combine(System.Environment.CurrentDirectory, "Assets", "mat");
#region doc_matrix_byte
// Let's say we would like to load different .mat files which can be found at:
// https://github.com/accord-net/framework/blob/development/Unit%20Tests/ISynergy.Framework.Mathematics.Tests/Resources/mat/
// Let's assume they all currently reside in a "localPath"
// folder. So let's start by trying to load a 8-bit matrix:
string pathInt8 = Path.Combine(localPath, "int8.mat");
// Create a .MAT reader for the file:
var reader = new MatReader(pathInt8);
// The variable in the file is called "arr"
sbyte[,] matrix = reader.Read <sbyte[, ]>("arr");
// The arr matrix should be equal to { -128, 127 }
// (in case he didn't know the name of the variable,
// we would have inspected the FieldNames property:
string[] names = reader.FieldNames; // should contain "arr"
#endregion
CollectionAssert.AreEqual(new sbyte[, ]
{
{ -128, 127 },
}, matrix);
CollectionAssert.AreEqual(new[] { "arr" }, names);
}
/// <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 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 DataReader()
{
using (MatReader reader = new MatReader(File.OpenRead(_matlabFile)))
{
_trainingArray = reader["data"]["trainData"].Value as int[, ];
_validationArray = reader["data"]["validData"].Value as int[, ];
_testArray = reader["data"]["testData"].Value as int[, ];
}
}
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);
}
public FigureDataStructList(string _path)
{
DataStructList = new List <FigureDataStruct>();
MatReader inputMatReader = new MatReader(_path);
MatNode inputMatNode = inputMatReader.Fields[inputMatReader.FieldNames[0]];
foreach (var field in inputMatNode.Fields)
{
MatNode _struct = inputMatNode.Fields[field.Key];
DataStructList.Add(new FigureDataStruct(_struct)); // read all variables in this node and add to list
}
}
private void loadFromMATFileToolStripMenuItem_Click(object sender, EventArgs e)
{
Stream myStream = null;
OpenFileDialog openFileDialog1 = new OpenFileDialog();
openFileDialog1.Filter = "MAT files (*.mat)|*.mat|All files (*.*)|*.*";
openFileDialog1.FilterIndex = 1;
openFileDialog1.RestoreDirectory = true;
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
try
{
if ((myStream = openFileDialog1.OpenFile()) != null)
{
using (myStream)
{
MatReader reader = new MatReader(myStream);
var aType = reader["img_bin"].GetType();
byte[,] bins = reader["img_bin"].GetValue <byte[, ]>();
//double[,] mapMatrix = Matrix.Create<double>(bins.Rows(), bins.Columns(), 0);
Enviroment env = new Enviroment(bins.Rows(), bins.Columns());
for (int i = 0; i < bins.Rows(); i++)
{
for (int j = 0; j < bins.Columns(); j++)
{
if (bins[i, j] == 0)
{
env.Map.MapMatrix[i, j] = 1;
}
else
{
env.Map.MapMatrix[i, j] = 0;
}
}
}
this.enviroment = env;
propertyGridEnviroment.SelectedObject = enviroment;
updateUI();
}
}
}
catch (Exception ex)
{
MessageBox.Show("Error: Could not read file from disk. Original error: " + ex.Message);
}
}
}
public void UpdateMatlabFigure()
{
DestroyAllChildren();
SliderCanvas.SetActive(false);
MatReader matFileReader = new MatReader(Application.streamingAssetsPath + Path.DirectorySeparatorChar + fileSelectionDropDown.Text);
MatNode matFile = matFileReader.Fields[matFileReader.FieldNames[0]];
foreach (var field in matFile.Fields)
{
MatNode _struct = matFile.Fields[field.Key];
int[,] _type = _struct.Fields["type"].GetValue <int[, ]>();
switch (_type[0, 0])
{
case 1: // type 1 = FV triangulated mesh
FVmeshVertexColor(_struct);
break;
case 2:
// type 2 = 3D scatter
scatter3(_struct);
break;
case 3:
// multiple vertex color mesh
FVmeshMultiVertColor(_struct);
break;
case 4:
// inset graph;
drawGraph(_struct);
break;
// should add options for multigraph
case 5:
// single color mesh
FVmeshSingleColor(_struct);
break;
case 6:
// set camera distance
CamDistSetter(_struct);
break;
}
}
}
static void Main(string[] args)
{
var reader = new MatReader(@"D:\Учеба\4 курс\Нейроматематика\LAB3\данные к задачам\mnist\data.mat");
var names = reader.Fields.Keys;
foreach (var name in names)
{
Console.WriteLine(name);
}
var t = reader.Read <byte[, ]>("y");
t[0, 0] = 0;
for (int i = 0; i < 5000; i += 500)
{
Console.WriteLine(t[i, 0]);
}
Console.ReadKey();
}
public void UpdateMatlabFigure()
{
string _path = Application.streamingAssetsPath + Path.DirectorySeparatorChar + fileSelectionDropDown.Text;
MatReader matFileReader = new MatReader(_path);
MatNode matFile = matFileReader.Fields[matFileReader.FieldNames[0]];
foreach (var field in matFile.Fields)
{
MatNode _struct = matFile.Fields[field.Key];
// this is a bit of a silly workaround to get a string read in to be the key "_type", but using strings as keys for _matTypes is going to maake this whole script much more readable.
// Accord throws an error if _struct is a Matlab struct with both numeric arrays and strings
// so type is a struct with one field. The field contains no data but the FieldName is the sting I am trying to pass.
string _type = new List <string>(_struct.Fields["type"].Fields.Keys)[0];
MatFileReader hmm = new MatFileReader(_struct);
_matTypes[_type](_struct);
}
}
public void matrix_test_int32()
{
string localPath = Path.Combine(System.Environment.CurrentDirectory, "Assets", "mat");
#region doc_matrix_int32
// Let's say we would like to load different .mat files which can be found at:
// https://github.com/accord-net/framework/blob/development/Unit%20Tests/ISynergy.Framework.Mathematics.Tests/Resources/mat/
// Let's assume they all currently reside in a "localPath"
// folder. So let's start by trying to load a 32-bit matrix:
string pathInt32 = Path.Combine(localPath, "int32.mat");
// Create a .MAT reader for the file:
var reader = new MatReader(pathInt32);
// Let's check what is the name of the variable we need to load:
string[] names = reader.FieldNames; // should be { "a" }
// Ok, so we have to load the matrix called "a".
// However, what if we didn't know the matrix type in advance?
// In this case, we could use the non-generic version of Read:
object unknown = reader.Read("a");
// And we could check it's type through C#:
Type t = unknown.GetType(); // should be typeof(int[,])
// Now we could either cast it to the correct type or
// use the generic version of Read<> to read it again:
int[,] matrix = reader.Read <int[, ]>("a");
// The a matrix should be equal to { 1, 2, 3, 4 }
#endregion
Assert.AreEqual(typeof(int[, ]), t);
CollectionAssert.AreEqual(new int[, ]
{
{ 1, 2, 3, 4 },
}, matrix);
CollectionAssert.AreEqual(new[] { "a" }, names);
}
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 readInt64()
{
var file = GetMat("int64.mat");
MatReader reader = new MatReader(file);
Assert.AreEqual(
"MATLAB 5.0 MAT-file, Platform: PCWIN, Created on: Wed Jun 27 17:41:23 2007",
reader.Description);
Assert.AreEqual(256, reader.Version);
Assert.IsFalse(reader.BigEndian);
var node = reader["arr"];
var value = node.Value as long[, ];
System.Int64[,] expected =
{
{ 0, -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 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));
}
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 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));
}
private void BrowseSource()
{
OpenFileDialog openDialog = new OpenFileDialog();
openDialog.Title = "Select a Tileset";
openDialog.InitialDirectory = this.session.LastTilesetDirectory.Value;
openDialog.Filter = ImageExtension.GetOpenFileImageExtensions();
if (openDialog.ShowDialog() == true)
{
string tileFilePath = openDialog.FileName;
if (File.Exists(tileFilePath))
{
this.IsSourceLoaded.Value = true;
this.SourcePath.Value = tileFilePath;
this.session.LastTilesetDirectory.Value = Directory.GetParent(tileFilePath).FullName;
MatReader reader = new MatReader();
ResourceLoader loader = ResourceLoader.Instance;
Mat toLoad = loader.Load <Mat>(tileFilePath, reader);
LoadItemImage(toLoad);
}
}
}
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 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 read_r_matrix(string fileName)
{
try
{
//var mzxml = new LIMPFileReader.LimpXml(fileName, (float)0, true);
Cursor = Cursors.WaitCursor;
var reader = new MatReader(fileName);
var structure = reader["data"];
var cType = structure["spectra"].ValueType;
var fields = structure.Fields;
//var scans = (reader["result"]["scans"].GetValue<int[,]>()).ToDouble();
var scans = reader["data"]["spectra"].GetValue <double[, ]>().Transpose();
R_matrix.mz_array = reader["data"]["mz"].GetValue <double[, ]>().ToJagged()[0];
mzmin = R_matrix.mz_array[0];
mzmax = R_matrix.mz_array[R_matrix.mz_array.Length - 1];
n_precision = (int)(Math.Round(1.0 / (R_matrix.mz_array[1] - R_matrix.mz_array[0])));
rf = new double[scans.Columns(), scans.Columns()];
R_matrix.matrix = rf;
rf2 = new double[rf.Columns(), rf.Rows()];
R_matrix.scans = scans.Transpose();
int mzlength = scans.GetLength(0);
var scannames = reader["data"]["filenames"];
var scan_of_file = (reader["data"]["scan_of_file"].GetValue <double[, ]>()).ToInt32();
scannames_count = scan_of_file.Length;
sampleNameList.Clear();
sampleNameList.Add(scannames[scan_of_file[0, 0]].Value.ToString());
sampleCoordList.Clear();
sampleCoordList.Add(0.0);
scanNamesList.Clear();
int intercept = 0;
for (int i = 0; i < scannames_count; i++)
{
scanNamesList.Add(scannames[scan_of_file[0, i]].Value.ToString());
if (i > 0)
{
if (scannames[scan_of_file[0, i]].Value.ToString() != scannames[scan_of_file[0, i - 1]].Value.ToString())
{
sampleNameList.Add(scannames[scan_of_file[0, i]].Value.ToString());
sampleCoordList.Add(i);
intercept = i;
}
}
sampleScanList.Add(Convert.ToString(i + 1 - intercept));
}
R_matrix.scan_names = sampleScanList;
R_matrix.file_names = sampleNameList;
R_matrix.refresh();
update_figure(threshold);
Cursor = Cursors.Arrow;
}
catch (Exception e)
{
var msg = e.Message;
Cursor = Cursors.Arrow;
MessageBox.Show(msg, "Warning", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1, MessageBoxOptions.DefaultDesktopOnly);
return;
}
}
void cgcoords_setup()
{
// Create a new MAT file reader
string path_src_cage = Path.Combine("C:/Users/vrproject/Downloads/iccm_orig/iccm_v2", "src_cage.mat");
//var reader = new MatReader(path_src_cage);
var reader = new MatReader(new BinaryReader(new FileStream(path_src_cage, FileMode.Open)), false, false);
//foreach (var field in reader.Fields)
// Debug.Log(field.Key);
src_cage = reader.Read <double[, ]>("Y");
//Debug.Log(src_cage[0, 0]+" "+src_cage[1, 0]);
//Debug.Log(src_cage.GetLength(0) + " " + src_cage.GetLength(1));
int cage_length = src_cage.GetLength(1);
cmplx_cage = new Complex[cage_length];
cagem1 = new Complex[cage_length];
A = new Complex[cage_length];
Ap1 = new Complex[cage_length];
B = new Complex[cage_length];
Bp1 = new Complex[cage_length];
Bm1 = new Complex[cage_length];
logBp1B = new Complex[cage_length];
wrongside = new bool[cage_length];
badB = new bool[cage_length];
badBp1 = new bool[cage_length];
logBBm1 = new Complex[cage_length];
C = new Complex[cage_length];
for (int i = 0; i < cage_length; i++)
{
cmplx_cage[i] = new Complex(src_cage[0, i], src_cage[1, i]);
}
//Debug.Log(cmplx_cage[914] + " " + cmplx_cage[234]);
//Debug.Log(cmplx_cage[775]);
for (int i = 0; i < cage_length - 1; i++)
{
cagem1[i + 1] = cmplx_cage[i];
}
cagem1[0] = cmplx_cage[cage_length - 1];
//Debug.Log(cagem1[775]);
for (int i = 0; i < cage_length; i++)
{
A[i] = cmplx_cage[i] - cagem1[i];
}
//Debug.Log(A[775]);
for (int i = 1; i < cage_length; i++)
{
Ap1[i - 1] = A[i];
}
Ap1[cage_length - 1] = A[0];
//Debug.Log(Ap1[775]);
path_src_cage = Path.Combine("C:/Users/vrproject/Downloads/iccm_orig/iccm_v2", "f_i.mat");
//var reader = new MatReader(path_src_cage);
reader = new MatReader(new BinaryReader(new FileStream(path_src_cage, FileMode.Open)), false, false);
//foreach (var field in reader.Fields)
// Debug.Log(field.Key);
double_f_i = reader.Read <double[, ]>("double_f_i");
//Debug.Log(double_f_i[0, 0] + " " + double_f_i[1, 0]);
//Debug.Log(double_f_i.GetLength(0)+" "+double_f_i.GetLength(1));
f_iLength = double_f_i.GetLength(1);
f_i = new Complex[f_iLength];
for (int i = 0; i < f_iLength && 2 * cage_length == f_iLength; i++)
{
f_i[i] = new Complex(double_f_i[0, i], double_f_i[1, i]);
}
}
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 structure_test()
{
string localPath = Path.Combine(System.Environment.CurrentDirectory, "Assets", "mat");
#region doc_structure
// Let's say we would like to load a .mat file
// called "simplestruct.mat". It can be found at
// https://github.com/accord-net/framework/blob/development/Unit%20Tests/ISynergy.Framework.Mathematics.Tests/Resources/mat/simplestruct.mat
// Let's assume it currently resides in a "localPath" folder
string fileName = Path.Combine(localPath, "simplestruct.mat");
// Create a .MAT reader for the file:
var reader = new MatReader(fileName);
// We can 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>();
#endregion
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);
}
