Exemple #1
0
        public static void byte16()
        {
            Random8 rng = new Random8(135);

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

                Assert.AreEqual(new byte16((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),
                                           (byte)_gcd(x.x8, y.x8),
                                           (byte)_gcd(x.x9, y.x9),
                                           (byte)_gcd(x.x10, y.x10),
                                           (byte)_gcd(x.x11, y.x11),
                                           (byte)_gcd(x.x12, y.x12),
                                           (byte)_gcd(x.x13, y.x13),
                                           (byte)_gcd(x.x14, y.x14),
                                           (byte)_gcd(x.x15, y.x15)),
                                maxmath.gcd(x, y));
            }
        }
Exemple #2
0
        public static void byte16()
        {
            Random8 rng = new Random8(135);

            for (int i = 0; i < 64; i++)
            {
                byte16 x = rng.NextByte16();

                Assert.AreEqual(new byte16((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),
                                           (byte)_intsqrt(x.x8),
                                           (byte)_intsqrt(x.x9),
                                           (byte)_intsqrt(x.x10),
                                           (byte)_intsqrt(x.x11),
                                           (byte)_intsqrt(x.x12),
                                           (byte)_intsqrt(x.x13),
                                           (byte)_intsqrt(x.x14),
                                           (byte)_intsqrt(x.x15)),
                                maxmath.intsqrt(x));
            }
        }
Exemple #3
0
        public static void sbyte16()
        {
            Random8 rng = new Random8(135);

            for (int i = 0; i < 64; i++)
            {
                sbyte16 x = rng.NextSByte16();
                byte16  n = rng.NextByte16();

                Assert.AreEqual(new sbyte16((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),
                                            (sbyte)_intpow(x.x8, n.x8),
                                            (sbyte)_intpow(x.x9, n.x9),
                                            (sbyte)_intpow(x.x10, n.x10),
                                            (sbyte)_intpow(x.x11, n.x11),
                                            (sbyte)_intpow(x.x12, n.x12),
                                            (sbyte)_intpow(x.x13, n.x13),
                                            (sbyte)_intpow(x.x14, n.x14),
                                            (sbyte)_intpow(x.x15, n.x15)),
                                maxmath.intpow(x, n));
            }
        }