Beispiel #1
0
        public static void Constructor_Byte_Byte_Byte_Byte_Byte_Byte_Byte_Byte()
        {
            byte8 x = new byte8(TestData_LHS[0].x0, TestData_LHS[0].x1, TestData_LHS[0].x2, TestData_LHS[0].x3, TestData_LHS[0].x4, TestData_LHS[0].x5, TestData_LHS[0].x6, TestData_LHS[0].x7);

            Assert.AreEqual(x.x0 == TestData_LHS[0].x0 &
                            x.x1 == TestData_LHS[0].x1 &
                            x.x2 == TestData_LHS[0].x2 &
                            x.x3 == TestData_LHS[0].x3 &
                            x.x4 == TestData_LHS[0].x4 &
                            x.x5 == TestData_LHS[0].x5 &
                            x.x6 == TestData_LHS[0].x6 &
                            x.x7 == TestData_LHS[0].x7, true);
        }
Beispiel #2
0
        public static void Constructor_Byte()
        {
            byte8 x = new byte8(TestData_LHS[0].x0);

            Assert.AreEqual(x.x0 == TestData_LHS[0].x0 &
                            x.x1 == TestData_LHS[0].x0 &
                            x.x2 == TestData_LHS[0].x0 &
                            x.x3 == TestData_LHS[0].x0 &
                            x.x4 == TestData_LHS[0].x0 &
                            x.x5 == TestData_LHS[0].x0 &
                            x.x6 == TestData_LHS[0].x0 &
                            x.x7 == TestData_LHS[0].x0, true);
        }
Beispiel #3
0
        public static void byte8()
        {
            for (int i = 0; i < Byte8.TestData_LHS.Length; i++)
            {
                for (int j = 1; j < 8; j++)
                {
                    byte8 ror = maxmath.vror(Byte8.TestData_LHS[i], j);

                    for (int k = 0; k < 8; k++)
                    {
                        Assert.AreEqual(ror[k], Byte8.TestData_LHS[i][(j + k) % 8]);
                    }
                }
            }
        }
Beispiel #4
0
        public static void byte8()
        {
            for (int i = 0; i < Byte8.TestData_LHS.Length; i++)
            {
                for (int j = 1; j < 8; j++)
                {
                    byte8 shl = maxmath.vshl(Byte8.TestData_LHS[i], j);

                    for (int k = 0; k < 8; k++)
                    {
                        Assert.IsTrue(shl[k] == ((k - j < 0) ? 0 : Byte8.TestData_LHS[i][k - j]));
                    }
                }
            }
        }
Beispiel #5
0
        public static void byte8()
        {
            for (int i = 0; i < Byte8.TestData_LHS.Length; i++)
            {
                for (int j = 1; j < 8; j++)
                {
                    byte8 shr = maxmath.vshr(Byte8.TestData_LHS[i], j);

                    for (int k = 0; k < 8; k++)
                    {
                        Assert.IsTrue(shr[k] == ((j + k >= 8) ? 0 : Byte8.TestData_LHS[i][j + k]));
                    }
                }
            }
        }
Beispiel #6
0
        public static void byte8()
        {
            Random8 rng = new Random8(135);

            for (int i = 0; i < 64; i++)
            {
                byte8 x = rng.NextByte8();

                Assert.AreEqual(new byte8((byte)_intsqrt(x.x0),
                                          (byte)_intsqrt(x.x1),
                                          (byte)_intsqrt(x.x2),
                                          (byte)_intsqrt(x.x3),
                                          (byte)_intsqrt(x.x4),
                                          (byte)_intsqrt(x.x5),
                                          (byte)_intsqrt(x.x6),
                                          (byte)_intsqrt(x.x7)),
                                maxmath.intsqrt(x));
            }
        }
Beispiel #7
0
        public static void XOR()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                byte8 x = TestData_LHS[i] ^ TestData_RHS[i];

                result &= x.x0 == (byte)(TestData_LHS[i].x0 ^ TestData_RHS[i].x0) &
                          x.x1 == (byte)(TestData_LHS[i].x1 ^ TestData_RHS[i].x1) &
                          x.x2 == (byte)(TestData_LHS[i].x2 ^ TestData_RHS[i].x2) &
                          x.x3 == (byte)(TestData_LHS[i].x3 ^ TestData_RHS[i].x3) &
                          x.x4 == (byte)(TestData_LHS[i].x4 ^ TestData_RHS[i].x4) &
                          x.x5 == (byte)(TestData_LHS[i].x5 ^ TestData_RHS[i].x5) &
                          x.x6 == (byte)(TestData_LHS[i].x6 ^ TestData_RHS[i].x6) &
                          x.x7 == (byte)(TestData_LHS[i].x7 ^ TestData_RHS[i].x7);
            }

            Assert.AreEqual(true, result);
        }
Beispiel #8
0
        public static void OR()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                byte8 x = TestData_LHS[i] | TestData_RHS[i];

                result &= x.x0 == (byte)(TestData_LHS[i].x0 | TestData_RHS[i].x0) &
                          x.x1 == (byte)(TestData_LHS[i].x1 | TestData_RHS[i].x1) &
                          x.x2 == (byte)(TestData_LHS[i].x2 | TestData_RHS[i].x2) &
                          x.x3 == (byte)(TestData_LHS[i].x3 | TestData_RHS[i].x3) &
                          x.x4 == (byte)(TestData_LHS[i].x4 | TestData_RHS[i].x4) &
                          x.x5 == (byte)(TestData_LHS[i].x5 | TestData_RHS[i].x5) &
                          x.x6 == (byte)(TestData_LHS[i].x6 | TestData_RHS[i].x6) &
                          x.x7 == (byte)(TestData_LHS[i].x7 | TestData_RHS[i].x7);
            }

            Assert.AreEqual(true, result);
        }
Beispiel #9
0
        public static void AND()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                byte8 x = TestData_LHS[i] & TestData_RHS[i];

                result &= x.x0 == (byte)(TestData_LHS[i].x0 & TestData_RHS[i].x0) &
                          x.x1 == (byte)(TestData_LHS[i].x1 & TestData_RHS[i].x1) &
                          x.x2 == (byte)(TestData_LHS[i].x2 & TestData_RHS[i].x2) &
                          x.x3 == (byte)(TestData_LHS[i].x3 & TestData_RHS[i].x3) &
                          x.x4 == (byte)(TestData_LHS[i].x4 & TestData_RHS[i].x4) &
                          x.x5 == (byte)(TestData_LHS[i].x5 & TestData_RHS[i].x5) &
                          x.x6 == (byte)(TestData_LHS[i].x6 & TestData_RHS[i].x6) &
                          x.x7 == (byte)(TestData_LHS[i].x7 & TestData_RHS[i].x7);
            }

            Assert.AreEqual(true, result);
        }
Beispiel #10
0
        public static void Remainder()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                byte8 x = TestData_LHS[i] % TestData_RHS[i];

                result &= x.x0 == (byte)(TestData_LHS[i].x0 % TestData_RHS[i].x0) &
                          x.x1 == (byte)(TestData_LHS[i].x1 % TestData_RHS[i].x1) &
                          x.x2 == (byte)(TestData_LHS[i].x2 % TestData_RHS[i].x2) &
                          x.x3 == (byte)(TestData_LHS[i].x3 % TestData_RHS[i].x3) &
                          x.x4 == (byte)(TestData_LHS[i].x4 % TestData_RHS[i].x4) &
                          x.x5 == (byte)(TestData_LHS[i].x5 % TestData_RHS[i].x5) &
                          x.x6 == (byte)(TestData_LHS[i].x6 % TestData_RHS[i].x6) &
                          x.x7 == (byte)(TestData_LHS[i].x7 % TestData_RHS[i].x7);
            }

            Assert.AreEqual(true, result);
        }
Beispiel #11
0
        public static void Multiply()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                byte8 x = TestData_LHS[i] * TestData_RHS[i];

                result &= x.x0 == (byte)(TestData_LHS[i].x0 * TestData_RHS[i].x0) &
                          x.x1 == (byte)(TestData_LHS[i].x1 * TestData_RHS[i].x1) &
                          x.x2 == (byte)(TestData_LHS[i].x2 * TestData_RHS[i].x2) &
                          x.x3 == (byte)(TestData_LHS[i].x3 * TestData_RHS[i].x3) &
                          x.x4 == (byte)(TestData_LHS[i].x4 * TestData_RHS[i].x4) &
                          x.x5 == (byte)(TestData_LHS[i].x5 * TestData_RHS[i].x5) &
                          x.x6 == (byte)(TestData_LHS[i].x6 * TestData_RHS[i].x6) &
                          x.x7 == (byte)(TestData_LHS[i].x7 * TestData_RHS[i].x7);
            }

            Assert.AreEqual(true, result);
        }
Beispiel #12
0
        public static void Subtract()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                byte8 x = TestData_LHS[i] - TestData_RHS[i];

                result &= x.x0 == (byte)(TestData_LHS[i].x0 - TestData_RHS[i].x0) &
                          x.x1 == (byte)(TestData_LHS[i].x1 - TestData_RHS[i].x1) &
                          x.x2 == (byte)(TestData_LHS[i].x2 - TestData_RHS[i].x2) &
                          x.x3 == (byte)(TestData_LHS[i].x3 - TestData_RHS[i].x3) &
                          x.x4 == (byte)(TestData_LHS[i].x4 - TestData_RHS[i].x4) &
                          x.x5 == (byte)(TestData_LHS[i].x5 - TestData_RHS[i].x5) &
                          x.x6 == (byte)(TestData_LHS[i].x6 - TestData_RHS[i].x6) &
                          x.x7 == (byte)(TestData_LHS[i].x7 - TestData_RHS[i].x7);
            }

            Assert.AreEqual(true, result);
        }
Beispiel #13
0
        public static void Add()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                byte8 x = TestData_LHS[i] + TestData_RHS[i];

                result &= x.x0 == (byte)(TestData_LHS[i].x0 + TestData_RHS[i].x0) &
                          x.x1 == (byte)(TestData_LHS[i].x1 + TestData_RHS[i].x1) &
                          x.x2 == (byte)(TestData_LHS[i].x2 + TestData_RHS[i].x2) &
                          x.x3 == (byte)(TestData_LHS[i].x3 + TestData_RHS[i].x3) &
                          x.x4 == (byte)(TestData_LHS[i].x4 + TestData_RHS[i].x4) &
                          x.x5 == (byte)(TestData_LHS[i].x5 + TestData_RHS[i].x5) &
                          x.x6 == (byte)(TestData_LHS[i].x6 + TestData_RHS[i].x6) &
                          x.x7 == (byte)(TestData_LHS[i].x7 + TestData_RHS[i].x7);
            }

            Assert.AreEqual(true, result);
        }
Beispiel #14
0
        public static void NOT()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                byte8 x = ~TestData_LHS[i];

                result &= x.x0 == (byte)(~TestData_LHS[i].x0) &
                          x.x1 == (byte)(~TestData_LHS[i].x1) &
                          x.x2 == (byte)(~TestData_LHS[i].x2) &
                          x.x3 == (byte)(~TestData_LHS[i].x3) &
                          x.x4 == (byte)(~TestData_LHS[i].x4) &
                          x.x5 == (byte)(~TestData_LHS[i].x5) &
                          x.x6 == (byte)(~TestData_LHS[i].x6) &
                          x.x7 == (byte)(~TestData_LHS[i].x7);
            }

            Assert.AreEqual(true, result);
        }
Beispiel #15
0
        public static void sbyte8()
        {
            Random8 rng = new Random8(135);

            for (int i = 0; i < 64; i++)
            {
                sbyte8 x = rng.NextSByte8();
                byte8  n = rng.NextByte8();

                Assert.AreEqual(new sbyte8((sbyte)_intpow(x.x0, n.x0),
                                           (sbyte)_intpow(x.x1, n.x1),
                                           (sbyte)_intpow(x.x2, n.x2),
                                           (sbyte)_intpow(x.x3, n.x3),
                                           (sbyte)_intpow(x.x4, n.x4),
                                           (sbyte)_intpow(x.x5, n.x5),
                                           (sbyte)_intpow(x.x6, n.x6),
                                           (sbyte)_intpow(x.x7, n.x7)),
                                maxmath.intpow(x, n));
            }
        }
Beispiel #16
0
        public static void Byte8()
        {
            bool result = true;

            for (int i = 0; i < 8; i++)
            {
                byte8 a = 0;

                for (int j = 0; j < 8; j++)
                {
                    a[j] = (byte)j;
                }

                result &= (maxmath.all_dif(a) == true);
                a[i]    = (byte)((i == 1) ? 2 : 1);
                result &= (maxmath.all_dif(a) == false);
            }

            Assert.AreEqual(true, result);
        }
Beispiel #17
0
        public static void byte8()
        {
            Random8 rng = new Random8(135);

            for (int i = 0; i < 64; i++)
            {
                byte8 x = rng.NextByte8();
                byte8 y = rng.NextByte8();

                Assert.AreEqual(new byte8((byte)_gcd(x.x0, y.x0),
                                          (byte)_gcd(x.x1, y.x1),
                                          (byte)_gcd(x.x2, y.x2),
                                          (byte)_gcd(x.x3, y.x3),
                                          (byte)_gcd(x.x4, y.x4),
                                          (byte)_gcd(x.x5, y.x5),
                                          (byte)_gcd(x.x6, y.x6),
                                          (byte)_gcd(x.x7, y.x7)),
                                maxmath.gcd(x, y));
            }
        }
Beispiel #18
0
        public static void Cast_ToByte()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                byte8 x = (byte8)TestData_LHS[i];

                result &= x.x0 == (byte)TestData_LHS[i].x0 &
                          x.x1 == (byte)TestData_LHS[i].x1 &
                          x.x2 == (byte)TestData_LHS[i].x2 &
                          x.x3 == (byte)TestData_LHS[i].x3 &
                          x.x4 == (byte)TestData_LHS[i].x4 &
                          x.x5 == (byte)TestData_LHS[i].x5 &
                          x.x6 == (byte)TestData_LHS[i].x6 &
                          x.x7 == (byte)TestData_LHS[i].x7;
            }

            Assert.AreEqual(true, result);
        }
Beispiel #19
0
        public static void Divide()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                byte8 x = TestData_LHS[i] / TestData_RHS[i];

                result &= x.x0 == (byte)(TestData_LHS[i].x0 / TestData_RHS[i].x0) &
                          x.x1 == (byte)(TestData_LHS[i].x1 / TestData_RHS[i].x1) &
                          x.x2 == (byte)(TestData_LHS[i].x2 / TestData_RHS[i].x2) &
                          x.x3 == (byte)(TestData_LHS[i].x3 / TestData_RHS[i].x3) &
                          x.x4 == (byte)(TestData_LHS[i].x4 / TestData_RHS[i].x4) &
                          x.x5 == (byte)(TestData_LHS[i].x5 / TestData_RHS[i].x5) &
                          x.x6 == (byte)(TestData_LHS[i].x6 / TestData_RHS[i].x6) &
                          x.x7 == (byte)(TestData_LHS[i].x7 / TestData_RHS[i].x7);
            }

            Assert.AreEqual(true, result);
        }
Beispiel #20
0
        public static void Cast_FromV128()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                byte8 x = TestData_LHS[i];
                v128  c = x;
                x = c;

                result &= x.x0 == TestData_LHS[i].x0 &
                          x.x1 == TestData_LHS[i].x1 &
                          x.x2 == TestData_LHS[i].x2 &
                          x.x3 == TestData_LHS[i].x3 &
                          x.x4 == TestData_LHS[i].x4 &
                          x.x5 == TestData_LHS[i].x5 &
                          x.x6 == TestData_LHS[i].x6 &
                          x.x7 == TestData_LHS[i].x7;
            }

            Assert.AreEqual(true, result);
        }
Beispiel #21
0
        public static void ShiftRight()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                for (int j = 0; j < 8; j++)
                {
                    byte8 x = TestData_LHS[i] >> j;

                    result &= x.x0 == (byte)(TestData_LHS[i].x0 >> j) &
                              x.x1 == (byte)(TestData_LHS[i].x1 >> j) &
                              x.x2 == (byte)(TestData_LHS[i].x2 >> j) &
                              x.x3 == (byte)(TestData_LHS[i].x3 >> j) &
                              x.x4 == (byte)(TestData_LHS[i].x4 >> j) &
                              x.x5 == (byte)(TestData_LHS[i].x5 >> j) &
                              x.x6 == (byte)(TestData_LHS[i].x6 >> j) &
                              x.x7 == (byte)(TestData_LHS[i].x7 >> j);
                }
            }

            Assert.AreEqual(true, result);
        }
Beispiel #22
0
        public static void ShiftLeft()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                for (int j = 0; j < 8; j++)
                {
                    byte8 x = TestData_LHS[i] << j;

                    result &= x.x0 == (byte)(TestData_LHS[i].x0 << j) &
                              x.x1 == (byte)(TestData_LHS[i].x1 << j) &
                              x.x2 == (byte)(TestData_LHS[i].x2 << j) &
                              x.x3 == (byte)(TestData_LHS[i].x3 << j) &
                              x.x4 == (byte)(TestData_LHS[i].x4 << j) &
                              x.x5 == (byte)(TestData_LHS[i].x5 << j) &
                              x.x6 == (byte)(TestData_LHS[i].x6 << j) &
                              x.x7 == (byte)(TestData_LHS[i].x7 << j);
                }
            }

            Assert.AreEqual(true, result);
        }
Beispiel #23
0
        TiffIFD parseDngPrivateData(TiffEntry t)
        {
            /*
            1. Six bytes containing the zero-terminated string "Adobe". (The DNG specification calls for the DNGPrivateData tag to start with an ASCII string identifying the creator/format).
            2. 4 bytes: an ASCII string ("MakN" for a Makernote),  indicating what sort of data is being stored here. Note that this is not zero-terminated.
            3. A four-byte count (number of data bytes following); this is the length of the original MakerNote data. (This is always in "most significant byte first" format).
            4. 2 bytes: the byte-order indicator from the original file (the usual 'MM'/4D4D or 'II'/4949).
            5. 4 bytes: the original file offset for the MakerNote tag data (stored according to the byte order given above).
            6. The contents of the MakerNote tag. This is a simple byte-for-byte copy, with no modification.
            */
            UInt32 size = t.count;
            byte[] data = t.getData();
            string id((char*) data);
            if (0 != id.compare("Adobe"))
                TiffParsingException.ThrowTPE("Not Adobe Private data");

            data += 6;
            if (!(data[0] == 'M' && data[1] == 'a' && data[2] == 'k' && data[3] == 'N'))
                ThrowTPE("Not Makernote");

            data += 4;
            UInt32 count;
            if (Endianness.big == Common.getHostEndianness())
                count = *(UInt32*)data;
            else
                count = (unsigned int)data[0] << 24 | (unsigned int)data[1] << 16 | (unsigned int)data[2] << 8 | (unsigned int)data[3];

            data += 4;
            if (count > size)
                ThrowTPE("Error reading TIFF structure (invalid size). File Corrupt");

            Endianness makernote_endian = unknown;
            if (data[0] == 0x49 && data[1] == 0x49)
                makernote_endian = little;
            else if (data[0] == 0x4D && data[1] == 0x4D)
                makernote_endian = big;
            else
                ThrowTPE("Cannot determine endianess of DNG makernote");

            data += 2;
            UInt32 org_offset;

            if (big == getHostEndianness())
                org_offset = *(UInt32*)data;
            else
                org_offset = (unsigned int)data[0] << 24 | (unsigned int)data[1] << 16 | (unsigned int)data[2] << 8 | (unsigned int)data[3];

            data += 4;
            /* We don't parse original makernotes that are placed after 300MB mark in the original file */
            if (org_offset + count > 300 * 1024 * 1024)
                ThrowTPE("Adobe Private data: original offset of makernote is past 300MB offset");

            /* Create fake tiff with original offsets */
            byte[] maker_data = new byte8[org_offset + count];
            memcpy(&maker_data[org_offset], data, count);
            FileMap* maker_map = new FileMap(maker_data, org_offset + count);

            TiffIFD* maker_ifd;
            try
            {
                maker_ifd = parseMakerNote(maker_map, org_offset, makernote_endian);
            }
            catch (TiffParserException &e) {
                delete[] maker_data;
                delete maker_map;
                throw e;
            }
            delete[] maker_data;
            delete maker_map;
            return maker_ifd;
            }
Beispiel #24
0
        public static void ShuffleSetter()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                byte8 v4_0 = TestData_LHS[i];
                v4_0.v4_0 = Byte4.TestData_LHS[i];
                result   &= v4_0.x0 == Byte4.TestData_LHS[i].x;
                result   &= v4_0.x1 == Byte4.TestData_LHS[i].y;
                result   &= v4_0.x2 == Byte4.TestData_LHS[i].z;
                result   &= v4_0.x3 == Byte4.TestData_LHS[i].w;
                result   &= v4_0.x4 == TestData_LHS[i].x4;
                result   &= v4_0.x5 == TestData_LHS[i].x5;
                result   &= v4_0.x6 == TestData_LHS[i].x6;
                result   &= v4_0.x7 == TestData_LHS[i].x7;

                byte8 v4_1 = TestData_LHS[i];
                v4_1.v4_1 = Byte4.TestData_LHS[i];
                result   &= v4_1.x0 == TestData_LHS[i].x0;
                result   &= v4_1.x1 == Byte4.TestData_LHS[i].x;
                result   &= v4_1.x2 == Byte4.TestData_LHS[i].y;
                result   &= v4_1.x3 == Byte4.TestData_LHS[i].z;
                result   &= v4_1.x4 == Byte4.TestData_LHS[i].w;
                result   &= v4_1.x5 == TestData_LHS[i].x5;
                result   &= v4_1.x6 == TestData_LHS[i].x6;
                result   &= v4_1.x7 == TestData_LHS[i].x7;

                byte8 v4_2 = TestData_LHS[i];
                v4_2.v4_2 = Byte4.TestData_LHS[i];
                result   &= v4_2.x0 == TestData_LHS[i].x0;
                result   &= v4_2.x1 == TestData_LHS[i].x1;
                result   &= v4_2.x2 == Byte4.TestData_LHS[i].x;
                result   &= v4_2.x3 == Byte4.TestData_LHS[i].y;
                result   &= v4_2.x4 == Byte4.TestData_LHS[i].z;
                result   &= v4_2.x5 == Byte4.TestData_LHS[i].w;
                result   &= v4_2.x6 == TestData_LHS[i].x6;
                result   &= v4_2.x7 == TestData_LHS[i].x7;

                byte8 v4_3 = TestData_LHS[i];
                v4_3.v4_3 = Byte4.TestData_LHS[i];
                result   &= v4_3.x0 == TestData_LHS[i].x0;
                result   &= v4_3.x1 == TestData_LHS[i].x1;
                result   &= v4_3.x2 == TestData_LHS[i].x2;
                result   &= v4_3.x3 == Byte4.TestData_LHS[i].x;
                result   &= v4_3.x4 == Byte4.TestData_LHS[i].y;
                result   &= v4_3.x5 == Byte4.TestData_LHS[i].z;
                result   &= v4_3.x6 == Byte4.TestData_LHS[i].w;
                result   &= v4_3.x7 == TestData_LHS[i].x7;

                byte8 v4_4 = TestData_LHS[i];
                v4_4.v4_4 = Byte4.TestData_LHS[i];
                result   &= v4_4.x0 == TestData_LHS[i].x0;
                result   &= v4_4.x1 == TestData_LHS[i].x1;
                result   &= v4_4.x2 == TestData_LHS[i].x2;
                result   &= v4_4.x3 == TestData_LHS[i].x3;
                result   &= v4_4.x4 == Byte4.TestData_LHS[i].x;
                result   &= v4_4.x5 == Byte4.TestData_LHS[i].y;
                result   &= v4_4.x6 == Byte4.TestData_LHS[i].z;
                result   &= v4_4.x7 == Byte4.TestData_LHS[i].w;


                byte8 v3_0 = TestData_LHS[i];
                v3_0.v3_0 = Byte3.TestData_LHS[i];
                result   &= v3_0.x0 == Byte3.TestData_LHS[i].x;
                result   &= v3_0.x1 == Byte3.TestData_LHS[i].y;
                result   &= v3_0.x2 == Byte3.TestData_LHS[i].z;
                result   &= v3_0.x3 == TestData_LHS[i].x3;
                result   &= v3_0.x4 == TestData_LHS[i].x4;
                result   &= v3_0.x5 == TestData_LHS[i].x5;
                result   &= v3_0.x6 == TestData_LHS[i].x6;
                result   &= v3_0.x7 == TestData_LHS[i].x7;

                byte8 v3_1 = TestData_LHS[i];
                v3_1.v3_1 = Byte3.TestData_LHS[i];
                result   &= v3_1.x0 == TestData_LHS[i].x0;
                result   &= v3_1.x1 == Byte3.TestData_LHS[i].x;
                result   &= v3_1.x2 == Byte3.TestData_LHS[i].y;
                result   &= v3_1.x3 == Byte3.TestData_LHS[i].z;
                result   &= v3_1.x4 == TestData_LHS[i].x4;
                result   &= v3_1.x5 == TestData_LHS[i].x5;
                result   &= v3_1.x6 == TestData_LHS[i].x6;
                result   &= v3_1.x7 == TestData_LHS[i].x7;

                byte8 v3_2 = TestData_LHS[i];
                v3_2.v3_2 = Byte3.TestData_LHS[i];
                result   &= v3_2.x0 == TestData_LHS[i].x0;
                result   &= v3_2.x1 == TestData_LHS[i].x1;
                result   &= v3_2.x2 == Byte3.TestData_LHS[i].x;
                result   &= v3_2.x3 == Byte3.TestData_LHS[i].y;
                result   &= v3_2.x4 == Byte3.TestData_LHS[i].z;
                result   &= v3_2.x5 == TestData_LHS[i].x5;
                result   &= v3_2.x6 == TestData_LHS[i].x6;
                result   &= v3_2.x7 == TestData_LHS[i].x7;

                byte8 v3_3 = TestData_LHS[i];
                v3_3.v3_3 = Byte3.TestData_LHS[i];
                result   &= v3_3.x0 == TestData_LHS[i].x0;
                result   &= v3_3.x1 == TestData_LHS[i].x1;
                result   &= v3_3.x2 == TestData_LHS[i].x2;
                result   &= v3_3.x3 == Byte3.TestData_LHS[i].x;
                result   &= v3_3.x4 == Byte3.TestData_LHS[i].y;
                result   &= v3_3.x5 == Byte3.TestData_LHS[i].z;
                result   &= v3_3.x6 == TestData_LHS[i].x6;
                result   &= v3_3.x7 == TestData_LHS[i].x7;

                byte8 v3_4 = TestData_LHS[i];
                v3_4.v3_4 = Byte3.TestData_LHS[i];
                result   &= v3_4.x0 == TestData_LHS[i].x0;
                result   &= v3_4.x1 == TestData_LHS[i].x1;
                result   &= v3_4.x2 == TestData_LHS[i].x2;
                result   &= v3_4.x3 == TestData_LHS[i].x3;
                result   &= v3_4.x4 == Byte3.TestData_LHS[i].x;
                result   &= v3_4.x5 == Byte3.TestData_LHS[i].y;
                result   &= v3_4.x6 == Byte3.TestData_LHS[i].z;
                result   &= v3_4.x7 == TestData_LHS[i].x7;

                byte8 v3_5 = TestData_LHS[i];
                v3_5.v3_5 = Byte3.TestData_LHS[i];
                result   &= v3_5.x0 == TestData_LHS[i].x0;
                result   &= v3_5.x1 == TestData_LHS[i].x1;
                result   &= v3_5.x2 == TestData_LHS[i].x2;
                result   &= v3_5.x3 == TestData_LHS[i].x3;
                result   &= v3_5.x4 == TestData_LHS[i].x4;
                result   &= v3_5.x5 == Byte3.TestData_LHS[i].x;
                result   &= v3_5.x6 == Byte3.TestData_LHS[i].y;
                result   &= v3_5.x7 == Byte3.TestData_LHS[i].z;


                byte8 v2_0 = TestData_LHS[i];
                v2_0.v2_0 = Byte2.TestData_LHS[i];
                result   &= v2_0.x0 == Byte2.TestData_LHS[i].x;
                result   &= v2_0.x1 == Byte2.TestData_LHS[i].y;
                result   &= v2_0.x2 == TestData_LHS[i].x2;
                result   &= v2_0.x3 == TestData_LHS[i].x3;
                result   &= v2_0.x4 == TestData_LHS[i].x4;
                result   &= v2_0.x5 == TestData_LHS[i].x5;
                result   &= v2_0.x6 == TestData_LHS[i].x6;
                result   &= v2_0.x7 == TestData_LHS[i].x7;

                byte8 v2_1 = TestData_LHS[i];
                v2_1.v2_1 = Byte2.TestData_LHS[i];
                result   &= v2_1.x0 == TestData_LHS[i].x0;
                result   &= v2_1.x1 == Byte2.TestData_LHS[i].x;
                result   &= v2_1.x2 == Byte2.TestData_LHS[i].y;
                result   &= v2_1.x3 == TestData_LHS[i].x3;
                result   &= v2_1.x4 == TestData_LHS[i].x4;
                result   &= v2_1.x5 == TestData_LHS[i].x5;
                result   &= v2_1.x6 == TestData_LHS[i].x6;
                result   &= v2_1.x7 == TestData_LHS[i].x7;

                byte8 v2_2 = TestData_LHS[i];
                v2_2.v2_2 = Byte2.TestData_LHS[i];
                result   &= v2_2.x0 == TestData_LHS[i].x0;
                result   &= v2_2.x1 == TestData_LHS[i].x1;
                result   &= v2_2.x2 == Byte2.TestData_LHS[i].x;
                result   &= v2_2.x3 == Byte2.TestData_LHS[i].y;
                result   &= v2_2.x4 == TestData_LHS[i].x4;
                result   &= v2_2.x5 == TestData_LHS[i].x5;
                result   &= v2_2.x6 == TestData_LHS[i].x6;
                result   &= v2_2.x7 == TestData_LHS[i].x7;

                byte8 v2_3 = TestData_LHS[i];
                v2_3.v2_3 = Byte2.TestData_LHS[i];
                result   &= v2_3.x0 == TestData_LHS[i].x0;
                result   &= v2_3.x1 == TestData_LHS[i].x1;
                result   &= v2_3.x2 == TestData_LHS[i].x2;
                result   &= v2_3.x3 == Byte2.TestData_LHS[i].x;
                result   &= v2_3.x4 == Byte2.TestData_LHS[i].y;
                result   &= v2_3.x5 == TestData_LHS[i].x5;
                result   &= v2_3.x6 == TestData_LHS[i].x6;
                result   &= v2_3.x7 == TestData_LHS[i].x7;

                byte8 v2_4 = TestData_LHS[i];
                v2_4.v2_4 = Byte2.TestData_LHS[i];
                result   &= v2_4.x0 == TestData_LHS[i].x0;
                result   &= v2_4.x1 == TestData_LHS[i].x1;
                result   &= v2_4.x2 == TestData_LHS[i].x2;
                result   &= v2_4.x3 == TestData_LHS[i].x3;
                result   &= v2_4.x4 == Byte2.TestData_LHS[i].x;
                result   &= v2_4.x5 == Byte2.TestData_LHS[i].y;
                result   &= v2_4.x6 == TestData_LHS[i].x6;
                result   &= v2_4.x7 == TestData_LHS[i].x7;

                byte8 v2_5 = TestData_LHS[i];
                v2_5.v2_5 = Byte2.TestData_LHS[i];
                result   &= v2_5.x0 == TestData_LHS[i].x0;
                result   &= v2_5.x1 == TestData_LHS[i].x1;
                result   &= v2_5.x2 == TestData_LHS[i].x2;
                result   &= v2_5.x3 == TestData_LHS[i].x3;
                result   &= v2_5.x4 == TestData_LHS[i].x4;
                result   &= v2_5.x5 == Byte2.TestData_LHS[i].x;
                result   &= v2_5.x6 == Byte2.TestData_LHS[i].y;
                result   &= v2_5.x7 == TestData_LHS[i].x7;

                byte8 v2_6 = TestData_LHS[i];
                v2_6.v2_6 = Byte2.TestData_LHS[i];
                result   &= v2_6.x0 == TestData_LHS[i].x0;
                result   &= v2_6.x1 == TestData_LHS[i].x1;
                result   &= v2_6.x2 == TestData_LHS[i].x2;
                result   &= v2_6.x3 == TestData_LHS[i].x3;
                result   &= v2_6.x4 == TestData_LHS[i].x4;
                result   &= v2_6.x5 == TestData_LHS[i].x5;
                result   &= v2_6.x6 == Byte2.TestData_LHS[i].x;
                result   &= v2_6.x7 == Byte2.TestData_LHS[i].y;
            }

            Assert.AreEqual(true, result);
        }