Exemple #1
0
        public static void ror_ushort8()
        {
            bool     result = true;
            Random32 rng    = new Random32(RNG_SEED);

            for (int i = 0; i < UShort8.NUM_TESTS; i++)
            {
                for (int j = 0; j < NUM_ROTATION_TESTS; j++)
                {
                    int     n    = rng.NextInt();
                    ushort8 test = maxmath.ror(UShort8.TestData_LHS[i], n);

                    result &= test.x0 == (ushort)math.ror(UShort8.TestData_LHS[i].x0 | (UShort8.TestData_LHS[i].x0 << 16), n);
                    result &= test.x1 == (ushort)math.ror(UShort8.TestData_LHS[i].x1 | (UShort8.TestData_LHS[i].x1 << 16), n);
                    result &= test.x2 == (ushort)math.ror(UShort8.TestData_LHS[i].x2 | (UShort8.TestData_LHS[i].x2 << 16), n);
                    result &= test.x3 == (ushort)math.ror(UShort8.TestData_LHS[i].x3 | (UShort8.TestData_LHS[i].x3 << 16), n);
                    result &= test.x4 == (ushort)math.ror(UShort8.TestData_LHS[i].x4 | (UShort8.TestData_LHS[i].x4 << 16), n);
                    result &= test.x5 == (ushort)math.ror(UShort8.TestData_LHS[i].x5 | (UShort8.TestData_LHS[i].x5 << 16), n);
                    result &= test.x6 == (ushort)math.ror(UShort8.TestData_LHS[i].x6 | (UShort8.TestData_LHS[i].x6 << 16), n);
                    result &= test.x7 == (ushort)math.ror(UShort8.TestData_LHS[i].x7 | (UShort8.TestData_LHS[i].x7 << 16), n);
                }
            }

            Assert.AreEqual(true, result);
        }
Exemple #2
0
        public static void Constructor_UShort()
        {
            ushort8 x = new ushort8(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);
        }
Exemple #3
0
        public static void Constructor_UShort_UShort_UShort_UShort_UShort_UShort_UShort_UShort()
        {
            ushort8 x = new ushort8(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);
        }
Exemple #4
0
        public static void ushort8()
        {
            for (int i = 0; i < UShort8.TestData_LHS.Length; i++)
            {
                for (int j = 1; j < 8; j++)
                {
                    ushort8 rol = maxmath.vrol(UShort8.TestData_LHS[i], j);

                    for (int k = 0; k < 8; k++)
                    {
                        Assert.AreEqual(rol[k], UShort8.TestData_LHS[i][((8 - j) + k) % 8]);
                    }
                }
            }
        }
Exemple #5
0
        public static void ushort8()
        {
            for (int i = 0; i < UShort8.TestData_LHS.Length; i++)
            {
                for (int j = 1; j < 8; j++)
                {
                    ushort8 shr = maxmath.vshr(UShort8.TestData_LHS[i], j);

                    for (int k = 0; k < 8; k++)
                    {
                        Assert.IsTrue(shr[k] == ((j + k >= 8) ? 0 : UShort8.TestData_LHS[i][j + k]));
                    }
                }
            }
        }
Exemple #6
0
        public static void ushort8()
        {
            for (int i = 0; i < UShort8.TestData_LHS.Length; i++)
            {
                for (int j = 1; j < 8; j++)
                {
                    ushort8 shl = maxmath.vshl(UShort8.TestData_LHS[i], j);

                    for (int k = 0; k < 8; k++)
                    {
                        Assert.IsTrue(shl[k] == ((k - j < 0) ? 0 : UShort8.TestData_LHS[i][k - j]));
                    }
                }
            }
        }
Exemple #7
0
        public static void ushort8()
        {
            Random16 rng = new Random16(135);

            for (int i = 0; i < 64; i++)
            {
                ushort8 x = rng.NextUShort8();

                Assert.AreEqual(new ushort8((ushort)_intsqrt(x.x0),
                                            (ushort)_intsqrt(x.x1),
                                            (ushort)_intsqrt(x.x2),
                                            (ushort)_intsqrt(x.x3),
                                            (ushort)_intsqrt(x.x4),
                                            (ushort)_intsqrt(x.x5),
                                            (ushort)_intsqrt(x.x6),
                                            (ushort)_intsqrt(x.x7)),
                                maxmath.intsqrt(x));
            }
        }
Exemple #8
0
        public static void Subtract()
        {
            bool result = true;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            Assert.AreEqual(true, result);
        }
Exemple #16
0
        public static void short8()
        {
            Random16 rng = new Random16(135);

            for (int i = 0; i < 64; i++)
            {
                short8  x = rng.NextShort8();
                ushort8 n = rng.NextUShort8();

                Assert.AreEqual(new short8((short)_intpow(x.x0, n.x0),
                                           (short)_intpow(x.x1, n.x1),
                                           (short)_intpow(x.x2, n.x2),
                                           (short)_intpow(x.x3, n.x3),
                                           (short)_intpow(x.x4, n.x4),
                                           (short)_intpow(x.x5, n.x5),
                                           (short)_intpow(x.x6, n.x6),
                                           (short)_intpow(x.x7, n.x7)),
                                maxmath.intpow(x, n));
            }
        }
Exemple #17
0
        public static void Cast_ToUShort()
        {
            bool result = true;

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

                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);
        }
Exemple #18
0
        public static void ushort8()
        {
            Random16 rng = new Random16(135);

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

                Assert.AreEqual(new ushort8((ushort)_gcd(x.x0, y.x0),
                                            (ushort)_gcd(x.x1, y.x1),
                                            (ushort)_gcd(x.x2, y.x2),
                                            (ushort)_gcd(x.x3, y.x3),
                                            (ushort)_gcd(x.x4, y.x4),
                                            (ushort)_gcd(x.x5, y.x5),
                                            (ushort)_gcd(x.x6, y.x6),
                                            (ushort)_gcd(x.x7, y.x7)),
                                maxmath.gcd(x, y));
            }
        }
Exemple #19
0
        public static void ShiftRight()
        {
            bool result = true;

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

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

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

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

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

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

            for (int i = 0; i < NUM_TESTS; i++)
            {
                ushort8 v4_0 = TestData_LHS[i];
                v4_0.v4_0 = UShort4.TestData_LHS[i];
                result   &= v4_0.x0 == UShort4.TestData_LHS[i].x;
                result   &= v4_0.x1 == UShort4.TestData_LHS[i].y;
                result   &= v4_0.x2 == UShort4.TestData_LHS[i].z;
                result   &= v4_0.x3 == UShort4.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;

                ushort8 v4_1 = TestData_LHS[i];
                v4_1.v4_1 = UShort4.TestData_LHS[i];
                result   &= v4_1.x0 == TestData_LHS[i].x0;
                result   &= v4_1.x1 == UShort4.TestData_LHS[i].x;
                result   &= v4_1.x2 == UShort4.TestData_LHS[i].y;
                result   &= v4_1.x3 == UShort4.TestData_LHS[i].z;
                result   &= v4_1.x4 == UShort4.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;

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

                ushort8 v4_3 = TestData_LHS[i];
                v4_3.v4_3 = UShort4.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 == UShort4.TestData_LHS[i].x;
                result   &= v4_3.x4 == UShort4.TestData_LHS[i].y;
                result   &= v4_3.x5 == UShort4.TestData_LHS[i].z;
                result   &= v4_3.x6 == UShort4.TestData_LHS[i].w;
                result   &= v4_3.x7 == TestData_LHS[i].x7;

                ushort8 v4_4 = TestData_LHS[i];
                v4_4.v4_4 = UShort4.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 == UShort4.TestData_LHS[i].x;
                result   &= v4_4.x5 == UShort4.TestData_LHS[i].y;
                result   &= v4_4.x6 == UShort4.TestData_LHS[i].z;
                result   &= v4_4.x7 == UShort4.TestData_LHS[i].w;


                ushort8 v3_0 = TestData_LHS[i];
                v3_0.v3_0 = UShort3.TestData_LHS[i];
                result   &= v3_0.x0 == UShort3.TestData_LHS[i].x;
                result   &= v3_0.x1 == UShort3.TestData_LHS[i].y;
                result   &= v3_0.x2 == UShort3.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;

                ushort8 v3_1 = TestData_LHS[i];
                v3_1.v3_1 = UShort3.TestData_LHS[i];
                result   &= v3_1.x0 == TestData_LHS[i].x0;
                result   &= v3_1.x1 == UShort3.TestData_LHS[i].x;
                result   &= v3_1.x2 == UShort3.TestData_LHS[i].y;
                result   &= v3_1.x3 == UShort3.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;

                ushort8 v3_2 = TestData_LHS[i];
                v3_2.v3_2 = UShort3.TestData_LHS[i];
                result   &= v3_2.x0 == TestData_LHS[i].x0;
                result   &= v3_2.x1 == TestData_LHS[i].x1;
                result   &= v3_2.x2 == UShort3.TestData_LHS[i].x;
                result   &= v3_2.x3 == UShort3.TestData_LHS[i].y;
                result   &= v3_2.x4 == UShort3.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;

                ushort8 v3_3 = TestData_LHS[i];
                v3_3.v3_3 = UShort3.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 == UShort3.TestData_LHS[i].x;
                result   &= v3_3.x4 == UShort3.TestData_LHS[i].y;
                result   &= v3_3.x5 == UShort3.TestData_LHS[i].z;
                result   &= v3_3.x6 == TestData_LHS[i].x6;
                result   &= v3_3.x7 == TestData_LHS[i].x7;

                ushort8 v3_4 = TestData_LHS[i];
                v3_4.v3_4 = UShort3.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 == UShort3.TestData_LHS[i].x;
                result   &= v3_4.x5 == UShort3.TestData_LHS[i].y;
                result   &= v3_4.x6 == UShort3.TestData_LHS[i].z;
                result   &= v3_4.x7 == TestData_LHS[i].x7;

                ushort8 v3_5 = TestData_LHS[i];
                v3_5.v3_5 = UShort3.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 == UShort3.TestData_LHS[i].x;
                result   &= v3_5.x6 == UShort3.TestData_LHS[i].y;
                result   &= v3_5.x7 == UShort3.TestData_LHS[i].z;


                ushort8 v2_0 = TestData_LHS[i];
                v2_0.v2_0 = UShort2.TestData_LHS[i];
                result   &= v2_0.x0 == UShort2.TestData_LHS[i].x;
                result   &= v2_0.x1 == UShort2.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;

                ushort8 v2_1 = TestData_LHS[i];
                v2_1.v2_1 = UShort2.TestData_LHS[i];
                result   &= v2_1.x0 == TestData_LHS[i].x0;
                result   &= v2_1.x1 == UShort2.TestData_LHS[i].x;
                result   &= v2_1.x2 == UShort2.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;

                ushort8 v2_2 = TestData_LHS[i];
                v2_2.v2_2 = UShort2.TestData_LHS[i];
                result   &= v2_2.x0 == TestData_LHS[i].x0;
                result   &= v2_2.x1 == TestData_LHS[i].x1;
                result   &= v2_2.x2 == UShort2.TestData_LHS[i].x;
                result   &= v2_2.x3 == UShort2.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;

                ushort8 v2_3 = TestData_LHS[i];
                v2_3.v2_3 = UShort2.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 == UShort2.TestData_LHS[i].x;
                result   &= v2_3.x4 == UShort2.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;

                ushort8 v2_4 = TestData_LHS[i];
                v2_4.v2_4 = UShort2.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 == UShort2.TestData_LHS[i].x;
                result   &= v2_4.x5 == UShort2.TestData_LHS[i].y;
                result   &= v2_4.x6 == TestData_LHS[i].x6;
                result   &= v2_4.x7 == TestData_LHS[i].x7;

                ushort8 v2_5 = TestData_LHS[i];
                v2_5.v2_5 = UShort2.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 == UShort2.TestData_LHS[i].x;
                result   &= v2_5.x6 == UShort2.TestData_LHS[i].y;
                result   &= v2_5.x7 == TestData_LHS[i].x7;

                ushort8 v2_6 = TestData_LHS[i];
                v2_6.v2_6 = UShort2.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 == UShort2.TestData_LHS[i].x;
                result   &= v2_6.x7 == UShort2.TestData_LHS[i].y;
            }

            Assert.AreEqual(true, result);
        }