Ejemplo n.º 1
0
        public static void Constructor_ULong()
        {
            ulong2 x = new ulong2(TestData_LHS[0].x);

            Assert.AreEqual(x.x == TestData_LHS[0].x &
                            x.y == TestData_LHS[0].x, true);
        }
Ejemplo n.º 2
0
        private static unsafe void Hash128Len17To128(byte *input, long length, byte *secret, ulong seed,
                                                     out uint4 result)
        {
            unchecked
            {
                var acc = new ulong2((ulong)length * PRIME64_1, 0);
                if (length > 32)
                {
                    if (length > 64)
                    {
                        if (length > 96)
                        {
                            acc = Mix32(acc, input + 48, input + length - 64, secret + 96, seed);
                        }

                        acc = Mix32(acc, input + 32, input + length - 48, secret + 64, seed);
                    }

                    acc = Mix32(acc, input + 16, input + length - 32, secret + 32, seed);
                }

                acc = Mix32(acc, input, input + length - 16, secret, seed);

                var low64  = acc.x + acc.y;
                var high64 = acc.x * PRIME64_1 + acc.y * PRIME64_4 + ((ulong)length - seed) * PRIME64_2;

                result = ToUint4(Avalanche(low64), 0ul - Avalanche(high64));
            }
        }
Ejemplo n.º 3
0
        private static unsafe void Hash128Len129To240(byte *input, long length, byte *secret, ulong seed,
                                                      out uint4 result)
        {
            unchecked
            {
                var acc      = new ulong2((ulong)length * PRIME64_1, 0);
                var nbRounds = length / 32;
                int i;

                for (i = 0; i < 4; i++)
                {
                    acc = Mix32(acc, input + 32 * i, input + 32 * i + 16, secret + 32 * i, seed);
                }

                acc.x = Avalanche(acc.x);
                acc.y = Avalanche(acc.y);

                for (i = 4; i < nbRounds; i++)
                {
                    acc = Mix32(acc, input + 32 * i, input + 32 * i + 16, secret + MIDSIZE_STARTOFFSET + 32 * (i - 4),
                                seed);
                }

                acc = Mix32(acc, input + length - 16, input + length - 32,
                            secret + SECRET_KEY_MIN_SIZE - MIDSIZE_LASTOFFSET - 16, 0UL - seed);

                var low64  = acc.x + acc.y;
                var high64 = acc.x * PRIME64_1 + acc.y * PRIME64_4 + ((ulong)length - seed) * PRIME64_2;

                result = ToUint4(Avalanche(low64), 0ul - Avalanche(high64));
            }
        }
        static Hash128 ToHash128(ulong2 l)
        {
            var h = new Hash128();

            unsafe
            {
                *((ulong2 *)UnsafeUtility.AddressOf(ref h)) = l;
            }
            return(h);
        }
        static ulong2 Iterate(ulong2 block, ulong2 seed)
        {
            var xor = Xor(block, seed);

            return(MultiplyMod(xor, new ulong2
            {
                x = primeX,
                y = primeY
            }));
        }
        static Hash128 Hash(NativeArray <byte> input, ulong2 seed)
        {
            var length = input.Length;

            for (int i = 0; i < length; ++i)
            {
                seed = Iterate(input[i], seed);
            }

            return(ToHash128(seed));
        }
Ejemplo n.º 7
0
        public static void ulong2()
        {
            Random64 rng = new Random64(135);

            for (ulong i = 0; i < 64; i++)
            {
                ulong2 x = rng.NextULong2();

                Assert.AreEqual(new ulong2((ulong)_intsqrt(x.x), (ulong)_intsqrt(x.y)), maxmath.intsqrt(x));
            }
        }
        static Hash128 Hash(NativeArray <ulong2> blocks, ulong2 seed)
        {
            var length = blocks.Length;

            for (int i = 0; i < length; ++i)
            {
                seed = Iterate(blocks[i], seed);
            }

            return(ToHash128(seed));
        }
        static ulong2 Iterate(byte nextByte, ulong2 seed)
        {
            var xor = Xor(new ulong2 {
                x = nextByte, y = 0
            }, seed);

            return(MultiplyMod(xor, new ulong2
            {
                x = primeX,
                y = primeY
            }));
        }
Ejemplo n.º 10
0
        public static void long2()
        {
            Random64 rng = new Random64(135);

            for (long i = 0; i < 64; i++)
            {
                long2  x = rng.NextLong2();
                ulong2 n = rng.NextULong2();

                Assert.AreEqual(new long2((long)_intpow(x.x, n.x), (long)_intpow(x.y, n.y)), maxmath.intpow(x, n));
            }
        }
Ejemplo n.º 11
0
        public static void ulong2()
        {
            Random64 rng = new Random64(135);

            for (ulong i = 0; i < 64; i++)
            {
                ulong2 x = rng.NextULong2();
                ulong2 y = rng.NextULong2();

                Assert.AreEqual(new ulong2((ulong)_gcd(x.x, y.x), (ulong)_gcd(x.y, y.y)), maxmath.gcd(x, y));
            }
        }
        internal static Hash128 HashBlocks(NativeArray <byte> data)
        {
            var seed = new ulong2 {
                x = seedX, y = seedY
            };

            if (RequiresRemainderHandling(data))
            {
                seed = Iterate(GetRemainderBlock(data), seed);
            }

            return(Hash(GetULong2View(data), seed));
        }
Ejemplo n.º 13
0
        private static unsafe ulong2 Mix32(ulong2 acc, byte *input_1, byte *input_2, byte *secret, ulong seed)
        {
            unchecked
            {
                var l0 = acc.x + Mix16(input_1, secret + 0, seed);
                l0 ^= Read64LE(input_2) + Read64LE(input_2 + 8);

                var l1 = acc.y + Mix16(input_2, secret + 16, seed);
                l1 ^= Read64LE(input_1) + Read64LE(input_1 + 8);

                return(new ulong2(l0, l1));
            }
        }
Ejemplo n.º 14
0
        public static void ShuffleSetter()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                ulong2 yx = TestData_LHS[i];
                yx.yx   = TestData_RHS[i];
                result &= yx.x == TestData_RHS[i].y;
                result &= yx.y == TestData_RHS[i].x;
            }

            Assert.AreEqual(true, result);
        }
Ejemplo n.º 15
0
        public static void Cast_ToULong()
        {
            bool result = true;

            for (uint i = 0; i < NUM_TESTS; i++)
            {
                ulong2 x = (ulong2)TestData_LHS[i];

                result &= x.x == (ulong)TestData_LHS[i].x &
                          x.y == (ulong)TestData_LHS[i].y;
            }

            Assert.AreEqual(true, result);
        }
Ejemplo n.º 16
0
        public static void Subtract()
        {
            bool result = true;

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

                result &= x.x == (ulong)(TestData_LHS[i].x - TestData_RHS[i].x) &
                          x.y == (ulong)(TestData_LHS[i].y - TestData_RHS[i].y);
            }

            Assert.AreEqual(true, result);
        }
Ejemplo n.º 17
0
        public static void NOT()
        {
            bool result = true;

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

                result &= x.x == (ulong)(~TestData_LHS[i].x) &
                          x.y == (ulong)(~TestData_LHS[i].y);
            }

            Assert.AreEqual(true, result);
        }
Ejemplo n.º 18
0
        public static void Remainder()
        {
            bool result = true;

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

                result &= x.x == (ulong)(TestData_LHS[i].x % TestData_RHS[i].x) &
                          x.y == (ulong)(TestData_LHS[i].y % TestData_RHS[i].y);
            }

            Assert.AreEqual(true, result);
        }
        internal static ulong2 MultiplyMod(ulong2 a, ulong2 b)
        {
            unchecked
            {
                var c = Multiply(a.x, b.x);
                var d = a.x * b.y + a.y * b.x;

                return(new ulong2
                {
                    x = c.x,
                    y = c.y + d
                });
            }
        }
Ejemplo n.º 20
0
        public static void ulong2()
        {
            for (int i = 0; i < ULong2.TestData_LHS.Length; i++)
            {
                for (int j = 1; j < 2; j++)
                {
                    ulong2 rol = maxmath.vrol(ULong2.TestData_LHS[i], j);

                    for (int k = 0; k < 2; k++)
                    {
                        Assert.AreEqual(rol[k], ULong2.TestData_LHS[i][((2 - j) + k) % 2]);
                    }
                }
            }
        }
Ejemplo n.º 21
0
        public static void ulong2()
        {
            for (int i = 0; i < ULong2.TestData_LHS.Length; i++)
            {
                for (int j = 1; j < 2; j++)
                {
                    ulong2 shl = maxmath.vshl(ULong2.TestData_LHS[i], j);

                    for (int k = 0; k < 2; k++)
                    {
                        Assert.IsTrue(shl[k] == ((k - j < 0) ? 0 : ULong2.TestData_LHS[i][k - j]));
                    }
                }
            }
        }
Ejemplo n.º 22
0
        public static void ulong2()
        {
            for (int i = 0; i < ULong2.TestData_LHS.Length; i++)
            {
                for (int j = 1; j < 2; j++)
                {
                    ulong2 shr = maxmath.vshr(ULong2.TestData_LHS[i], j);

                    for (int k = 0; k < 2; k++)
                    {
                        Assert.IsTrue(shr[k] == ((j + k >= 2) ? 0 : ULong2.TestData_LHS[i][j + k]));
                    }
                }
            }
        }
Ejemplo n.º 23
0
        public static void Cast_FromV128()
        {
            bool result = true;

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

                result &= x.x == TestData_LHS[i].x &
                          x.y == TestData_LHS[i].y;
            }

            Assert.AreEqual(true, result);
        }
Ejemplo n.º 24
0
        public static void ShiftRight()
        {
            bool result = true;

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

                    result &= x.x == (ulong)(TestData_LHS[i].x >> j) &
                              x.y == (ulong)(TestData_LHS[i].y >> j);
                }
            }

            Assert.AreEqual(true, result);
        }
Ejemplo n.º 25
0
        public static void rol_ulong2()
        {
            bool     result = true;
            Random32 rng    = new Random32(RNG_SEED);

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

                    result &= test.x == math.rol(ULong2.TestData_LHS[i].x, n);
                    result &= test.y == math.rol(ULong2.TestData_LHS[i].y, n);
                }
            }

            Assert.AreEqual(true, result);
        }
        static ulong2 GetRemainderBlock(NativeArray <byte> data)
        {
            var length         = data.Length;
            var remainderBytes = length & 0xf;

            var rBlock = new ulong2();

            unsafe
            {
                UnsafeUtility.MemCpy
                (
                    UnsafeUtility.AddressOf(ref rBlock),
                    (byte *)data.GetUnsafeReadOnlyPtr() + (length - remainderBytes),
                    remainderBytes
                );
            }

            return(rBlock);
        }
 static ulong2 Xor(ulong2 a, ulong2 b) => new ulong2
 {
     x = a.x ^ b.x,
     y = a.y ^ b.y
 };
Ejemplo n.º 28
0
        public static void ShuffleGetter()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                ulong4 xxxx = TestData_LHS[i].xxxx;
                result &= xxxx.x == TestData_LHS[i].x &
                          xxxx.y == TestData_LHS[i].x &
                          xxxx.z == TestData_LHS[i].x &
                          xxxx.w == TestData_LHS[i].x;

                ulong4 xxxy = TestData_LHS[i].xxxy;
                result &= xxxy.x == TestData_LHS[i].x &
                          xxxy.y == TestData_LHS[i].x &
                          xxxy.z == TestData_LHS[i].x &
                          xxxy.w == TestData_LHS[i].y;

                ulong4 xxxz = TestData_LHS[i].xxxz;
                result &= xxxz.x == TestData_LHS[i].x &
                          xxxz.y == TestData_LHS[i].x &
                          xxxz.z == TestData_LHS[i].x &
                          xxxz.w == TestData_LHS[i].z;

                ulong4 xxyx = TestData_LHS[i].xxyx;
                result &= xxyx.x == TestData_LHS[i].x &
                          xxyx.y == TestData_LHS[i].x &
                          xxyx.z == TestData_LHS[i].y &
                          xxyx.w == TestData_LHS[i].x;

                ulong4 xxyy = TestData_LHS[i].xxyy;
                result &= xxyy.x == TestData_LHS[i].x &
                          xxyy.y == TestData_LHS[i].x &
                          xxyy.z == TestData_LHS[i].y &
                          xxyy.w == TestData_LHS[i].y;

                ulong4 xxyz = TestData_LHS[i].xxyz;
                result &= xxyz.x == TestData_LHS[i].x &
                          xxyz.y == TestData_LHS[i].x &
                          xxyz.z == TestData_LHS[i].y &
                          xxyz.w == TestData_LHS[i].z;

                ulong4 xxzx = TestData_LHS[i].xxzx;
                result &= xxzx.x == TestData_LHS[i].x &
                          xxzx.y == TestData_LHS[i].x &
                          xxzx.z == TestData_LHS[i].z &
                          xxzx.w == TestData_LHS[i].x;

                ulong4 xxzy = TestData_LHS[i].xxzy;
                result &= xxzy.x == TestData_LHS[i].x &
                          xxzy.y == TestData_LHS[i].x &
                          xxzy.z == TestData_LHS[i].z &
                          xxzy.w == TestData_LHS[i].y;

                ulong4 xxzz = TestData_LHS[i].xxzz;
                result &= xxzz.x == TestData_LHS[i].x &
                          xxzz.y == TestData_LHS[i].x &
                          xxzz.z == TestData_LHS[i].z &
                          xxzz.w == TestData_LHS[i].z;

                ulong4 xyxx = TestData_LHS[i].xyxx;
                result &= xyxx.x == TestData_LHS[i].x &
                          xyxx.y == TestData_LHS[i].y &
                          xyxx.z == TestData_LHS[i].x &
                          xyxx.w == TestData_LHS[i].x;

                ulong4 xyxy = TestData_LHS[i].xyxy;
                result &= xyxy.x == TestData_LHS[i].x &
                          xyxy.y == TestData_LHS[i].y &
                          xyxy.z == TestData_LHS[i].x &
                          xyxy.w == TestData_LHS[i].y;

                ulong4 xyxz = TestData_LHS[i].xyxz;
                result &= xyxz.x == TestData_LHS[i].x &
                          xyxz.y == TestData_LHS[i].y &
                          xyxz.z == TestData_LHS[i].x &
                          xyxz.w == TestData_LHS[i].z;

                ulong4 xyyx = TestData_LHS[i].xyyx;
                result &= xyyx.x == TestData_LHS[i].x &
                          xyyx.y == TestData_LHS[i].y &
                          xyyx.z == TestData_LHS[i].y &
                          xyyx.w == TestData_LHS[i].x;

                ulong4 xyyy = TestData_LHS[i].xyyy;
                result &= xyyy.x == TestData_LHS[i].x &
                          xyyy.y == TestData_LHS[i].y &
                          xyyy.z == TestData_LHS[i].y &
                          xyyy.w == TestData_LHS[i].y;

                ulong4 xyyz = TestData_LHS[i].xyyz;
                result &= xyyz.x == TestData_LHS[i].x &
                          xyyz.y == TestData_LHS[i].y &
                          xyyz.z == TestData_LHS[i].y &
                          xyyz.w == TestData_LHS[i].z;

                ulong4 xyzx = TestData_LHS[i].xyzx;
                result &= xyzx.x == TestData_LHS[i].x &
                          xyzx.y == TestData_LHS[i].y &
                          xyzx.z == TestData_LHS[i].z &
                          xyzx.w == TestData_LHS[i].x;

                ulong4 xyzy = TestData_LHS[i].xyzy;
                result &= xyzy.x == TestData_LHS[i].x &
                          xyzy.y == TestData_LHS[i].y &
                          xyzy.z == TestData_LHS[i].z &
                          xyzy.w == TestData_LHS[i].y;

                ulong4 xyzz = TestData_LHS[i].xyzz;
                result &= xyzz.x == TestData_LHS[i].x &
                          xyzz.y == TestData_LHS[i].y &
                          xyzz.z == TestData_LHS[i].z &
                          xyzz.w == TestData_LHS[i].z;

                ulong4 xzxx = TestData_LHS[i].xzxx;
                result &= xzxx.x == TestData_LHS[i].x &
                          xzxx.y == TestData_LHS[i].z &
                          xzxx.z == TestData_LHS[i].x &
                          xzxx.w == TestData_LHS[i].x;

                ulong4 xzxy = TestData_LHS[i].xzxy;
                result &= xzxy.x == TestData_LHS[i].x &
                          xzxy.y == TestData_LHS[i].z &
                          xzxy.z == TestData_LHS[i].x &
                          xzxy.w == TestData_LHS[i].y;

                ulong4 xzxz = TestData_LHS[i].xzxz;
                result &= xzxz.x == TestData_LHS[i].x &
                          xzxz.y == TestData_LHS[i].z &
                          xzxz.z == TestData_LHS[i].x &
                          xzxz.w == TestData_LHS[i].z;

                ulong4 xzyx = TestData_LHS[i].xzyx;
                result &= xzyx.x == TestData_LHS[i].x &
                          xzyx.y == TestData_LHS[i].z &
                          xzyx.z == TestData_LHS[i].y &
                          xzyx.w == TestData_LHS[i].x;

                ulong4 xzyy = TestData_LHS[i].xzyy;
                result &= xzyy.x == TestData_LHS[i].x &
                          xzyy.y == TestData_LHS[i].z &
                          xzyy.z == TestData_LHS[i].y &
                          xzyy.w == TestData_LHS[i].y;

                ulong4 xzyz = TestData_LHS[i].xzyz;
                result &= xzyz.x == TestData_LHS[i].x &
                          xzyz.y == TestData_LHS[i].z &
                          xzyz.z == TestData_LHS[i].y &
                          xzyz.w == TestData_LHS[i].z;

                ulong4 xzzx = TestData_LHS[i].xzzx;
                result &= xzzx.x == TestData_LHS[i].x &
                          xzzx.y == TestData_LHS[i].z &
                          xzzx.z == TestData_LHS[i].z &
                          xzzx.w == TestData_LHS[i].x;

                ulong4 xzzy = TestData_LHS[i].xzzy;
                result &= xzzy.x == TestData_LHS[i].x &
                          xzzy.y == TestData_LHS[i].z &
                          xzzy.z == TestData_LHS[i].z &
                          xzzy.w == TestData_LHS[i].y;

                ulong4 xzzz = TestData_LHS[i].xzzz;
                result &= xzzz.x == TestData_LHS[i].x &
                          xzzz.y == TestData_LHS[i].z &
                          xzzz.z == TestData_LHS[i].z &
                          xzzz.w == TestData_LHS[i].z;

                ulong4 yxxx = TestData_LHS[i].yxxx;
                result &= yxxx.x == TestData_LHS[i].y &
                          yxxx.y == TestData_LHS[i].x &
                          yxxx.z == TestData_LHS[i].x &
                          yxxx.w == TestData_LHS[i].x;

                ulong4 yxxy = TestData_LHS[i].yxxy;
                result &= yxxy.x == TestData_LHS[i].y &
                          yxxy.y == TestData_LHS[i].x &
                          yxxy.z == TestData_LHS[i].x &
                          yxxy.w == TestData_LHS[i].y;

                ulong4 yxxz = TestData_LHS[i].yxxz;
                result &= yxxz.x == TestData_LHS[i].y &
                          yxxz.y == TestData_LHS[i].x &
                          yxxz.z == TestData_LHS[i].x &
                          yxxz.w == TestData_LHS[i].z;

                ulong4 yxyx = TestData_LHS[i].yxyx;
                result &= yxyx.x == TestData_LHS[i].y &
                          yxyx.y == TestData_LHS[i].x &
                          yxyx.z == TestData_LHS[i].y &
                          yxyx.w == TestData_LHS[i].x;

                ulong4 yxyy = TestData_LHS[i].yxyy;
                result &= yxyy.x == TestData_LHS[i].y &
                          yxyy.y == TestData_LHS[i].x &
                          yxyy.z == TestData_LHS[i].y &
                          yxyy.w == TestData_LHS[i].y;

                ulong4 yxyz = TestData_LHS[i].yxyz;
                result &= yxyz.x == TestData_LHS[i].y &
                          yxyz.y == TestData_LHS[i].x &
                          yxyz.z == TestData_LHS[i].y &
                          yxyz.w == TestData_LHS[i].z;

                ulong4 yxzx = TestData_LHS[i].yxzx;
                result &= yxzx.x == TestData_LHS[i].y &
                          yxzx.y == TestData_LHS[i].x &
                          yxzx.z == TestData_LHS[i].z &
                          yxzx.w == TestData_LHS[i].x;

                ulong4 yxzy = TestData_LHS[i].yxzy;
                result &= yxzy.x == TestData_LHS[i].y &
                          yxzy.y == TestData_LHS[i].x &
                          yxzy.z == TestData_LHS[i].z &
                          yxzy.w == TestData_LHS[i].y;

                ulong4 yxzz = TestData_LHS[i].yxzz;
                result &= yxzz.x == TestData_LHS[i].y &
                          yxzz.y == TestData_LHS[i].x &
                          yxzz.z == TestData_LHS[i].z &
                          yxzz.w == TestData_LHS[i].z;

                ulong4 yyxx = TestData_LHS[i].yyxx;
                result &= yyxx.x == TestData_LHS[i].y &
                          yyxx.y == TestData_LHS[i].y &
                          yyxx.z == TestData_LHS[i].x &
                          yyxx.w == TestData_LHS[i].x;

                ulong4 yyxy = TestData_LHS[i].yyxy;
                result &= yyxy.x == TestData_LHS[i].y &
                          yyxy.y == TestData_LHS[i].y &
                          yyxy.z == TestData_LHS[i].x &
                          yyxy.w == TestData_LHS[i].y;

                ulong4 yyxz = TestData_LHS[i].yyxz;
                result &= yyxz.x == TestData_LHS[i].y &
                          yyxz.y == TestData_LHS[i].y &
                          yyxz.z == TestData_LHS[i].x &
                          yyxz.w == TestData_LHS[i].z;

                ulong4 yyyx = TestData_LHS[i].yyyx;
                result &= yyyx.x == TestData_LHS[i].y &
                          yyyx.y == TestData_LHS[i].y &
                          yyyx.z == TestData_LHS[i].y &
                          yyyx.w == TestData_LHS[i].x;

                ulong4 yyyy = TestData_LHS[i].yyyy;
                result &= yyyy.x == TestData_LHS[i].y &
                          yyyy.y == TestData_LHS[i].y &
                          yyyy.z == TestData_LHS[i].y &
                          yyyy.w == TestData_LHS[i].y;

                ulong4 yyyz = TestData_LHS[i].yyyz;
                result &= yyyz.x == TestData_LHS[i].y &
                          yyyz.y == TestData_LHS[i].y &
                          yyyz.z == TestData_LHS[i].y &
                          yyyz.w == TestData_LHS[i].z;

                ulong4 yyzx = TestData_LHS[i].yyzx;
                result &= yyzx.x == TestData_LHS[i].y &
                          yyzx.y == TestData_LHS[i].y &
                          yyzx.z == TestData_LHS[i].z &
                          yyzx.w == TestData_LHS[i].x;

                ulong4 yyzy = TestData_LHS[i].yyzy;
                result &= yyzy.x == TestData_LHS[i].y &
                          yyzy.y == TestData_LHS[i].y &
                          yyzy.z == TestData_LHS[i].z &
                          yyzy.w == TestData_LHS[i].y;

                ulong4 yyzz = TestData_LHS[i].yyzz;
                result &= yyzz.x == TestData_LHS[i].y &
                          yyzz.y == TestData_LHS[i].y &
                          yyzz.z == TestData_LHS[i].z &
                          yyzz.w == TestData_LHS[i].z;

                ulong4 yzxx = TestData_LHS[i].yzxx;
                result &= yzxx.x == TestData_LHS[i].y &
                          yzxx.y == TestData_LHS[i].z &
                          yzxx.z == TestData_LHS[i].x &
                          yzxx.w == TestData_LHS[i].x;

                ulong4 yzxy = TestData_LHS[i].yzxy;
                result &= yzxy.x == TestData_LHS[i].y &
                          yzxy.y == TestData_LHS[i].z &
                          yzxy.z == TestData_LHS[i].x &
                          yzxy.w == TestData_LHS[i].y;

                ulong4 yzxz = TestData_LHS[i].yzxz;
                result &= yzxz.x == TestData_LHS[i].y &
                          yzxz.y == TestData_LHS[i].z &
                          yzxz.z == TestData_LHS[i].x &
                          yzxz.w == TestData_LHS[i].z;

                ulong4 yzyx = TestData_LHS[i].yzyx;
                result &= yzyx.x == TestData_LHS[i].y &
                          yzyx.y == TestData_LHS[i].z &
                          yzyx.z == TestData_LHS[i].y &
                          yzyx.w == TestData_LHS[i].x;

                ulong4 yzyy = TestData_LHS[i].yzyy;
                result &= yzyy.x == TestData_LHS[i].y &
                          yzyy.y == TestData_LHS[i].z &
                          yzyy.z == TestData_LHS[i].y &
                          yzyy.w == TestData_LHS[i].y;

                ulong4 yzyz = TestData_LHS[i].yzyz;
                result &= yzyz.x == TestData_LHS[i].y &
                          yzyz.y == TestData_LHS[i].z &
                          yzyz.z == TestData_LHS[i].y &
                          yzyz.w == TestData_LHS[i].z;

                ulong4 yzzx = TestData_LHS[i].yzzx;
                result &= yzzx.x == TestData_LHS[i].y &
                          yzzx.y == TestData_LHS[i].z &
                          yzzx.z == TestData_LHS[i].z &
                          yzzx.w == TestData_LHS[i].x;

                ulong4 yzzy = TestData_LHS[i].yzzy;
                result &= yzzy.x == TestData_LHS[i].y &
                          yzzy.y == TestData_LHS[i].z &
                          yzzy.z == TestData_LHS[i].z &
                          yzzy.w == TestData_LHS[i].y;

                ulong4 yzzz = TestData_LHS[i].yzzz;
                result &= yzzz.x == TestData_LHS[i].y &
                          yzzz.y == TestData_LHS[i].z &
                          yzzz.z == TestData_LHS[i].z &
                          yzzz.w == TestData_LHS[i].z;

                ulong4 zxxx = TestData_LHS[i].zxxx;
                result &= zxxx.x == TestData_LHS[i].z &
                          zxxx.y == TestData_LHS[i].x &
                          zxxx.z == TestData_LHS[i].x &
                          zxxx.w == TestData_LHS[i].x;

                ulong4 zxxy = TestData_LHS[i].zxxy;
                result &= zxxy.x == TestData_LHS[i].z &
                          zxxy.y == TestData_LHS[i].x &
                          zxxy.z == TestData_LHS[i].x &
                          zxxy.w == TestData_LHS[i].y;

                ulong4 zxxz = TestData_LHS[i].zxxz;
                result &= zxxz.x == TestData_LHS[i].z &
                          zxxz.y == TestData_LHS[i].x &
                          zxxz.z == TestData_LHS[i].x &
                          zxxz.w == TestData_LHS[i].z;

                ulong4 zxyx = TestData_LHS[i].zxyx;
                result &= zxyx.x == TestData_LHS[i].z &
                          zxyx.y == TestData_LHS[i].x &
                          zxyx.z == TestData_LHS[i].y &
                          zxyx.w == TestData_LHS[i].x;

                ulong4 zxyy = TestData_LHS[i].zxyy;
                result &= zxyy.x == TestData_LHS[i].z &
                          zxyy.y == TestData_LHS[i].x &
                          zxyy.z == TestData_LHS[i].y &
                          zxyy.w == TestData_LHS[i].y;

                ulong4 zxyz = TestData_LHS[i].zxyz;
                result &= zxyz.x == TestData_LHS[i].z &
                          zxyz.y == TestData_LHS[i].x &
                          zxyz.z == TestData_LHS[i].y &
                          zxyz.w == TestData_LHS[i].z;

                ulong4 zxzx = TestData_LHS[i].zxzx;
                result &= zxzx.x == TestData_LHS[i].z &
                          zxzx.y == TestData_LHS[i].x &
                          zxzx.z == TestData_LHS[i].z &
                          zxzx.w == TestData_LHS[i].x;

                ulong4 zxzy = TestData_LHS[i].zxzy;
                result &= zxzy.x == TestData_LHS[i].z &
                          zxzy.y == TestData_LHS[i].x &
                          zxzy.z == TestData_LHS[i].z &
                          zxzy.w == TestData_LHS[i].y;

                ulong4 zxzz = TestData_LHS[i].zxzz;
                result &= zxzz.x == TestData_LHS[i].z &
                          zxzz.y == TestData_LHS[i].x &
                          zxzz.z == TestData_LHS[i].z &
                          zxzz.w == TestData_LHS[i].z;

                ulong4 zyxx = TestData_LHS[i].zyxx;
                result &= zyxx.x == TestData_LHS[i].z &
                          zyxx.y == TestData_LHS[i].y &
                          zyxx.z == TestData_LHS[i].x &
                          zyxx.w == TestData_LHS[i].x;

                ulong4 zyxy = TestData_LHS[i].zyxy;
                result &= zyxy.x == TestData_LHS[i].z &
                          zyxy.y == TestData_LHS[i].y &
                          zyxy.z == TestData_LHS[i].x &
                          zyxy.w == TestData_LHS[i].y;

                ulong4 zyxz = TestData_LHS[i].zyxz;
                result &= zyxz.x == TestData_LHS[i].z &
                          zyxz.y == TestData_LHS[i].y &
                          zyxz.z == TestData_LHS[i].x &
                          zyxz.w == TestData_LHS[i].z;

                ulong4 zyyx = TestData_LHS[i].zyyx;
                result &= zyyx.x == TestData_LHS[i].z &
                          zyyx.y == TestData_LHS[i].y &
                          zyyx.z == TestData_LHS[i].y &
                          zyyx.w == TestData_LHS[i].x;

                ulong4 zyyy = TestData_LHS[i].zyyy;
                result &= zyyy.x == TestData_LHS[i].z &
                          zyyy.y == TestData_LHS[i].y &
                          zyyy.z == TestData_LHS[i].y &
                          zyyy.w == TestData_LHS[i].y;

                ulong4 zyyz = TestData_LHS[i].zyyz;
                result &= zyyz.x == TestData_LHS[i].z &
                          zyyz.y == TestData_LHS[i].y &
                          zyyz.z == TestData_LHS[i].y &
                          zyyz.w == TestData_LHS[i].z;

                ulong4 zyzx = TestData_LHS[i].zyzx;
                result &= zyzx.x == TestData_LHS[i].z &
                          zyzx.y == TestData_LHS[i].y &
                          zyzx.z == TestData_LHS[i].z &
                          zyzx.w == TestData_LHS[i].x;

                ulong4 zyzy = TestData_LHS[i].zyzy;
                result &= zyzy.x == TestData_LHS[i].z &
                          zyzy.y == TestData_LHS[i].y &
                          zyzy.z == TestData_LHS[i].z &
                          zyzy.w == TestData_LHS[i].y;

                ulong4 zyzz = TestData_LHS[i].zyzz;
                result &= zyzz.x == TestData_LHS[i].z &
                          zyzz.y == TestData_LHS[i].y &
                          zyzz.z == TestData_LHS[i].z &
                          zyzz.w == TestData_LHS[i].z;

                ulong4 zzxx = TestData_LHS[i].zzxx;
                result &= zzxx.x == TestData_LHS[i].z &
                          zzxx.y == TestData_LHS[i].z &
                          zzxx.z == TestData_LHS[i].x &
                          zzxx.w == TestData_LHS[i].x;

                ulong4 zzxy = TestData_LHS[i].zzxy;
                result &= zzxy.x == TestData_LHS[i].z &
                          zzxy.y == TestData_LHS[i].z &
                          zzxy.z == TestData_LHS[i].x &
                          zzxy.w == TestData_LHS[i].y;

                ulong4 zzxz = TestData_LHS[i].zzxz;
                result &= zzxz.x == TestData_LHS[i].z &
                          zzxz.y == TestData_LHS[i].z &
                          zzxz.z == TestData_LHS[i].x &
                          zzxz.w == TestData_LHS[i].z;

                ulong4 zzyx = TestData_LHS[i].zzyx;
                result &= zzyx.x == TestData_LHS[i].z &
                          zzyx.y == TestData_LHS[i].z &
                          zzyx.z == TestData_LHS[i].y &
                          zzyx.w == TestData_LHS[i].x;

                ulong4 zzyy = TestData_LHS[i].zzyy;
                result &= zzyy.x == TestData_LHS[i].z &
                          zzyy.y == TestData_LHS[i].z &
                          zzyy.z == TestData_LHS[i].y &
                          zzyy.w == TestData_LHS[i].y;

                ulong4 zzyz = TestData_LHS[i].zzyz;
                result &= zzyz.x == TestData_LHS[i].z &
                          zzyz.y == TestData_LHS[i].z &
                          zzyz.z == TestData_LHS[i].y &
                          zzyz.w == TestData_LHS[i].z;

                ulong4 zzzx = TestData_LHS[i].zzzx;
                result &= zzzx.x == TestData_LHS[i].z &
                          zzzx.y == TestData_LHS[i].z &
                          zzzx.z == TestData_LHS[i].z &
                          zzzx.w == TestData_LHS[i].x;

                ulong4 zzzy = TestData_LHS[i].zzzy;
                result &= zzzy.x == TestData_LHS[i].z &
                          zzzy.y == TestData_LHS[i].z &
                          zzzy.z == TestData_LHS[i].z &
                          zzzy.w == TestData_LHS[i].y;

                ulong4 zzzz = TestData_LHS[i].zzzz;
                result &= zzzz.x == TestData_LHS[i].z &
                          zzzz.y == TestData_LHS[i].z &
                          zzzz.z == TestData_LHS[i].z &
                          zzzz.w == TestData_LHS[i].z;


                ulong3 xxx = TestData_LHS[i].xxx;
                result &= xxx.x == TestData_LHS[i].x &
                          xxx.y == TestData_LHS[i].x &
                          xxx.z == TestData_LHS[i].x;

                ulong3 xxy = TestData_LHS[i].xxy;
                result &= xxy.x == TestData_LHS[i].x &
                          xxy.y == TestData_LHS[i].x &
                          xxy.z == TestData_LHS[i].y;

                ulong3 xxz = TestData_LHS[i].xxz;
                result &= xxz.x == TestData_LHS[i].x &
                          xxz.y == TestData_LHS[i].x &
                          xxz.z == TestData_LHS[i].z;

                ulong3 xyx = TestData_LHS[i].xyx;
                result &= xyx.x == TestData_LHS[i].x &
                          xyx.y == TestData_LHS[i].y &
                          xyx.z == TestData_LHS[i].x;

                ulong3 xyy = TestData_LHS[i].xyy;
                result &= xyy.x == TestData_LHS[i].x &
                          xyy.y == TestData_LHS[i].y &
                          xyy.z == TestData_LHS[i].y;

                ulong3 xzx = TestData_LHS[i].xzx;
                result &= xzx.x == TestData_LHS[i].x &
                          xzx.y == TestData_LHS[i].z &
                          xzx.z == TestData_LHS[i].x;

                ulong3 xzy = TestData_LHS[i].xzy;
                result &= xzy.x == TestData_LHS[i].x &
                          xzy.y == TestData_LHS[i].z &
                          xzy.z == TestData_LHS[i].y;

                ulong3 xzz = TestData_LHS[i].xzz;
                result &= xzz.x == TestData_LHS[i].x &
                          xzz.y == TestData_LHS[i].z &
                          xzz.z == TestData_LHS[i].z;

                ulong3 yxx = TestData_LHS[i].yxx;
                result &= yxx.x == TestData_LHS[i].y &
                          yxx.y == TestData_LHS[i].x &
                          yxx.z == TestData_LHS[i].x;

                ulong3 yxy = TestData_LHS[i].yxy;
                result &= yxy.x == TestData_LHS[i].y &
                          yxy.y == TestData_LHS[i].x &
                          yxy.z == TestData_LHS[i].y;

                ulong3 yxz = TestData_LHS[i].yxz;
                result &= yxz.x == TestData_LHS[i].y &
                          yxz.y == TestData_LHS[i].x &
                          yxz.z == TestData_LHS[i].z;

                ulong3 yyx = TestData_LHS[i].yyx;
                result &= yyx.x == TestData_LHS[i].y &
                          yyx.y == TestData_LHS[i].y &
                          yyx.z == TestData_LHS[i].x;

                ulong3 yyy = TestData_LHS[i].yyy;
                result &= yyy.x == TestData_LHS[i].y &
                          yyy.y == TestData_LHS[i].y &
                          yyy.z == TestData_LHS[i].y;

                ulong3 yyz = TestData_LHS[i].yyz;
                result &= yyz.x == TestData_LHS[i].y &
                          yyz.y == TestData_LHS[i].y &
                          yyz.z == TestData_LHS[i].z;

                ulong3 yzx = TestData_LHS[i].yzx;
                result &= yzx.x == TestData_LHS[i].y &
                          yzx.y == TestData_LHS[i].z &
                          yzx.z == TestData_LHS[i].x;

                ulong3 yzy = TestData_LHS[i].yzy;
                result &= yzy.x == TestData_LHS[i].y &
                          yzy.y == TestData_LHS[i].z &
                          yzy.z == TestData_LHS[i].y;

                ulong3 yzz = TestData_LHS[i].yzz;
                result &= yzz.x == TestData_LHS[i].y &
                          yzz.y == TestData_LHS[i].z &
                          yzz.z == TestData_LHS[i].z;

                ulong3 zxx = TestData_LHS[i].zxx;
                result &= zxx.x == TestData_LHS[i].z &
                          zxx.y == TestData_LHS[i].x &
                          zxx.z == TestData_LHS[i].x;

                ulong3 zxy = TestData_LHS[i].zxy;
                result &= zxy.x == TestData_LHS[i].z &
                          zxy.y == TestData_LHS[i].x &
                          zxy.z == TestData_LHS[i].y;

                ulong3 zxz = TestData_LHS[i].zxz;
                result &= zxz.x == TestData_LHS[i].z &
                          zxz.y == TestData_LHS[i].x &
                          zxz.z == TestData_LHS[i].z;

                ulong3 zyx = TestData_LHS[i].zyx;
                result &= zyx.x == TestData_LHS[i].z &
                          zyx.y == TestData_LHS[i].y &
                          zyx.z == TestData_LHS[i].x;

                ulong3 zyy = TestData_LHS[i].zyy;
                result &= zyy.x == TestData_LHS[i].z &
                          zyy.y == TestData_LHS[i].y &
                          zyy.z == TestData_LHS[i].y;

                ulong3 zyz = TestData_LHS[i].zyz;
                result &= zyz.x == TestData_LHS[i].z &
                          zyz.y == TestData_LHS[i].y &
                          zyz.z == TestData_LHS[i].z;

                ulong3 zzx = TestData_LHS[i].zzx;
                result &= zzx.x == TestData_LHS[i].z &
                          zzx.y == TestData_LHS[i].z &
                          zzx.z == TestData_LHS[i].x;

                ulong3 zzy = TestData_LHS[i].zzy;
                result &= zzy.x == TestData_LHS[i].z &
                          zzy.y == TestData_LHS[i].z &
                          zzy.z == TestData_LHS[i].y;

                ulong3 zzz = TestData_LHS[i].zzz;
                result &= zzz.x == TestData_LHS[i].z &
                          zzz.y == TestData_LHS[i].z &
                          zzz.z == TestData_LHS[i].z;


                ulong2 xx = TestData_LHS[i].xx;
                result &= xx.x == TestData_LHS[i].x &
                          xx.y == TestData_LHS[i].x;

                ulong2 xy = TestData_LHS[i].xy;
                result &= xy.x == TestData_LHS[i].x &
                          xy.y == TestData_LHS[i].y;

                ulong2 xz = TestData_LHS[i].xz;
                result &= xz.x == TestData_LHS[i].x &
                          xz.y == TestData_LHS[i].z;

                ulong2 yx = TestData_LHS[i].yx;
                result &= yx.x == TestData_LHS[i].y &
                          yx.y == TestData_LHS[i].x;

                ulong2 yy = TestData_LHS[i].yy;
                result &= yy.x == TestData_LHS[i].y &
                          yy.y == TestData_LHS[i].y;

                ulong2 yz = TestData_LHS[i].yz;
                result &= yz.x == TestData_LHS[i].y &
                          yz.y == TestData_LHS[i].z;

                ulong2 zx = TestData_LHS[i].zx;
                result &= zx.x == TestData_LHS[i].z &
                          zx.y == TestData_LHS[i].x;

                ulong2 zy = TestData_LHS[i].zy;
                result &= zy.x == TestData_LHS[i].z &
                          zy.y == TestData_LHS[i].y;

                ulong2 zz = TestData_LHS[i].zz;
                result &= zz.x == TestData_LHS[i].z &
                          zz.y == TestData_LHS[i].z;
            }

            Assert.AreEqual(true, result);
        }
Ejemplo n.º 29
0
 public static extern CUResult cuMemcpyDtoH_v2(ref ulong2 dstHost, CUdeviceptr srcDevice, SizeT ByteCount);
Ejemplo n.º 30
0
        public static void ShuffleGetter()
        {
            bool result = true;

            for (int i = 0; i < NUM_TESTS; i++)
            {
                ulong4 xxxx = TestData_LHS[i].xxxx;
                result &= xxxx.x == TestData_LHS[i].x &
                          xxxx.y == TestData_LHS[i].x &
                          xxxx.z == TestData_LHS[i].x &
                          xxxx.w == TestData_LHS[i].x;

                ulong4 yxxx = TestData_LHS[i].yxxx;
                result &= yxxx.x == TestData_LHS[i].y &
                          yxxx.y == TestData_LHS[i].x &
                          yxxx.z == TestData_LHS[i].x &
                          yxxx.w == TestData_LHS[i].x;

                ulong4 xyxx = TestData_LHS[i].xyxx;
                result &= xyxx.x == TestData_LHS[i].x &
                          xyxx.y == TestData_LHS[i].y &
                          xyxx.z == TestData_LHS[i].x &
                          xyxx.w == TestData_LHS[i].x;

                ulong4 xxyx = TestData_LHS[i].xxyx;
                result &= xxyx.x == TestData_LHS[i].x &
                          xxyx.y == TestData_LHS[i].x &
                          xxyx.z == TestData_LHS[i].y &
                          xxyx.w == TestData_LHS[i].x;

                ulong4 xxxy = TestData_LHS[i].xxxy;
                result &= xxxy.x == TestData_LHS[i].x &
                          xxxy.y == TestData_LHS[i].x &
                          xxxy.z == TestData_LHS[i].x &
                          xxxy.w == TestData_LHS[i].y;

                ulong4 yyxx = TestData_LHS[i].yyxx;
                result &= yyxx.x == TestData_LHS[i].y &
                          yyxx.y == TestData_LHS[i].y &
                          yyxx.z == TestData_LHS[i].x &
                          yyxx.w == TestData_LHS[i].x;

                ulong4 yxyx = TestData_LHS[i].yxyx;
                result &= yxyx.x == TestData_LHS[i].y &
                          yxyx.y == TestData_LHS[i].x &
                          yxyx.z == TestData_LHS[i].y &
                          yxyx.w == TestData_LHS[i].x;

                ulong4 yxxy = TestData_LHS[i].yxxy;
                result &= yxxy.x == TestData_LHS[i].y &
                          yxxy.y == TestData_LHS[i].x &
                          yxxy.z == TestData_LHS[i].x &
                          yxxy.w == TestData_LHS[i].y;

                ulong4 xyyx = TestData_LHS[i].xyyx;
                result &= xyyx.x == TestData_LHS[i].x &
                          xyyx.y == TestData_LHS[i].y &
                          xyyx.z == TestData_LHS[i].y &
                          xyyx.w == TestData_LHS[i].x;

                ulong4 xyxy = TestData_LHS[i].xyxy;
                result &= xyxy.x == TestData_LHS[i].x &
                          xyxy.y == TestData_LHS[i].y &
                          xyxy.z == TestData_LHS[i].x &
                          xyxy.w == TestData_LHS[i].y;

                ulong4 xxyy = TestData_LHS[i].xxyy;
                result &= xxyy.x == TestData_LHS[i].x &
                          xxyy.y == TestData_LHS[i].x &
                          xxyy.z == TestData_LHS[i].y &
                          xxyy.w == TestData_LHS[i].y;

                ulong4 yyyx = TestData_LHS[i].yyyx;
                result &= yyyx.x == TestData_LHS[i].y &
                          yyyx.y == TestData_LHS[i].y &
                          yyyx.z == TestData_LHS[i].y &
                          yyyx.w == TestData_LHS[i].x;

                ulong4 yyxy = TestData_LHS[i].yyxy;
                result &= yyxy.x == TestData_LHS[i].y &
                          yyxy.y == TestData_LHS[i].y &
                          yyxy.z == TestData_LHS[i].x &
                          yyxy.w == TestData_LHS[i].y;

                ulong4 yxyy = TestData_LHS[i].yxyy;
                result &= yxyy.x == TestData_LHS[i].y &
                          yxyy.y == TestData_LHS[i].x &
                          yxyy.z == TestData_LHS[i].y &
                          yxyy.w == TestData_LHS[i].y;

                ulong4 xyyy = TestData_LHS[i].xyyy;
                result &= xyyy.x == TestData_LHS[i].x &
                          xyyy.y == TestData_LHS[i].y &
                          xyyy.z == TestData_LHS[i].y &
                          xyyy.w == TestData_LHS[i].y;

                ulong4 yyyy = TestData_LHS[i].yyyy;
                result &= yyyy.x == TestData_LHS[i].y &
                          yyyy.y == TestData_LHS[i].y &
                          yyyy.z == TestData_LHS[i].y &
                          yyyy.w == TestData_LHS[i].y;


                ulong3 xxx = TestData_LHS[i].xxx;
                result &= xxx.x == TestData_LHS[i].x &
                          xxx.y == TestData_LHS[i].x &
                          xxx.z == TestData_LHS[i].x;

                ulong3 yxx = TestData_LHS[i].yxx;
                result &= yxx.x == TestData_LHS[i].y &
                          yxx.y == TestData_LHS[i].x &
                          yxx.z == TestData_LHS[i].x;

                ulong3 xyx = TestData_LHS[i].xyx;
                result &= xyx.x == TestData_LHS[i].x &
                          xyx.y == TestData_LHS[i].y &
                          xyx.z == TestData_LHS[i].x;

                ulong3 xxy = TestData_LHS[i].xxy;
                result &= xxy.x == TestData_LHS[i].x &
                          xxy.y == TestData_LHS[i].x &
                          xxy.z == TestData_LHS[i].y;

                ulong3 yyx = TestData_LHS[i].yyx;
                result &= yyx.x == TestData_LHS[i].y &
                          yyx.y == TestData_LHS[i].y &
                          yyx.z == TestData_LHS[i].x;

                ulong3 yxy = TestData_LHS[i].yxy;
                result &= yxy.x == TestData_LHS[i].y &
                          yxy.y == TestData_LHS[i].x &
                          yxy.z == TestData_LHS[i].y;

                ulong3 xyy = TestData_LHS[i].xyy;
                result &= xyy.x == TestData_LHS[i].x &
                          xyy.y == TestData_LHS[i].y &
                          xyy.z == TestData_LHS[i].y;

                ulong3 yyy = TestData_LHS[i].yyy;
                result &= yyy.x == TestData_LHS[i].y &
                          yyy.y == TestData_LHS[i].y &
                          yyy.z == TestData_LHS[i].y;

                ulong2 xx = TestData_LHS[i].xx;
                result &= xx.x == TestData_LHS[i].x &
                          xx.y == TestData_LHS[i].x;

                ulong2 yx = TestData_LHS[i].yx;
                result &= yx.x == TestData_LHS[i].y &
                          yx.y == TestData_LHS[i].x;

                ulong2 yy = TestData_LHS[i].yy;
                result &= yy.x == TestData_LHS[i].y &
                          yy.y == TestData_LHS[i].y;
            }

            Assert.AreEqual(true, result);
        }