Accord.Tests.Math.MatReaderTest.readCell C# (CSharp) Method

readCell() private method

private readCell ( ) : void
return void
        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);
        }