【原創】開源Math.NET基礎數學類庫使用(09)相關數論函式使用

               本部落格所有文章分類的總目錄：【總目錄】本部落格博文總目錄-實時更新 

開源Math.NET基礎數學類庫使用總目錄：【目錄】開源Math.NET基礎數學類庫使用總目錄

前言

　　數論就是指研究整數性質的一門理論。數論=算術。不過通常算術指數的計算，數論指數的理論。整數的基本元素是素數，所以數論的本質是對素數性質的研究。它是與平面幾何同樣歷史悠久的學科。它大致包括代數數論、解析數論、計算數論等等。

　　Math.NET也包括了很多數論相關的函式，這些函式都是靜態的，可以直接呼叫，如判斷是否奇數，判斷冪，平方數，最大公約數等等。同時部分函式已經作為擴充套件方法，可以直接在物件中使用。

　　如果本文資源或者顯示有問題，請參考 本文原文地址：http://www.cnblogs.com/asxinyu/p/4301097.html 

1.數論函式類Euclid

　　Math.NET包括的數論函式除了一部分大家日常接觸到的，奇數，偶數，冪，平方數，最大公約數，最小公倍數等函式，還有一些歐幾里得幾何的函式，當然也是比較簡單的，這些問題的演算法有一些比較簡單，如最大公約數，最小公倍數等，都有成熟的演算法可以使用，對於使用Math.NET的人來說，不必要了解太小，當然對於需要搞清楚原理的人來說，學習Math.NET的架構或者實現，是可以參考的。所以這裡先給出Math.NET關於數論函式類Euclid的原始碼：

/// <summary>
/// 整數數論函式
/// Integer number theory functions.
/// </summary>
public static class Euclid
{
    /// <summary>
    /// Canonical Modulus. The result has the sign of the divisor.
    /// </summary>
    public static double Modulus(double dividend, double divisor)
    {
        return ((dividend%divisor) + divisor)%divisor;
    }

    /// <summary>
    /// Canonical Modulus. The result has the sign of the divisor.
    /// </summary>
    public static float Modulus(float dividend, float divisor)
    {
        return ((dividend%divisor) + divisor)%divisor;
    }

    /// <summary>
    /// Canonical Modulus. The result has the sign of the divisor.
    /// </summary>
    public static int Modulus(int dividend, int divisor)
    {
        return ((dividend%divisor) + divisor)%divisor;
    }

    /// <summary>
    /// Canonical Modulus. The result has the sign of the divisor.
    /// </summary>
    public static long Modulus(long dividend, long divisor)
    {
        return ((dividend%divisor) + divisor)%divisor;
    }

#if !NOSYSNUMERICS
    /// <summary>
    /// Canonical Modulus. The result has the sign of the divisor.
    /// </summary>
    public static BigInteger Modulus(BigInteger dividend, BigInteger divisor)
    {
        return ((dividend%divisor) + divisor)%divisor;
    }
#endif

    /// <summary>
    /// Remainder (% operator). The result has the sign of the dividend.
    /// </summary>
    public static double Remainder(double dividend, double divisor)
    {
        return dividend%divisor;
    }

    /// <summary>
    /// Remainder (% operator). The result has the sign of the dividend.
    /// </summary>
    public static float Remainder(float dividend, float divisor)
    {
        return dividend%divisor;
    }

    /// <summary>
    /// Remainder (% operator). The result has the sign of the dividend.
    /// </summary>
    public static int Remainder(int dividend, int divisor)
    {
        return dividend%divisor;
    }

    /// <summary>
    /// Remainder (% operator). The result has the sign of the dividend.
    /// </summary>
    public static long Remainder(long dividend, long divisor)
    {
        return dividend%divisor;
    }

#if !NOSYSNUMERICS
    /// <summary>
    /// Remainder (% operator). The result has the sign of the dividend.
    /// </summary>
    public static BigInteger Remainder(BigInteger dividend, BigInteger divisor)
    {
        return dividend%divisor;
    }
#endif

    /// <summary>
    /// Find out whether the provided 32 bit integer is an even number.
    /// </summary>
    /// <param name="number">The number to very whether it's even.</param>
    /// <returns>True if and only if it is an even number.</returns>
    public static bool IsEven(this int number)
    {
        return (number & 0x1) == 0x0;
    }

    /// <summary>
    /// Find out whether the provided 64 bit integer is an even number.
    /// </summary>
    /// <param name="number">The number to very whether it's even.</param>
    /// <returns>True if and only if it is an even number.</returns>
    public static bool IsEven(this long number)
    {
        return (number & 0x1) == 0x0;
    }

    /// <summary>
    /// Find out whether the provided 32 bit integer is an odd number.
    /// </summary>
    /// <param name="number">The number to very whether it's odd.</param>
    /// <returns>True if and only if it is an odd number.</returns>
    public static bool IsOdd(this int number)
    {
        return (number & 0x1) == 0x1;
    }

    /// <summary>
    /// Find out whether the provided 64 bit integer is an odd number.
    /// </summary>
    /// <param name="number">The number to very whether it's odd.</param>
    /// <returns>True if and only if it is an odd number.</returns>
    public static bool IsOdd(this long number)
    {
        return (number & 0x1) == 0x1;
    }

    /// <summary>
    /// Find out whether the provided 32 bit integer is a perfect power of two.
    /// </summary>
    /// <param name="number">The number to very whether it's a power of two.</param>
    /// <returns>True if and only if it is a power of two.</returns>
    public static bool IsPowerOfTwo(this int number)
    {
        return number > 0 && (number & (number - 1)) == 0x0;
    }

    /// <summary>
    /// Find out whether the provided 64 bit integer is a perfect power of two.
    /// </summary>
    /// <param name="number">The number to very whether it's a power of two.</param>
    /// <returns>True if and only if it is a power of two.</returns>
    public static bool IsPowerOfTwo(this long number)
    {
        return number > 0 && (number & (number - 1)) == 0x0;
    }

    /// <summary>
    /// Find out whether the provided 32 bit integer is a perfect square, i.e. a square of an integer.
    /// </summary>
    /// <param name="number">The number to very whether it's a perfect square.</param>
    /// <returns>True if and only if it is a perfect square.</returns>
    public static bool IsPerfectSquare(this int number)
    {
        if (number < 0)
        {
            return false;
        }

        int lastHexDigit = number & 0xF;
        if (lastHexDigit > 9)
        {
            return false; // return immediately in 6 cases out of 16.
        }

        if (lastHexDigit == 0 || lastHexDigit == 1 || lastHexDigit == 4 || lastHexDigit == 9)
        {
            int t = (int)Math.Floor(Math.Sqrt(number) + 0.5);
            return (t * t) == number;
        }

        return false;
    }

    /// <summary>
    /// Find out whether the provided 64 bit integer is a perfect square, i.e. a square of an integer.
    /// </summary>
    /// <param name="number">The number to very whether it's a perfect square.</param>
    /// <returns>True if and only if it is a perfect square.</returns>
    public static bool IsPerfectSquare(this long number)
    {
        if (number < 0)
        {
            return false;
        }

        int lastHexDigit = (int)(number & 0xF);
        if (lastHexDigit > 9)
        {
            return false; // return immediately in 6 cases out of 16.
        }

        if (lastHexDigit == 0 || lastHexDigit == 1 || lastHexDigit == 4 || lastHexDigit == 9)
        {
            long t = (long)Math.Floor(Math.Sqrt(number) + 0.5);
            return (t * t) == number;
        }

        return false;
    }

    /// <summary>
    /// Raises 2 to the provided integer exponent (0 &lt;= exponent &lt; 31).
    /// </summary>
    /// <param name="exponent">The exponent to raise 2 up to.</param>
    /// <returns>2 ^ exponent.</returns>
    /// <exception cref="ArgumentOutOfRangeException"/>
    public static int PowerOfTwo(this int exponent)
    {
        if (exponent < 0 || exponent >= 31)
        {
            throw new ArgumentOutOfRangeException("exponent");
        }

        return 1 << exponent;
    }

    /// <summary>
    /// Raises 2 to the provided integer exponent (0 &lt;= exponent &lt; 63).
    /// </summary>
    /// <param name="exponent">The exponent to raise 2 up to.</param>
    /// <returns>2 ^ exponent.</returns>
    /// <exception cref="ArgumentOutOfRangeException"/>
    public static long PowerOfTwo(this long exponent)
    {
        if (exponent < 0 || exponent >= 63)
        {
            throw new ArgumentOutOfRangeException("exponent");
        }

        return ((long)1) << (int)exponent;
    }

    /// <summary>
    /// Find the closest perfect power of two that is larger or equal to the provided
    /// 32 bit integer.
    /// </summary>
    /// <param name="number">The number of which to find the closest upper power of two.</param>
    /// <returns>A power of two.</returns>
    /// <exception cref="ArgumentOutOfRangeException"/>
    public static int CeilingToPowerOfTwo(this int number)
    {
        if (number == Int32.MinValue)
        {
            return 0;
        }

        const int maxPowerOfTwo = 0x40000000;
        if (number > maxPowerOfTwo)
        {
            throw new ArgumentOutOfRangeException("number");
        }

        number--;
        number |= number >> 1;
        number |= number >> 2;
        number |= number >> 4;
        number |= number >> 8;
        number |= number >> 16;
        return number + 1;
    }

    /// <summary>
    /// Find the closest perfect power of two that is larger or equal to the provided
    /// 64 bit integer.
    /// </summary>
    /// <param name="number">The number of which to find the closest upper power of two.</param>
    /// <returns>A power of two.</returns>
    /// <exception cref="ArgumentOutOfRangeException"/>
    public static long CeilingToPowerOfTwo(this long number)
    {
        if (number == Int64.MinValue)
        {
            return 0;
        }

        const long maxPowerOfTwo = 0x4000000000000000;
        if (number > maxPowerOfTwo)
        {
            throw new ArgumentOutOfRangeException("number");
        }

        number--;
        number |= number >> 1;
        number |= number >> 2;
        number |= number >> 4;
        number |= number >> 8;
        number |= number >> 16;
        number |= number >> 32;
        return number + 1;
    }

    /// <summary>
    /// Returns the greatest common divisor (<c>gcd</c>) of two integers using Euclid's algorithm.
    /// </summary>
    /// <param name="a">First Integer: a.</param>
    /// <param name="b">Second Integer: b.</param>
    /// <returns>Greatest common divisor <c>gcd</c>(a,b)</returns>
    public static long GreatestCommonDivisor(long a, long b)
    {
        while (b != 0)
        {
            var remainder = a%b;
            a = b;
            b = remainder;
        }

        return Math.Abs(a);
    }

    /// <summary>
    /// Returns the greatest common divisor (<c>gcd</c>) of a set of integers using Euclid's
    /// algorithm.
    /// </summary>
    /// <param name="integers">List of Integers.</param>
    /// <returns>Greatest common divisor <c>gcd</c>(list of integers)</returns>
    public static long GreatestCommonDivisor(IList<long> integers)
    {
        if (null == integers)
        {
            throw new ArgumentNullException("integers");
        }

        if (integers.Count == 0)
        {
            return 0;
        }

        var gcd = Math.Abs(integers[0]);

        for (var i = 1; (i < integers.Count) && (gcd > 1); i++)
        {
            gcd = GreatestCommonDivisor(gcd, integers[i]);
        }

        return gcd;
    }

    /// <summary>
    /// Returns the greatest common divisor (<c>gcd</c>) of a set of integers using Euclid's algorithm.
    /// </summary>
    /// <param name="integers">List of Integers.</param>
    /// <returns>Greatest common divisor <c>gcd</c>(list of integers)</returns>
    public static long GreatestCommonDivisor(params long[] integers)
    {
        return GreatestCommonDivisor((IList<long>)integers);
    }

    /// <summary>
    /// Computes the extended greatest common divisor, such that a*x + b*y = <c>gcd</c>(a,b).
    /// </summary>
    /// <param name="a">First Integer: a.</param>
    /// <param name="b">Second Integer: b.</param>
    /// <param name="x">Resulting x, such that a*x + b*y = <c>gcd</c>(a,b).</param>
    /// <param name="y">Resulting y, such that a*x + b*y = <c>gcd</c>(a,b)</param>
    /// <returns>Greatest common divisor <c>gcd</c>(a,b)</returns>
    /// <example>
    /// <code>
    /// long x,y,d;
    /// d = Fn.GreatestCommonDivisor(45,18,out x, out y);
    /// -> d == 9 &amp;&amp; x == 1 &amp;&amp; y == -2
    /// </code>
    /// The <c>gcd</c> of 45 and 18 is 9: 18 = 2*9, 45 = 5*9. 9 = 1*45 -2*18, therefore x=1 and y=-2.
    /// </example>
    public static long ExtendedGreatestCommonDivisor(long a, long b, out long x, out long y)
    {
        long mp = 1, np = 0, m = 0, n = 1;

        while (b != 0)
        {
            long rem;
#if PORTABLE
            rem = a % b;
            var quot = a / b;
#else
            long quot = Math.DivRem(a, b, out rem);
#endif
            a = b;
            b = rem;

            var tmp = m;
            m = mp - (quot*m);
            mp = tmp;

            tmp = n;
            n = np - (quot*n);
            np = tmp;
        }

        if (a >= 0)
        {
            x = mp;
            y = np;
            return a;
        }

        x = -mp;
        y = -np;
        return -a;
    }

    /// <summary>
    /// Returns the least common multiple (<c>lcm</c>) of two integers using Euclid's algorithm.
    /// </summary>
    /// <param name="a">First Integer: a.</param>
    /// <param name="b">Second Integer: b.</param>
    /// <returns>Least common multiple <c>lcm</c>(a,b)</returns>
    public static long LeastCommonMultiple(long a, long b)
    {
        if ((a == 0) || (b == 0))
        {
            return 0;
        }

        return Math.Abs((a/GreatestCommonDivisor(a, b))*b);
    }

    /// <summary>
    /// Returns the least common multiple (<c>lcm</c>) of a set of integers using Euclid's algorithm.
    /// </summary>
    /// <param name="integers">List of Integers.</param>
    /// <returns>Least common multiple <c>lcm</c>(list of integers)</returns>
    public static long LeastCommonMultiple(IList<long> integers)
    {
        if (null == integers)
        {
            throw new ArgumentNullException("integers");
        }

        if (integers.Count == 0)
        {
            return 1;
        }

        var lcm = Math.Abs(integers[0]);

        for (var i = 1; i < integers.Count; i++)
        {
            lcm = LeastCommonMultiple(lcm, integers[i]);
        }

        return lcm;
    }

    /// <summary>
    /// Returns the least common multiple (<c>lcm</c>) of a set of integers using Euclid's algorithm.
    /// </summary>
    /// <param name="integers">List of Integers.</param>
    /// <returns>Least common multiple <c>lcm</c>(list of integers)</returns>
    public static long LeastCommonMultiple(params long[] integers)
    {
        return LeastCommonMultiple((IList<long>)integers);
    }

#if !NOSYSNUMERICS
    /// <summary>
    /// Returns the greatest common divisor (<c>gcd</c>) of two big integers.
    /// </summary>
    /// <param name="a">First Integer: a.</param>
    /// <param name="b">Second Integer: b.</param>
    /// <returns>Greatest common divisor <c>gcd</c>(a,b)</returns>
    public static BigInteger GreatestCommonDivisor(BigInteger a, BigInteger b)
    {
        return BigInteger.GreatestCommonDivisor(a, b);
    }

    /// <summary>
    /// Returns the greatest common divisor (<c>gcd</c>) of a set of big integers.
    /// </summary>
    /// <param name="integers">List of Integers.</param>
    /// <returns>Greatest common divisor <c>gcd</c>(list of integers)</returns>
    public static BigInteger GreatestCommonDivisor(IList<BigInteger> integers)
    {
        if (null == integers)
        {
            throw new ArgumentNullException("integers");
        }

        if (integers.Count == 0)
        {
            return 0;
        }

        var gcd = BigInteger.Abs(integers[0]);

        for (int i = 1; (i < integers.Count) && (gcd > BigInteger.One); i++)
        {
            gcd = GreatestCommonDivisor(gcd, integers[i]);
        }

        return gcd;
    }

    /// <summary>
    /// Returns the greatest common divisor (<c>gcd</c>) of a set of big integers.
    /// </summary>
    /// <param name="integers">List of Integers.</param>
    /// <returns>Greatest common divisor <c>gcd</c>(list of integers)</returns>
    public static BigInteger GreatestCommonDivisor(params BigInteger[] integers)
    {
        return GreatestCommonDivisor((IList<BigInteger>)integers);
    }

    /// <summary>
    /// Computes the extended greatest common divisor, such that a*x + b*y = <c>gcd</c>(a,b).
    /// </summary>
    /// <param name="a">First Integer: a.</param>
    /// <param name="b">Second Integer: b.</param>
    /// <param name="x">Resulting x, such that a*x + b*y = <c>gcd</c>(a,b).</param>
    /// <param name="y">Resulting y, such that a*x + b*y = <c>gcd</c>(a,b)</param>
    /// <returns>Greatest common divisor <c>gcd</c>(a,b)</returns>
    /// <example>
    /// <code>
    /// long x,y,d;
    /// d = Fn.GreatestCommonDivisor(45,18,out x, out y);
    /// -> d == 9 &amp;&amp; x == 1 &amp;&amp; y == -2
    /// </code>
    /// The <c>gcd</c> of 45 and 18 is 9: 18 = 2*9, 45 = 5*9. 9 = 1*45 -2*18, therefore x=1 and y=-2.
    /// </example>
    public static BigInteger ExtendedGreatestCommonDivisor(BigInteger a, BigInteger b, out BigInteger x, out BigInteger y)
    {
        BigInteger mp = BigInteger.One, np = BigInteger.Zero, m = BigInteger.Zero, n = BigInteger.One;

        while (!b.IsZero)
        {
            BigInteger rem;
            BigInteger quot = BigInteger.DivRem(a, b, out rem);
            a = b;
            b = rem;

            BigInteger tmp = m;
            m = mp - (quot*m);
            mp = tmp;

            tmp = n;
            n = np - (quot*n);
            np = tmp;
        }

        if (a >= BigInteger.Zero)
        {
            x = mp;
            y = np;
            return a;
        }

        x = -mp;
        y = -np;
        return -a;
    }

    /// <summary>
    /// Returns the least common multiple (<c>lcm</c>) of two big integers.
    /// </summary>
    /// <param name="a">First Integer: a.</param>
    /// <param name="b">Second Integer: b.</param>
    /// <returns>Least common multiple <c>lcm</c>(a,b)</returns>
    public static BigInteger LeastCommonMultiple(BigInteger a, BigInteger b)
    {
        if (a.IsZero || b.IsZero)
        {
            return BigInteger.Zero;
        }

        return BigInteger.Abs((a/BigInteger.GreatestCommonDivisor(a, b))*b);
    }

    /// <summary>
    /// Returns the least common multiple (<c>lcm</c>) of a set of big integers.
    /// </summary>
    /// <param name="integers">List of Integers.</param>
    /// <returns>Least common multiple <c>lcm</c>(list of integers)</returns>
    public static BigInteger LeastCommonMultiple(IList<BigInteger> integers)
    {
        if (null == integers)
        {
            throw new ArgumentNullException("integers");
        }

        if (integers.Count == 0)
        {
            return 1;
        }

        var lcm = BigInteger.Abs(integers[0]);

        for (int i = 1; i < integers.Count; i++)
        {
            lcm = LeastCommonMultiple(lcm, integers[i]);
        }

        return lcm;
    }

    /// <summary>
    /// Returns the least common multiple (<c>lcm</c>) of a set of big integers.
    /// </summary>
    /// <param name="integers">List of Integers.</param>
    /// <returns>Least common multiple <c>lcm</c>(list of integers)</returns>
    public static BigInteger LeastCommonMultiple(params BigInteger[] integers)
    {
        return LeastCommonMultiple((IList<BigInteger>)integers);
    }
#endif
}

2.Euclid類的使用例子

 　上面已經看到原始碼，也提到了，Euclid作為靜態類，其中的很多靜態方法都可以直接作為擴充套件方法使用。這裡看看幾個簡單的例子：

// 1. Find out whether the provided number is an even number
Console.WriteLine(@"1.判斷提供的數字是否是偶數");
Console.WriteLine(@"{0} 是偶數 = {1}. {2} 是偶數 = {3}", 1, Euclid.IsEven(1), 2, 2.IsEven());
Console.WriteLine();

// 2. Find out whether the provided number is an odd number
Console.WriteLine(@"2.判斷提供的數字是否是奇數");
Console.WriteLine(@"{0} 是奇數 = {1}. {2} 是奇數 = {3}", 1, 1.IsOdd(), 2, Euclid.IsOdd(2));
Console.WriteLine();

// 3. Find out whether the provided number is a perfect power of two
Console.WriteLine(@"2.判斷提供的數字是否是2的冪");
Console.WriteLine(@"{0} 是2的冪 = {1}. {2} 是2的冪 = {3}", 5, 5.IsPowerOfTwo(), 16, Euclid.IsPowerOfTwo(16));
Console.WriteLine();

// 4. Find the closest perfect power of two that is larger or equal to 97
Console.WriteLine(@"4.返回大於等於97的最小2的冪整數");
Console.WriteLine(97.CeilingToPowerOfTwo());
Console.WriteLine();

// 5. Raise 2 to the 16
Console.WriteLine(@"5. 2的16次冪");
Console.WriteLine(16.PowerOfTwo());
Console.WriteLine();

// 6. Find out whether the number is a perfect square
Console.WriteLine(@"6. 判斷提供的數字是否是平方數");
Console.WriteLine(@"{0} 是平方數 = {1}. {2} 是平方數 = {3}", 37, 37.IsPerfectSquare(), 81, Euclid.IsPerfectSquare(81));
Console.WriteLine();

// 7. Compute the greatest common divisor of 32 and 36 
Console.WriteLine(@"7. 返回32和36的最大公約數");
Console.WriteLine(Euclid.GreatestCommonDivisor(32, 36));
Console.WriteLine();

// 8. Compute the greatest common divisor of 492, -984, 123, 246
Console.WriteLine(@"8. 返回的最大公約數：492、-984、123、246");
Console.WriteLine(Euclid.GreatestCommonDivisor(492, -984, 123, 246));
Console.WriteLine();

// 9. Compute the least common multiple of 16 and 12
Console.WriteLine(@"10. 計算的最小公倍數：16和12");
Console.WriteLine(Euclid.LeastCommonMultiple(16, 12));
Console.WriteLine();

結果如下：

1.判斷提供的數字是否是偶數
1 是偶數 = False. 2 是偶數 = True

2.判斷提供的數字是否是奇數
1 是奇數 = True. 2 是奇數 = False

2.判斷提供的數字是否是2的冪
5 是2的冪 = False. 16 是2的冪 = True

4.返回大於等於97的最小2的冪整數
128

5. 2的16次冪
65536

6. 判斷提供的數字是否是平方數
37 是平方數 = False. 81 是平方數 = True

7. 返回32和36的最大公約數
4

8. 返回的最大公約數：492、-984、123、246
123

10. 計算的最小公倍數：16和12
48

3.資源

　　原始碼下載：http://www.cnblogs.com/asxinyu/p/4264638.html

　　如果本文資源或者顯示有問題，請參考 本文原文地址：http://www.cnblogs.com/asxinyu/p/4301097.html