【原创】开源Math.NET基础数学类库使用(09)相关数论函数使用
2015-03-06 08:00
465 查看
本博客所有文章分类的总目录:【总目录】本博客博文总目录-实时更新
开源Math.NET基础数学类库使用总目录:【目录】开源Math.NET基础数学类库使用总目录
Math.NET也包括了很多数论相关的函数,这些函数都是静态的,可以直接调用,如判断是否奇数,判断幂,平方数,最大公约数等等。同时部分函数已经作为扩展方法,可以直接在对象中使用。
如果本文资源或者显示有问题,请参考 本文原文地址:http://www.cnblogs.com/asxinyu/p/4301097.html
结果如下:
如果本文资源或者显示有问题,请参考 本文原文地址:http://www.cnblogs.com/asxinyu/p/4301097.html
开源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 <= exponent < 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 <= exponent < 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 && x == 1 && 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 && x == 1 && 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
相关文章推荐
- 【原创】开源Math.NET基础数学类库使用(09)相关数论函数使用
- 开源Math.NET基础数学类库使用(09)相关数论函数使用
- 【原创】开源Math.NET基础数学类库使用(11)C#计算相关系数
- 【原创】开源Math.NET基础数学类库使用(11)C#计算相关系数
- 【原创】开源Math.NET基础数学类库使用(08)C#进行数值积分
- 【原创】开源Math.NET基础数学类库使用(04)C#解析Matrix Marke数据格式
- 【原创】开源Math.NET基础数学类库使用(08)C#进行数值积分
- 【原创】开源Math.NET基础数学类库使用(06)直接求解线性方程组
- 【原创】开源Math.NET基础数学类库使用(03)C#解析Matlab的mat格式
- 【原创】开源Math.NET基础数学类库使用(12)C#随机数扩展方法
- 【原创】开源Math.NET基础数学类库使用(01)综合介绍
- 【原创】开源Math.NET基础数学类库使用(10)C#进行基本数据统计
- 【原创】开源Math.NET基础数学类库使用(03)C#解析Matlab的mat格式
- 【原创】开源Math.NET基础数学类库使用(02)矩阵向量计算
- 【原创】开源Math.NET基础数学类库使用(01)综合介绍
- 【原创】开源Math.NET基础数学类库使用(06)直接求解线性方程组
- 【原创】开源Math.NET基础数学类库使用(02)矩阵向量计算
- 【原创】开源Math.NET基础数学类库使用(10)C#进行基本数据统计
- 【原创】开源Math.NET基础数学类库使用(17)C#计算矩阵条件数
- 【原创】开源Math.NET基础数学类库使用(15)C#计算矩阵行列式