开源Math.NET基础数学类库使用(09)相关数论函数使用

原文:【原创】开源Math.NET基础数学类库使用(09)相关数论函数使用

              本博客所有文章分类的总目录：http://www.cnblogs.com/asxinyu/p/4288836.html

开源Math.NET基础数学类库使用总目录：http://www.cnblogs.com/asxinyu/p/4329737.html

前言

　　数论就是指研究整数性质的一门理论。数论=算术。不过通常算术指数的计算，数论指数的理论。整数的基本元素是素数，所以数论的本质是对素数性质的研究。它是与平面几何同样历史悠久的学科。它大致包括代数数论、解析数论、计算数论等等。

　　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 >  && (number & (number - )) == 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 >  && (number & (number - )) == 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 < )
         {
             return false;
         }

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

         if (lastHexDigit ==  || lastHexDigit ==  || lastHexDigit ==  || lastHexDigit == )
         {
             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 < )
         {
             return false;
         }

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

         if (lastHexDigit ==  || lastHexDigit ==  || lastHexDigit ==  || lastHexDigit == )
         {
             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 <  || exponent >= )
         {
             throw new ArgumentOutOfRangeException("exponent");
         }

         return  << 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 <  || exponent >= )
         {
             throw new ArgumentOutOfRangeException("exponent");
         }

         return ((long)) << (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 ;
         }

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

         number--;
         number |= number >> ;
         number |= number >> ;
         number |= number >> ;
         number |= number >> ;
         number |= number >> ;
         return number + ;
     }

     /// <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 ;
         }

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

         number--;
         number |= number >> ;
         number |= number >> ;
         number |= number >> ;
         number |= number >> ;
         number |= number >> ;
         number |= number >> ;
         return number + ;
     }

     /// <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 != )
         {
             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 == )
         {
             return ;
         }

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

         for (var i = ; (i < integers.Count) && (gcd > ); 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 = , np = , m = , n = ;

         while (b != )
         {
             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 >= )
         {
             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 == ) || (b == ))
         {
             return ;
         }

         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 == )
         {
             return ;
         }

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

         for (var i = ; 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 == )
         {
             return ;
         }

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

         for (int i = ; (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 == )
         {
             return ;
         }

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

         for (int i = ; 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}", , Euclid.IsEven(), , .IsEven());
 Console.WriteLine();

 // 2. Find out whether the provided number is an odd number
 Console.WriteLine(@"2.判断提供的数字是否是奇数");
 Console.WriteLine(@"{0} 是奇数 = {1}. {2} 是奇数 = {3}", , .IsOdd(), , Euclid.IsOdd());
 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}", , .IsPowerOfTwo(), , Euclid.IsPowerOfTwo());
 Console.WriteLine();

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

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

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

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

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

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

结果如下：

.判断提供的数字是否是偶数
 是偶数 = False.  是偶数 = True

.判断提供的数字是否是奇数
 是奇数 = True.  是奇数 = False

.判断提供的数字是否是2的幂
 是2的幂 = False.  是2的幂 = True

.返回大于等于97的最小2的幂整数

. 2的16次幂

. 判断提供的数字是否是平方数
 是平方数 = False.  是平方数 = True

. 返回32和36的最大公约数

. 返回的最大公约数：、-、、

. 计算的最小公倍数：16和12

3.资源

　　源码下载：http://www.cnblogs.com/asxinyu/p/4264638.html

　　如果本文资源或者显示有问题，请参考 本文原文地址：http://www.cnblogs.com/asxinyu/p/4301097.html