diff --git a/src/Examples/NumberTheory.cs b/src/Examples/NumberTheory.cs index 31d8efe0..cfddb2c5 100644 --- a/src/Examples/NumberTheory.cs +++ b/src/Examples/NumberTheory.cs @@ -25,7 +25,7 @@ // using System; -using MathNet.Numerics.NumberTheory; +using MathNet.Numerics; namespace Examples { @@ -63,17 +63,17 @@ namespace Examples { // 1. Find out whether the provided number is an even number Console.WriteLine(@"1. Find out whether the provided number is an even number"); - Console.WriteLine(@"{0} is even = {1}. {2} is even = {3}", 1, IntegerTheory.IsEven(1), 2, 2.IsEven()); + Console.WriteLine(@"{0} is even = {1}. {2} is even = {3}", 1, Euclid.IsEven(1), 2, 2.IsEven()); Console.WriteLine(); // 2. Find out whether the provided number is an odd number Console.WriteLine(@"2. Find out whether the provided number is an odd number"); - Console.WriteLine(@"{0} is odd = {1}. {2} is odd = {3}", 1, 1.IsOdd(), 2, IntegerTheory.IsOdd(2)); + Console.WriteLine(@"{0} is odd = {1}. {2} is odd = {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. Find out whether the provided number is a perfect power of two"); - Console.WriteLine(@"{0} is power of two = {1}. {2} is power of two = {3}", 5, 5.IsPowerOfTwo(), 16, IntegerTheory.IsPowerOfTwo(16)); + Console.WriteLine(@"{0} is power of two = {1}. {2} is power of two = {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 @@ -88,29 +88,29 @@ namespace Examples // 6. Find out whether the number is a perfect square Console.WriteLine(@"6. Find out whether the number is a perfect square"); - Console.WriteLine(@"{0} is perfect square = {1}. {2} is perfect square = {3}", 37, 37.IsPerfectSquare(), 81, IntegerTheory.IsPerfectSquare(81)); + Console.WriteLine(@"{0} is perfect square = {1}. {2} is perfect square = {3}", 37, 37.IsPerfectSquare(), 81, Euclid.IsPerfectSquare(81)); Console.WriteLine(); // 7. Compute the greatest common divisor of 32 and 36 Console.WriteLine(@"7. Returns the greatest common divisor of 32 and 36"); - Console.WriteLine(IntegerTheory.GreatestCommonDivisor(32, 36)); + Console.WriteLine(Euclid.GreatestCommonDivisor(32, 36)); Console.WriteLine(); // 8. Compute the greatest common divisor of 492, -984, 123, 246 Console.WriteLine(@"8. Returns the greatest common divisor of 492, -984, 123, 246"); - Console.WriteLine(IntegerTheory.GreatestCommonDivisor(492, -984, 123, 246)); + Console.WriteLine(Euclid.GreatestCommonDivisor(492, -984, 123, 246)); Console.WriteLine(); // 9. Compute the extended greatest common divisor "z", such that 45*x + 18*y = z Console.WriteLine(@"9. Compute the extended greatest common divisor Z, such that 45*x + 18*y = Z"); long x, y; - var z = IntegerTheory.ExtendedGreatestCommonDivisor(45, 18, out x, out y); + var z = Euclid.ExtendedGreatestCommonDivisor(45, 18, out x, out y); Console.WriteLine(@"z = {0}, x = {1}, y = {2}. 45*{1} + 18*{2} = {0}", z, x, y); Console.WriteLine(); // 10. Compute the least common multiple of 16 and 12 Console.WriteLine(@"10. Compute the least common multiple of 16 and 12"); - Console.WriteLine(IntegerTheory.LeastCommonMultiple(16, 12)); + Console.WriteLine(Euclid.LeastCommonMultiple(16, 12)); Console.WriteLine(); } } diff --git a/src/Examples/Signals/Chebyshev.cs b/src/Examples/Signals/Chebyshev.cs index 024c61ab..2fff7394 100644 --- a/src/Examples/Signals/Chebyshev.cs +++ b/src/Examples/Signals/Chebyshev.cs @@ -25,7 +25,7 @@ // using System; -using MathNet.Numerics.Signals; +using MathNet.Numerics; namespace Examples.SignalsExamples { @@ -62,7 +62,8 @@ namespace Examples.SignalsExamples public void Run() { // 1. Get 20 samples of f(x) = (x * x) / 2 at the roots of the Chebyshev polynomial of the first kind within interval [0, 10] - var result = SignalGenerator.ChebyshevNodesFirstKind(Function, 0, 10, 20); + var roots = FindRoots.ChebychevPolynomialFirstKind(20, 0, 10); + var result = Generate.Map(roots, Function); Console.WriteLine(@"1. Get 20 samples of f(x) = (x * x) / 2 at the roots of the Chebyshev polynomial of the first kind within interval [0, 10]"); for (var i = 0; i < result.Length; i++) { @@ -73,7 +74,8 @@ namespace Examples.SignalsExamples Console.WriteLine(); // 2. Get 20 samples of f(x) = (x * x) / 2 at the roots of the Chebyshev polynomial of the second kind within interval [0, 10] - result = SignalGenerator.ChebyshevNodesSecondKind(Function, 0, 10, 20); + roots = FindRoots.ChebychevPolynomialSecondKind(20, 0, 10); + result = Generate.Map(roots, Function); Console.WriteLine(@"2. Get 20 samples of f(x) = (x * x) / 2 at the roots of the Chebyshev polynomial of the second kind within interval [0, 10]"); for (var i = 0; i < result.Length; i++) { diff --git a/src/Numerics/Euclid.cs b/src/Numerics/Euclid.cs new file mode 100644 index 00000000..d7522132 --- /dev/null +++ b/src/Numerics/Euclid.cs @@ -0,0 +1,611 @@ +// +// Math.NET Numerics, part of the Math.NET Project +// http://numerics.mathdotnet.com +// http://github.com/mathnet/mathnet-numerics +// http://mathnetnumerics.codeplex.com +// +// Copyright (c) 2009-2013 Math.NET +// +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without +// restriction, including without limitation the rights to use, +// copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following +// conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// + +using System; +using System.Collections.Generic; + +#if !NOSYSNUMERICS +using System.Numerics; +#endif + +namespace MathNet.Numerics +{ + /// + /// Integer number theory functions. + /// + public static class Euclid + { + /// + /// Canonical Modulus. The result has the sign of the divisor. + /// + public static double Modulus(double dividend, double divisor) + { + return ((dividend%divisor) + divisor)%divisor; + } + + /// + /// Canonical Modulus. The result has the sign of the divisor. + /// + public static int Modulus(int dividend, int divisor) + { + return ((dividend%divisor) + divisor)%divisor; + } + + /// + /// Canonical Modulus. The result has the sign of the divisor. + /// + public static long Modulus(long dividend, long divisor) + { + return ((dividend%divisor) + divisor)%divisor; + } + + /// + /// Remainder (% operator). The result has the sign of the dividend. + /// + public static double Remainder(double dividend, double divisor) + { + return dividend%divisor; + } + + /// + /// Remainder (% operator). The result has the sign of the dividend. + /// + public static int Remainder(int dividend, int divisor) + { + return dividend%divisor; + } + + /// + /// Remainder (% operator). The result has the sign of the dividend. + /// + public static long Remainder(long dividend, long divisor) + { + return dividend%divisor; + } + + /// + /// Find out whether the provided 32 bit integer is an even number. + /// + /// The number to very whether it's even. + /// True if and only if it is an even number. + public static bool IsEven(this int number) + { + return (number & 0x1) == 0x0; + } + + /// + /// Find out whether the provided 64 bit integer is an even number. + /// + /// The number to very whether it's even. + /// True if and only if it is an even number. + public static bool IsEven(this long number) + { + return (number & 0x1) == 0x0; + } + + /// + /// Find out whether the provided 32 bit integer is an odd number. + /// + /// The number to very whether it's odd. + /// True if and only if it is an odd number. + public static bool IsOdd(this int number) + { + return (number & 0x1) == 0x1; + } + + /// + /// Find out whether the provided 64 bit integer is an odd number. + /// + /// The number to very whether it's odd. + /// True if and only if it is an odd number. + public static bool IsOdd(this long number) + { + return (number & 0x1) == 0x1; + } + + /// + /// Find out whether the provided 32 bit integer is a perfect power of two. + /// + /// The number to very whether it's a power of two. + /// True if and only if it is a power of two. + public static bool IsPowerOfTwo(this int number) + { + return number > 0 && (number & (number - 1)) == 0x0; + } + + /// + /// Find out whether the provided 64 bit integer is a perfect power of two. + /// + /// The number to very whether it's a power of two. + /// True if and only if it is a power of two. + public static bool IsPowerOfTwo(this long number) + { + return number > 0 && (number & (number - 1)) == 0x0; + } + + /// + /// Find out whether the provided 32 bit integer is a perfect square, i.e. a square of an integer. + /// + /// The number to very whether it's a perfect square. + /// True if and only if it is a perfect square. + 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; + } + + /// + /// Find out whether the provided 64 bit integer is a perfect square, i.e. a square of an integer. + /// + /// The number to very whether it's a perfect square. + /// True if and only if it is a perfect square. + 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; + } + + /// + /// Raises 2 to the provided integer exponent (0 <= exponent < 31). + /// + /// The exponent to raise 2 up to. + /// 2 ^ exponent. + /// + public static int PowerOfTwo(this int exponent) + { + if (exponent < 0 || exponent >= 31) + { + throw new ArgumentOutOfRangeException("exponent"); + } + + return 1 << exponent; + } + + /// + /// Raises 2 to the provided integer exponent (0 <= exponent < 63). + /// + /// The exponent to raise 2 up to. + /// 2 ^ exponent. + /// + public static long PowerOfTwo(this long exponent) + { + if (exponent < 0 || exponent >= 63) + { + throw new ArgumentOutOfRangeException("exponent"); + } + + return ((long)1) << (int)exponent; + } + + /// + /// Find the closest perfect power of two that is larger or equal to the provided + /// 32 bit integer. + /// + /// The number of which to find the closest upper power of two. + /// A power of two. + /// + 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; + } + + /// + /// Find the closest perfect power of two that is larger or equal to the provided + /// 64 bit integer. + /// + /// The number of which to find the closest upper power of two. + /// A power of two. + /// + 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; + } + + /// + /// Returns the greatest common divisor (gcd) of two integers using Euclid's algorithm. + /// + /// First Integer: a. + /// Second Integer: b. + /// Greatest common divisor gcd(a,b) + public static long GreatestCommonDivisor(long a, long b) + { + while (b != 0) + { + var remainder = a%b; + a = b; + b = remainder; + } + + return Math.Abs(a); + } + + /// + /// Returns the greatest common divisor (gcd) of a set of integers using Euclid's + /// algorithm. + /// + /// List of Integers. + /// Greatest common divisor gcd(list of integers) + public static long GreatestCommonDivisor(IList 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; + } + + /// + /// Returns the greatest common divisor (gcd) of a set of integers using Euclid's algorithm. + /// + /// List of Integers. + /// Greatest common divisor gcd(list of integers) + public static long GreatestCommonDivisor(params long[] integers) + { + return GreatestCommonDivisor((IList)integers); + } + + /// + /// Computes the extended greatest common divisor, such that a*x + b*y = gcd(a,b). + /// + /// First Integer: a. + /// Second Integer: b. + /// Resulting x, such that a*x + b*y = gcd(a,b). + /// Resulting y, such that a*x + b*y = gcd(a,b) + /// Greatest common divisor gcd(a,b) + /// + /// + /// long x,y,d; + /// d = Fn.GreatestCommonDivisor(45,18,out x, out y); + /// -> d == 9 && x == 1 && y == -2 + /// + /// The gcd of 45 and 18 is 9: 18 = 2*9, 45 = 5*9. 9 = 1*45 -2*18, therefore x=1 and y=-2. + /// + 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; + } + + /// + /// Returns the least common multiple (lcm) of two integers using Euclid's algorithm. + /// + /// First Integer: a. + /// Second Integer: b. + /// Least common multiple lcm(a,b) + public static long LeastCommonMultiple(long a, long b) + { + if ((a == 0) || (b == 0)) + { + return 0; + } + + return Math.Abs((a/GreatestCommonDivisor(a, b))*b); + } + + /// + /// Returns the least common multiple (lcm) of a set of integers using Euclid's algorithm. + /// + /// List of Integers. + /// Least common multiple lcm(list of integers) + public static long LeastCommonMultiple(IList 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; + } + + /// + /// Returns the least common multiple (lcm) of a set of integers using Euclid's algorithm. + /// + /// List of Integers. + /// Least common multiple lcm(list of integers) + public static long LeastCommonMultiple(params long[] integers) + { + return LeastCommonMultiple((IList)integers); + } + +#if !NOSYSNUMERICS + /// + /// Returns the greatest common divisor (gcd) of two big integers. + /// + /// First Integer: a. + /// Second Integer: b. + /// Greatest common divisor gcd(a,b) + public static BigInteger GreatestCommonDivisor(BigInteger a, BigInteger b) + { + return BigInteger.GreatestCommonDivisor(a, b); + } + + /// + /// Returns the greatest common divisor (gcd) of a set of big integers. + /// + /// List of Integers. + /// Greatest common divisor gcd(list of integers) + public static BigInteger GreatestCommonDivisor(IList 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; + } + + /// + /// Returns the greatest common divisor (gcd) of a set of big integers. + /// + /// List of Integers. + /// Greatest common divisor gcd(list of integers) + public static BigInteger GreatestCommonDivisor(params BigInteger[] integers) + { + return GreatestCommonDivisor((IList)integers); + } + + /// + /// Computes the extended greatest common divisor, such that a*x + b*y = gcd(a,b). + /// + /// First Integer: a. + /// Second Integer: b. + /// Resulting x, such that a*x + b*y = gcd(a,b). + /// Resulting y, such that a*x + b*y = gcd(a,b) + /// Greatest common divisor gcd(a,b) + /// + /// + /// long x,y,d; + /// d = Fn.GreatestCommonDivisor(45,18,out x, out y); + /// -> d == 9 && x == 1 && y == -2 + /// + /// The gcd of 45 and 18 is 9: 18 = 2*9, 45 = 5*9. 9 = 1*45 -2*18, therefore x=1 and y=-2. + /// + 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; + } + + /// + /// Returns the least common multiple (lcm) of two big integers. + /// + /// First Integer: a. + /// Second Integer: b. + /// Least common multiple lcm(a,b) + 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); + } + + /// + /// Returns the least common multiple (lcm) of a set of big integers. + /// + /// List of Integers. + /// Least common multiple lcm(list of integers) + public static BigInteger LeastCommonMultiple(IList 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; + } + + /// + /// Returns the least common multiple (lcm) of a set of big integers. + /// + /// List of Integers. + /// Least common multiple lcm(list of integers) + public static BigInteger LeastCommonMultiple(params BigInteger[] integers) + { + return LeastCommonMultiple((IList)integers); + } +#endif + } +} diff --git a/src/Numerics/Generate.cs b/src/Numerics/Generate.cs index 3665ba51..2ac28e88 100644 --- a/src/Numerics/Generate.cs +++ b/src/Numerics/Generate.cs @@ -357,5 +357,26 @@ namespace MathNet.Numerics { return Stable.Samples(MersenneTwister.Default, alpha, beta, scale, location); } + + /// + /// Generate sample by sampling a function at the provided points. + /// + public static TV[] Map(TU[] points, Func map) + { + var res = new TV[points.Length]; + for (int i = 0; i < points.Length; i++) + { + res[i] = map(points[i]); + } + return res; + } + + /// + /// Generate a sample sequence by sampling a function at the provided point sequence. + /// + public static IEnumerable MapSequence(IEnumerable points, Func map) + { + return points.Select(map); + } } } diff --git a/src/Numerics/IntegralTransforms/Algorithms/DiscreteFourierTransform.Bluestein.cs b/src/Numerics/IntegralTransforms/Algorithms/DiscreteFourierTransform.Bluestein.cs index 47c8829a..4ec01aa1 100644 --- a/src/Numerics/IntegralTransforms/Algorithms/DiscreteFourierTransform.Bluestein.cs +++ b/src/Numerics/IntegralTransforms/Algorithms/DiscreteFourierTransform.Bluestein.cs @@ -28,14 +28,14 @@ // OTHER DEALINGS IN THE SOFTWARE. // +using System; +using MathNet.Numerics.Threading; + namespace MathNet.Numerics.IntegralTransforms.Algorithms { - using System; - using NumberTheory; - using Threading; #if !NOSYSNUMERICS - using Complex = System.Numerics.Complex; + using System.Numerics; #endif /// diff --git a/src/Numerics/IntegralTransforms/Algorithms/DiscreteFourierTransform.RadixN.cs b/src/Numerics/IntegralTransforms/Algorithms/DiscreteFourierTransform.RadixN.cs index 97503331..f7069dfd 100644 --- a/src/Numerics/IntegralTransforms/Algorithms/DiscreteFourierTransform.RadixN.cs +++ b/src/Numerics/IntegralTransforms/Algorithms/DiscreteFourierTransform.RadixN.cs @@ -28,15 +28,15 @@ // OTHER DEALINGS IN THE SOFTWARE. // +using System; +using MathNet.Numerics.Properties; +using MathNet.Numerics.Threading; + namespace MathNet.Numerics.IntegralTransforms.Algorithms { - using System; - using NumberTheory; - using Properties; - using Threading; #if !NOSYSNUMERICS - using Complex = System.Numerics.Complex; + using System.Numerics; #endif /// diff --git a/src/Numerics/Integration/SimpsonRule.cs b/src/Numerics/Integration/SimpsonRule.cs index a1717184..e109cde4 100644 --- a/src/Numerics/Integration/SimpsonRule.cs +++ b/src/Numerics/Integration/SimpsonRule.cs @@ -29,7 +29,6 @@ // using System; -using MathNet.Numerics.NumberTheory; using MathNet.Numerics.Properties; namespace MathNet.Numerics.Integration diff --git a/src/Numerics/NumberTheory/IntegerTheory.Euclid.Big.cs b/src/Numerics/NumberTheory/IntegerTheory.Euclid.Big.cs deleted file mode 100644 index ffb0cf76..00000000 --- a/src/Numerics/NumberTheory/IntegerTheory.Euclid.Big.cs +++ /dev/null @@ -1,197 +0,0 @@ -// -// Math.NET Numerics, part of the Math.NET Project -// http://numerics.mathdotnet.com -// http://github.com/mathnet/mathnet-numerics -// http://mathnetnumerics.codeplex.com -// -// Copyright (c) 2009-2010 Math.NET -// -// Permission is hereby granted, free of charge, to any person -// obtaining a copy of this software and associated documentation -// files (the "Software"), to deal in the Software without -// restriction, including without limitation the rights to use, -// copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the -// Software is furnished to do so, subject to the following -// conditions: -// -// The above copyright notice and this permission notice shall be -// included in all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES -// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT -// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, -// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR -// OTHER DEALINGS IN THE SOFTWARE. -// - -#if !NOSYSNUMERICS -namespace MathNet.Numerics.NumberTheory -{ - using System; - using System.Collections.Generic; - using System.Numerics; - - /// - /// Number theory utility functions for integers. - /// - public static partial class IntegerTheory - { - /// - /// Returns the greatest common divisor (gcd) of two big integers. - /// - /// First Integer: a. - /// Second Integer: b. - /// Greatest common divisor gcd(a,b) - public static BigInteger GreatestCommonDivisor(BigInteger a, BigInteger b) - { - return BigInteger.GreatestCommonDivisor(a, b); - } - - /// - /// Returns the greatest common divisor (gcd) of a set of big integers. - /// - /// List of Integers. - /// Greatest common divisor gcd(list of integers) - public static BigInteger GreatestCommonDivisor(IList 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; - } - - /// - /// Returns the greatest common divisor (gcd) of a set of big integers. - /// - /// List of Integers. - /// Greatest common divisor gcd(list of integers) - public static BigInteger GreatestCommonDivisor(params BigInteger[] integers) - { - return GreatestCommonDivisor((IList)integers); - } - - /// - /// Computes the extended greatest common divisor, such that a*x + b*y = gcd(a,b). - /// - /// First Integer: a. - /// Second Integer: b. - /// Resulting x, such that a*x + b*y = gcd(a,b). - /// Resulting y, such that a*x + b*y = gcd(a,b) - /// Greatest common divisor gcd(a,b) - /// - /// - /// long x,y,d; - /// d = Fn.GreatestCommonDivisor(45,18,out x, out y); - /// -> d == 9 && x == 1 && y == -2 - /// - /// The gcd of 45 and 18 is 9: 18 = 2*9, 45 = 5*9. 9 = 1*45 -2*18, therefore x=1 and y=-2. - /// - 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; - } - - /// - /// Returns the least common multiple (lcm) of two big integers. - /// - /// First Integer: a. - /// Second Integer: b. - /// Least common multiple lcm(a,b) - 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); - } - - /// - /// Returns the least common multiple (lcm) of a set of big integers. - /// - /// List of Integers. - /// Least common multiple lcm(list of integers) - public static BigInteger LeastCommonMultiple(IList 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; - } - - /// - /// Returns the least common multiple (lcm) of a set of big integers. - /// - /// List of Integers. - /// Least common multiple lcm(list of integers) - public static BigInteger LeastCommonMultiple(params BigInteger[] integers) - { - return LeastCommonMultiple((IList)integers); - } - } -} -#endif diff --git a/src/Numerics/NumberTheory/IntegerTheory.Euclid.cs b/src/Numerics/NumberTheory/IntegerTheory.Euclid.cs deleted file mode 100644 index 5696f5a1..00000000 --- a/src/Numerics/NumberTheory/IntegerTheory.Euclid.cs +++ /dev/null @@ -1,203 +0,0 @@ -// -// Math.NET Numerics, part of the Math.NET Project -// http://numerics.mathdotnet.com -// http://github.com/mathnet/mathnet-numerics -// http://mathnetnumerics.codeplex.com -// Copyright (c) 2009-2010 Math.NET -// Permission is hereby granted, free of charge, to any person -// obtaining a copy of this software and associated documentation -// files (the "Software"), to deal in the Software without -// restriction, including without limitation the rights to use, -// copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the -// Software is furnished to do so, subject to the following -// conditions: -// The above copyright notice and this permission notice shall be -// included in all copies or substantial portions of the Software. -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES -// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT -// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, -// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR -// OTHER DEALINGS IN THE SOFTWARE. -// - -namespace MathNet.Numerics.NumberTheory -{ - using System; - using System.Collections.Generic; - - /// - /// Number theory utility functions for integers. - /// - public static partial class IntegerTheory - { - /// - /// Returns the greatest common divisor (gcd) of two integers using Euclid's algorithm. - /// - /// First Integer: a. - /// Second Integer: b. - /// Greatest common divisor gcd(a,b) - public static long GreatestCommonDivisor(long a, long b) - { - while (b != 0) - { - var remainder = a % b; - a = b; - b = remainder; - } - - return Math.Abs(a); - } - - /// - /// Returns the greatest common divisor (gcd) of a set of integers using Euclid's - /// algorithm. - /// - /// List of Integers. - /// Greatest common divisor gcd(list of integers) - public static long GreatestCommonDivisor(IList 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; - } - - /// - /// Returns the greatest common divisor (gcd) of a set of integers using Euclid's algorithm. - /// - /// List of Integers. - /// Greatest common divisor gcd(list of integers) - public static long GreatestCommonDivisor(params long[] integers) - { - return GreatestCommonDivisor((IList)integers); - } - - /// - /// Computes the extended greatest common divisor, such that a*x + b*y = gcd(a,b). - /// - /// First Integer: a. - /// Second Integer: b. - /// Resulting x, such that a*x + b*y = gcd(a,b). - /// Resulting y, such that a*x + b*y = gcd(a,b) - /// Greatest common divisor gcd(a,b) - /// - /// - /// long x,y,d; - /// d = Fn.GreatestCommonDivisor(45,18,out x, out y); - /// -> d == 9 && x == 1 && y == -2 - /// - /// The gcd of 45 and 18 is 9: 18 = 2*9, 45 = 5*9. 9 = 1*45 -2*18, therefore x=1 and y=-2. - /// - 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; - } - - /// - /// Returns the least common multiple (lcm) of two integers using Euclid's algorithm. - /// - /// First Integer: a. - /// Second Integer: b. - /// Least common multiple lcm(a,b) - public static long LeastCommonMultiple(long a, long b) - { - if ((a == 0) || (b == 0)) - { - return 0; - } - - return Math.Abs((a / GreatestCommonDivisor(a, b)) * b); - } - - /// - /// Returns the least common multiple (lcm) of a set of integers using Euclid's algorithm. - /// - /// List of Integers. - /// Least common multiple lcm(list of integers) - public static long LeastCommonMultiple(IList 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; - } - - /// - /// Returns the least common multiple (lcm) of a set of integers using Euclid's algorithm. - /// - /// List of Integers. - /// Least common multiple lcm(list of integers) - public static long LeastCommonMultiple(params long[] integers) - { - return LeastCommonMultiple((IList)integers); - } - } -} \ No newline at end of file diff --git a/src/Numerics/NumberTheory/IntegerTheory.cs b/src/Numerics/NumberTheory/IntegerTheory.cs deleted file mode 100644 index 993b7b26..00000000 --- a/src/Numerics/NumberTheory/IntegerTheory.cs +++ /dev/null @@ -1,245 +0,0 @@ -// -// Math.NET Numerics, part of the Math.NET Project -// http://numerics.mathdotnet.com -// http://github.com/mathnet/mathnet-numerics -// http://mathnetnumerics.codeplex.com -// -// Copyright (c) 2009-2010 Math.NET -// -// Permission is hereby granted, free of charge, to any person -// obtaining a copy of this software and associated documentation -// files (the "Software"), to deal in the Software without -// restriction, including without limitation the rights to use, -// copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the -// Software is furnished to do so, subject to the following -// conditions: -// -// The above copyright notice and this permission notice shall be -// included in all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES -// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT -// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, -// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR -// OTHER DEALINGS IN THE SOFTWARE. -// - -namespace MathNet.Numerics.NumberTheory -{ - using System; - - /// - /// Number theory utility functions for integers. - /// - public static partial class IntegerTheory - { - /// - /// Find out whether the provided 32 bit integer is an even number. - /// - /// The number to very whether it's even. - /// True if and only if it is an even number. - public static bool IsEven(this int number) - { - return (number & 0x1) == 0x0; - } - - /// - /// Find out whether the provided 64 bit integer is an even number. - /// - /// The number to very whether it's even. - /// True if and only if it is an even number. - public static bool IsEven(this long number) - { - return (number & 0x1) == 0x0; - } - - /// - /// Find out whether the provided 32 bit integer is an odd number. - /// - /// The number to very whether it's odd. - /// True if and only if it is an odd number. - public static bool IsOdd(this int number) - { - return (number & 0x1) == 0x1; - } - - /// - /// Find out whether the provided 64 bit integer is an odd number. - /// - /// The number to very whether it's odd. - /// True if and only if it is an odd number. - public static bool IsOdd(this long number) - { - return (number & 0x1) == 0x1; - } - - /// - /// Find out whether the provided 32 bit integer is a perfect power of two. - /// - /// The number to very whether it's a power of two. - /// True if and only if it is a power of two. - public static bool IsPowerOfTwo(this int number) - { - return number > 0 && (number & (number - 1)) == 0x0; - } - - /// - /// Find out whether the provided 64 bit integer is a perfect power of two. - /// - /// The number to very whether it's a power of two. - /// True if and only if it is a power of two. - public static bool IsPowerOfTwo(this long number) - { - return number > 0 && (number & (number - 1)) == 0x0; - } - - /// - /// Find the closest perfect power of two that is larger or equal to the provided - /// 32 bit integer. - /// - /// The number of which to find the closest upper power of two. - /// A power of two. - /// - 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; - } - - /// - /// Find the closest perfect power of two that is larger or equal to the provided - /// 64 bit integer. - /// - /// The number of which to find the closest upper power of two. - /// A power of two. - /// - 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; - } - - /// - /// Raises 2 to the provided integer exponent (0 <= exponent < 31). - /// - /// The exponent to raise 2 up to. - /// 2 ^ exponent. - /// - public static int PowerOfTwo(this int exponent) - { - if (exponent < 0 || exponent >= 31) - { - throw new ArgumentOutOfRangeException("exponent"); - } - - return 1 << exponent; - } - - /// - /// Raises 2 to the provided integer exponent (0 <= exponent < 63). - /// - /// The exponent to raise 2 up to. - /// 2 ^ exponent. - /// - public static long PowerOfTwo(this long exponent) - { - if (exponent < 0 || exponent >= 63) - { - throw new ArgumentOutOfRangeException("exponent"); - } - - return ((long)1) << (int)exponent; - } - - /// - /// Find out whether the provided 32 bit integer is a perfect square, i.e. a square of an integer. - /// - /// The number to very whether it's a perfect square. - /// True if and only if it is a perfect square. - 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; - } - - /// - /// Find out whether the provided 64 bit integer is a perfect square, i.e. a square of an integer. - /// - /// The number to very whether it's a perfect square. - /// True if and only if it is a perfect square. - 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; - } - } -} diff --git a/src/Numerics/Numerics.csproj b/src/Numerics/Numerics.csproj index 97f7ef12..47162196 100644 --- a/src/Numerics/Numerics.csproj +++ b/src/Numerics/Numerics.csproj @@ -87,6 +87,7 @@ + @@ -387,9 +388,6 @@ - - - diff --git a/src/UnitTests/EuclidTests/GcdRelatedTest.cs b/src/UnitTests/EuclidTests/GcdRelatedTest.cs new file mode 100644 index 00000000..f521081e --- /dev/null +++ b/src/UnitTests/EuclidTests/GcdRelatedTest.cs @@ -0,0 +1,201 @@ +// +// Math.NET Numerics, part of the Math.NET Project +// http://numerics.mathdotnet.com +// http://github.com/mathnet/mathnet-numerics +// http://mathnetnumerics.codeplex.com +// Copyright (c) 2009-2010 Math.NET +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without +// restriction, including without limitation the rights to use, +// copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following +// conditions: +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// + +using System; +using NUnit.Framework; + +namespace MathNet.Numerics.UnitTests.EuclidTests +{ + /// + /// GreatestCommonDivisor related test. + /// + [TestFixture, Category("Functions")] + public class GcdRelatedTest + { + /// + /// GreatestCommonDivisor handles normal input correctly. + /// + [Test] + public void GcdHandlesNormalInputCorrectly() + { + Assert.AreEqual(0, Euclid.GreatestCommonDivisor(0, 0), "Gcd(0,0)"); + Assert.AreEqual(6, Euclid.GreatestCommonDivisor(0, 6), "Gcd(0,6)"); + Assert.AreEqual(1, Euclid.GreatestCommonDivisor(7, 13), "Gcd(7,13)"); + Assert.AreEqual(7, Euclid.GreatestCommonDivisor(7, 14), "Gcd(7,14)"); + Assert.AreEqual(1, Euclid.GreatestCommonDivisor(7, 15), "Gcd(7,15)"); + Assert.AreEqual(3, Euclid.GreatestCommonDivisor(6, 15), "Gcd(6,15)"); + } + + /// + /// GreatestCommonDivisor handles negative input correctly. + /// + [Test] + public void GcdHandlesNegativeInputCorrectly() + { + Assert.AreEqual(5, Euclid.GreatestCommonDivisor(-5, 0), "Gcd(-5,0)"); + Assert.AreEqual(5, Euclid.GreatestCommonDivisor(0, -5), "Gcd(0, -5)"); + Assert.AreEqual(1, Euclid.GreatestCommonDivisor(-7, 15), "Gcd(-7,15)"); + Assert.AreEqual(1, Euclid.GreatestCommonDivisor(-7, -15), "Gcd(-7,-15)"); + } + + /// + /// GreatestCommonDivisor supports large input. + /// + [Test] + public void GcdSupportsLargeInput() + { + Assert.AreEqual(Int32.MaxValue, Euclid.GreatestCommonDivisor(0, Int32.MaxValue), "Gcd(0,Int32Max)"); + Assert.AreEqual(Int64.MaxValue, Euclid.GreatestCommonDivisor(0, Int64.MaxValue), "Gcd(0,Int64Max)"); + Assert.AreEqual(1, Euclid.GreatestCommonDivisor(Int32.MaxValue, Int64.MaxValue), "Gcd(Int32Max,Int64Max)"); + Assert.AreEqual(1 << 18, Euclid.GreatestCommonDivisor(1 << 18, 1 << 20), "Gcd(1>>18,1<<20)"); + } + + /// + /// Extended GreatestCommonDivisor handles normal input correctly + /// + [Test] + public void ExtendedGcdHandlesNormalInputCorrectly() + { + long x, y; + + Assert.AreEqual(3, Euclid.ExtendedGreatestCommonDivisor(6, 15, out x, out y), "Egcd(6,15)"); + Assert.AreEqual(3, (6*x) + (15*y), "Egcd(6,15) -> a*x+b*y"); + + Assert.AreEqual(3, Euclid.ExtendedGreatestCommonDivisor(-6, 15, out x, out y), "Egcd(-6,15)"); + Assert.AreEqual(3, (-6*x) + (15*y), "Egcd(-6,15) -> a*x+b*y"); + + Assert.AreEqual(3, Euclid.ExtendedGreatestCommonDivisor(-6, -15, out x, out y), "Egcd(-6,-15)"); + Assert.AreEqual(3, (-6*x) + (-15*y), "Egcd(-6,-15) -> a*x+b*y"); + } + + /// + /// List GreatestCommonDivisor handles normal input Correctly + /// + [Test] + public void ListGcdHandlesNormalInputCorrectly() + { + Assert.AreEqual(2, Euclid.GreatestCommonDivisor(-10, 6, -8), "Gcd(-10,6,-8)"); + Assert.AreEqual(1, Euclid.GreatestCommonDivisor(-10, 6, -8, 5, 9, 13), "Gcd(-10,6,-8,5,9,13)"); + Assert.AreEqual(5, Euclid.GreatestCommonDivisor(-10, 20, 120, 60, -15, 1000), "Gcd(-10,20,120,60,-15,1000)"); + Assert.AreEqual(3, Euclid.GreatestCommonDivisor(Int64.MaxValue - 1, Int64.MaxValue - 4, Int64.MaxValue - 7), "Gcd(Int64Max-1,Int64Max-4,Int64Max-7)"); + Assert.AreEqual(123, Euclid.GreatestCommonDivisor(492, -2*492, 492/4), "Gcd(492, -984, 123)"); + } + + /// + /// List GreatestCommonDivisor handles special input correctly. + /// + [Test] + public void ListGcdHandlesSpecialInputCorrectly() + { + Assert.AreEqual(0, Euclid.GreatestCommonDivisor(new long[0]), "Gcd()"); + Assert.AreEqual(100, Euclid.GreatestCommonDivisor(-100), "Gcd(-100)"); + } + + /// + /// List GreatestCommonDivisor checks for null all arguments. + /// + [Test] + public void ListGcdChecksForNullArguments() + { + Assert.Throws( + typeof (ArgumentNullException), + () => Euclid.GreatestCommonDivisor((long[])null)); + } + + /// + /// LeastCommonMultiple handles normal input correctly. + /// + [Test] + public void LcmHandlesNormalInputCorrectly() + { + Assert.AreEqual(10, Euclid.LeastCommonMultiple(10, 10), "Lcm(10,10)"); + + Assert.AreEqual(0, Euclid.LeastCommonMultiple(0, 10), "Lcm(0,10)"); + Assert.AreEqual(0, Euclid.LeastCommonMultiple(10, 0), "Lcm(10,0)"); + + Assert.AreEqual(77, Euclid.LeastCommonMultiple(11, 7), "Lcm(11,7)"); + Assert.AreEqual(33, Euclid.LeastCommonMultiple(11, 33), "Lcm(11,33)"); + Assert.AreEqual(374, Euclid.LeastCommonMultiple(11, 34), "Lcm(11,34)"); + } + + /// + /// LeastCommonMultiple handles negative input correctly. + /// + [Test] + public void LcmHandlesNegativeInputCorrectly() + { + Assert.AreEqual(352, Euclid.LeastCommonMultiple(11, -32), "Lcm(11,-32)"); + Assert.AreEqual(352, Euclid.LeastCommonMultiple(-11, 32), "Lcm(-11,32)"); + Assert.AreEqual(352, Euclid.LeastCommonMultiple(-11, -32), "Lcm(-11,-32)"); + } + + /// + /// LeastCommonMultiple supports large input. + /// + [Test] + public void LcmSupportsLargeInput() + { + Assert.AreEqual(Int32.MaxValue, Euclid.LeastCommonMultiple(Int32.MaxValue, Int32.MaxValue), "Lcm(Int32Max,Int32Max)"); + Assert.AreEqual(Int64.MaxValue, Euclid.LeastCommonMultiple(Int64.MaxValue, Int64.MaxValue), "Lcm(Int64Max,Int64Max)"); + Assert.AreEqual(Int64.MaxValue, Euclid.LeastCommonMultiple(-Int64.MaxValue, -Int64.MaxValue), "Lcm(-Int64Max,-Int64Max)"); + Assert.AreEqual(Int64.MaxValue, Euclid.LeastCommonMultiple(-Int64.MaxValue, Int64.MaxValue), "Lcm(-Int64Max,Int64Max)"); + } + + /// + /// List LeastCommonMultiple handles normal input correctly. + /// + [Test] + public void ListLcmHandlesNormalInputCorrectly() + { + Assert.AreEqual(120, Euclid.LeastCommonMultiple(-10, 6, -8), "Lcm(-10,6,-8)"); + Assert.AreEqual(4680, Euclid.LeastCommonMultiple(-10, 6, -8, 5, 9, 13), "Lcm(-10,6,-8,5,9,13)"); + Assert.AreEqual(3000, Euclid.LeastCommonMultiple(-10, 20, 120, 60, -15, 1000), "Lcm(-10,20,120,60,-15,1000)"); + Assert.AreEqual(984, Euclid.LeastCommonMultiple(492, -2*492, 492/4), "Lcm(492, -984, 123)"); + Assert.AreEqual(2016, Euclid.LeastCommonMultiple(32, 42, 36, 18), "Lcm(32,42,36,18)"); + } + + /// + /// List LeastCommonMultiple handles special input correctly. + /// + [Test] + public void ListLcmHandlesSpecialInputCorrectly() + { + Assert.AreEqual(1, Euclid.LeastCommonMultiple(new long[0]), "Lcm()"); + Assert.AreEqual(100, Euclid.LeastCommonMultiple(-100), "Lcm(-100)"); + } + + /// + /// List LeastCommonMultiple checks for null arguments. + /// + [Test] + public void ListLcmChecksForNullArguments() + { + Assert.Throws( + typeof (ArgumentNullException), + () => Euclid.LeastCommonMultiple((long[])null)); + } + } +} diff --git a/src/UnitTests/EuclidTests/GcdRelatedTestBigInteger.cs b/src/UnitTests/EuclidTests/GcdRelatedTestBigInteger.cs new file mode 100644 index 00000000..8f81b05e --- /dev/null +++ b/src/UnitTests/EuclidTests/GcdRelatedTestBigInteger.cs @@ -0,0 +1,222 @@ +// +// Math.NET Numerics, part of the Math.NET Project +// http://numerics.mathdotnet.com +// http://github.com/mathnet/mathnet-numerics +// http://mathnetnumerics.codeplex.com +// Copyright (c) 2009-2010 Math.NET +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without +// restriction, including without limitation the rights to use, +// copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following +// conditions: +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// + +#if !NOSYSNUMERICS + +using System; +using System.Numerics; +using NUnit.Framework; + +namespace MathNet.Numerics.UnitTests.EuclidTests +{ + /// + /// GreatestCommonDivisor related test for BigInteger. + /// + [TestFixture, Category("Functions")] + public class GcdRelatedTestBigInteger + { + /// + /// GreatestCommonDivisor handles normal input correctly. + /// + [Test] + public void GcdHandlesNormalInputCorrectly() + { + Assert.AreEqual((BigInteger)0, Euclid.GreatestCommonDivisor(BigInteger.Zero, BigInteger.Zero), "Gcd(0,0)"); + Assert.AreEqual((BigInteger)6, Euclid.GreatestCommonDivisor(BigInteger.Zero, 6), "Gcd(0,6)"); + Assert.AreEqual((BigInteger)1, Euclid.GreatestCommonDivisor((BigInteger)7, 13), "Gcd(7,13)"); + Assert.AreEqual((BigInteger)7, Euclid.GreatestCommonDivisor((BigInteger)7, 14), "Gcd(7,14)"); + Assert.AreEqual((BigInteger)1, Euclid.GreatestCommonDivisor((BigInteger)7, 15), "Gcd(7,15)"); + Assert.AreEqual((BigInteger)3, Euclid.GreatestCommonDivisor((BigInteger)6, 15), "Gcd(6,15)"); + } + + /// + /// GreatestCommonDivisor handles negative input correctly. + /// + [Test] + public void GcdHandlesNegativeInputCorrectly() + { + Assert.AreEqual((BigInteger)5, Euclid.GreatestCommonDivisor((BigInteger)(-5), 0), "Gcd(-5,0)"); + Assert.AreEqual((BigInteger)5, Euclid.GreatestCommonDivisor(BigInteger.Zero, -5), "Gcd(0, -5)"); + Assert.AreEqual((BigInteger)1, Euclid.GreatestCommonDivisor((BigInteger)(-7), 15), "Gcd(-7,15)"); + Assert.AreEqual((BigInteger)1, Euclid.GreatestCommonDivisor((BigInteger)(-7), -15), "Gcd(-7,-15)"); + } + + /// + /// GreatestCommonDivisor supports large input. + /// + [Test] + public void GcdSupportsLargeInput() + { + Assert.AreEqual((BigInteger)Int32.MaxValue, Euclid.GreatestCommonDivisor(BigInteger.Zero, Int32.MaxValue), "Gcd(0,Int32Max)"); + Assert.AreEqual((BigInteger)Int64.MaxValue, Euclid.GreatestCommonDivisor(BigInteger.Zero, Int64.MaxValue), "Gcd(0,Int64Max)"); + Assert.AreEqual((BigInteger)1, Euclid.GreatestCommonDivisor((BigInteger)Int32.MaxValue, Int64.MaxValue), "Gcd(Int32Max,Int64Max)"); + Assert.AreEqual((BigInteger)(1 << 18), Euclid.GreatestCommonDivisor((BigInteger)(1 << 18), 1 << 20), "Gcd(1>>18,1<<20)"); + Assert.AreEqual((BigInteger)(1 << 18), Euclid.GreatestCommonDivisor((BigInteger)(1 << 18), 1 << 20), "Gcd(1>>18,1<<20)"); +#if !PORTABLE + Assert.AreEqual((BigInteger)4569031055798, Euclid.GreatestCommonDivisor(BigInteger.Parse("7305316061155559483748611586449542122662"), BigInteger.Parse("57377277362010117405715236427413896")), "Gcd(large)"); +#endif + } + + /// + /// Extended GreatestCommonDivisor handles normal input correctly. + /// + [Test] + public void ExtendedGcdHandlesNormalInputCorrectly() + { + BigInteger x, y; + + Assert.AreEqual((BigInteger)3, Euclid.ExtendedGreatestCommonDivisor(6, 15, out x, out y), "Egcd(6,15)"); + Assert.AreEqual((BigInteger)3, (6*x) + (15*y), "Egcd(6,15) -> a*x+b*y"); + + Assert.AreEqual((BigInteger)3, Euclid.ExtendedGreatestCommonDivisor(-6, 15, out x, out y), "Egcd(-6,15)"); + Assert.AreEqual((BigInteger)3, (-6*x) + (15*y), "Egcd(-6,15) -> a*x+b*y"); + + Assert.AreEqual((BigInteger)3, Euclid.ExtendedGreatestCommonDivisor(-6, -15, out x, out y), "Egcd(-6,-15)"); + Assert.AreEqual((BigInteger)3, (-6*x) + (-15*y), "Egcd(-6,-15) -> a*x+b*y"); + +#if !PORTABLE + var a = BigInteger.Parse("7305316061155559483748611586449542122662"); + var b = BigInteger.Parse("57377277362010117405715236427413896"); + Assert.AreEqual((BigInteger)4569031055798, Euclid.ExtendedGreatestCommonDivisor(a, b, out x, out y), "Egcd(large)"); + Assert.AreEqual((BigInteger)4569031055798, (a*x) + (b*y), "Egcd(large) -> a*x+b*y"); + Assert.AreEqual((BigInteger)4569031055798, Euclid.ExtendedGreatestCommonDivisor(-a, b, out x, out y), "Egcd(-large)"); + Assert.AreEqual((BigInteger)4569031055798, (-a*x) + (b*y), "Egcd(-large) -> a*x+b*y"); +#endif + } + + /// + /// List GreatestCommonDivisor handles normal input Correctly + /// + [Test] + public void ListGcdHandlesNormalInputCorrectly() + { + Assert.AreEqual((BigInteger)2, Euclid.GreatestCommonDivisor((BigInteger)(-10), 6, -8), "Gcd(-10,6,-8)"); + Assert.AreEqual((BigInteger)1, Euclid.GreatestCommonDivisor((BigInteger)(-10), 6, -8, 5, 9, 13), "Gcd(-10,6,-8,5,9,13)"); + Assert.AreEqual((BigInteger)5, Euclid.GreatestCommonDivisor((BigInteger)(-10), 20, 120, 60, -15, 1000), "Gcd(-10,20,120,60,-15,1000)"); + Assert.AreEqual((BigInteger)3, Euclid.GreatestCommonDivisor((BigInteger)(Int64.MaxValue - 1), Int64.MaxValue - 4, Int64.MaxValue - 7), "Gcd(Int64Max-1,Int64Max-4,Int64Max-7)"); + Assert.AreEqual((BigInteger)123, Euclid.GreatestCommonDivisor((BigInteger)492, -2*492, 492/4), "Gcd(492, -984, 123)"); + } + + /// + /// List GreatestCommonDivisor handles special input correctly. + /// + [Test] + public void ListGcdHandlesSpecialInputCorrectly() + { + Assert.AreEqual((BigInteger)0, Euclid.GreatestCommonDivisor(new BigInteger[0]), "Gcd()"); + Assert.AreEqual((BigInteger)100, Euclid.GreatestCommonDivisor((BigInteger)(-100)), "Gcd(-100)"); + } + + /// + /// List GreatestCommonDivisor checks for null all arguments. + /// + [Test] + public void ListGcdChecksForNullArguments() + { + Assert.Throws( + typeof (ArgumentNullException), + () => Euclid.GreatestCommonDivisor((BigInteger[])null)); + } + + /// + /// LeastCommonMultiple handles normal input correctly. + /// + [Test] + public void LcmHandlesNormalInputCorrectly() + { + Assert.AreEqual((BigInteger)10, Euclid.LeastCommonMultiple((BigInteger)10, 10), "Lcm(10,10)"); + + Assert.AreEqual((BigInteger)0, Euclid.LeastCommonMultiple(BigInteger.Zero, 10), "Lcm(0,10)"); + Assert.AreEqual((BigInteger)0, Euclid.LeastCommonMultiple((BigInteger)10, 0), "Lcm(10,0)"); + + Assert.AreEqual((BigInteger)77, Euclid.LeastCommonMultiple((BigInteger)11, 7), "Lcm(11,7)"); + Assert.AreEqual((BigInteger)33, Euclid.LeastCommonMultiple((BigInteger)11, 33), "Lcm(11,33)"); + Assert.AreEqual((BigInteger)374, Euclid.LeastCommonMultiple((BigInteger)11, 34), "Lcm(11,34)"); + } + + /// + /// LeastCommonMultiple handles negative input correctly. + /// + [Test] + public void LcmHandlesNegativeInputCorrectly() + { + Assert.AreEqual((BigInteger)352, Euclid.LeastCommonMultiple((BigInteger)11, -32), "Lcm(11,-32)"); + Assert.AreEqual((BigInteger)352, Euclid.LeastCommonMultiple((BigInteger)(-11), 32), "Lcm(-11,32)"); + Assert.AreEqual((BigInteger)352, Euclid.LeastCommonMultiple((BigInteger)(-11), -32), "Lcm(-11,-32)"); + } + + /// + /// LeastCommonMultiple supports large input. + /// + [Test] + public void LcmSupportsLargeInput() + { + Assert.AreEqual((BigInteger)Int32.MaxValue, Euclid.LeastCommonMultiple((BigInteger)Int32.MaxValue, Int32.MaxValue), "Lcm(Int32Max,Int32Max)"); + Assert.AreEqual((BigInteger)Int64.MaxValue, Euclid.LeastCommonMultiple((BigInteger)Int64.MaxValue, Int64.MaxValue), "Lcm(Int64Max,Int64Max)"); + Assert.AreEqual((BigInteger)Int64.MaxValue, Euclid.LeastCommonMultiple((BigInteger)(-Int64.MaxValue), -Int64.MaxValue), "Lcm(-Int64Max,-Int64Max)"); + Assert.AreEqual((BigInteger)Int64.MaxValue, Euclid.LeastCommonMultiple((BigInteger)(-Int64.MaxValue), Int64.MaxValue), "Lcm(-Int64Max,Int64Max)"); +#if !PORTABLE + Assert.AreEqual(BigInteger.Parse("91739176367857263082719902034485224119528064014300888465614024"), Euclid.LeastCommonMultiple(BigInteger.Parse("7305316061155559483748611586449542122662"), BigInteger.Parse("57377277362010117405715236427413896")), "Lcm(large)"); +#endif + } + + /// + /// List LeastCommonMultiple handles normal input correctly. + /// + [Test] + public void ListLcmHandlesNormalInputCorrectly() + { + Assert.AreEqual((BigInteger)120, Euclid.LeastCommonMultiple((BigInteger)(-10), 6, -8), "Lcm(-10,6,-8)"); + Assert.AreEqual((BigInteger)4680, Euclid.LeastCommonMultiple((BigInteger)(-10), 6, -8, 5, 9, 13), "Lcm(-10,6,-8,5,9,13)"); + Assert.AreEqual((BigInteger)3000, Euclid.LeastCommonMultiple((BigInteger)(-10), 20, 120, 60, -15, 1000), "Lcm(-10,20,120,60,-15,1000)"); + Assert.AreEqual((BigInteger)984, Euclid.LeastCommonMultiple((BigInteger)492, -2*492, 492/4), "Lcm(492, -984, 123)"); + Assert.AreEqual((BigInteger)2016, Euclid.LeastCommonMultiple((BigInteger)32, 42, 36, 18), "Lcm(32,42,36,18)"); + } + + /// + /// List LeastCommonMultiple handles special input correctly. + /// + [Test] + public void ListLcmHandlesSpecialInputCorrectly() + { + Assert.AreEqual((BigInteger)1, Euclid.LeastCommonMultiple(new BigInteger[0]), "Lcm()"); + Assert.AreEqual((BigInteger)100, Euclid.LeastCommonMultiple((BigInteger)(-100)), "Lcm(-100)"); + } + + /// + /// List LeastCommonMultiple checks for null arguments. + /// + [Test] + public void ListLcmChecksForNullArguments() + { + Assert.Throws( + typeof (ArgumentNullException), + () => Euclid.LeastCommonMultiple((BigInteger[])null)); + } + } +} + +#endif diff --git a/src/UnitTests/NumberTheoryTests/IntegerTheoryTest.cs b/src/UnitTests/EuclidTests/IntegerTheoryTest.cs similarity index 74% rename from src/UnitTests/NumberTheoryTests/IntegerTheoryTest.cs rename to src/UnitTests/EuclidTests/IntegerTheoryTest.cs index e4535ef7..d8e2007a 100644 --- a/src/UnitTests/NumberTheoryTests/IntegerTheoryTest.cs +++ b/src/UnitTests/EuclidTests/IntegerTheoryTest.cs @@ -24,18 +24,112 @@ // OTHER DEALINGS IN THE SOFTWARE. // -namespace MathNet.Numerics.UnitTests.NumberTheoryTests -{ - using System; - using NumberTheory; - using NUnit.Framework; +using System; +using NUnit.Framework; +namespace MathNet.Numerics.UnitTests.EuclidTests +{ /// /// Integer theory tests. /// [TestFixture, Category("Functions")] public class IntegerTheoryTest { + [Test] + public void TestModulus() + { + Assert.That(Euclid.Modulus(0, 3), Is.EqualTo(0)); + Assert.That(Euclid.Modulus(2, 3), Is.EqualTo(2)); + Assert.That(Euclid.Modulus(3, 3), Is.EqualTo(0)); + Assert.That(Euclid.Modulus(4, 3), Is.EqualTo(1)); + Assert.That(Euclid.Modulus(6, 3), Is.EqualTo(0)); + Assert.That(Euclid.Modulus(-1, 3), Is.EqualTo(2)); + Assert.That(Euclid.Modulus(-2, 3), Is.EqualTo(1)); + Assert.That(Euclid.Modulus(-3, 3), Is.EqualTo(0)); + Assert.That(Euclid.Modulus(-4, 3), Is.EqualTo(2)); + + Assert.That(Euclid.Modulus(0, -3), Is.EqualTo(0)); + Assert.That(Euclid.Modulus(2, -3), Is.EqualTo(-1)); + Assert.That(Euclid.Modulus(3, -3), Is.EqualTo(0)); + Assert.That(Euclid.Modulus(4, -3), Is.EqualTo(-2)); + Assert.That(Euclid.Modulus(6, -3), Is.EqualTo(0)); + Assert.That(Euclid.Modulus(-1, -3), Is.EqualTo(-1)); + Assert.That(Euclid.Modulus(-2, -3), Is.EqualTo(-2)); + Assert.That(Euclid.Modulus(-3, -3), Is.EqualTo(0)); + Assert.That(Euclid.Modulus(-4, -3), Is.EqualTo(-1)); + } + + [Test] + public void TestModulusFloatingPoint() + { + Assert.That(Euclid.Modulus(0.2, 3), Is.EqualTo(0.2).Within(1e-12)); + Assert.That(Euclid.Modulus(2.2, 3), Is.EqualTo(2.2).Within(1e-12)); + Assert.That(Euclid.Modulus(3.2, 3), Is.EqualTo(0.2).Within(1e-12)); + Assert.That(Euclid.Modulus(4.2, 3), Is.EqualTo(1.2).Within(1e-12)); + Assert.That(Euclid.Modulus(6.2, 3), Is.EqualTo(0.2).Within(1e-12)); + Assert.That(Euclid.Modulus(-1.2, 3), Is.EqualTo(1.8).Within(1e-12)); + Assert.That(Euclid.Modulus(-2.2, 3), Is.EqualTo(0.8).Within(1e-12)); + Assert.That(Euclid.Modulus(-3.2, 3), Is.EqualTo(2.8).Within(1e-12)); + Assert.That(Euclid.Modulus(-4.2, 3), Is.EqualTo(1.8).Within(1e-12)); + + Assert.That(Euclid.Modulus(0.2, -3), Is.EqualTo(-2.8).Within(1e-12)); + Assert.That(Euclid.Modulus(2.2, -3), Is.EqualTo(-0.8).Within(1e-12)); + Assert.That(Euclid.Modulus(3.2, -3), Is.EqualTo(-2.8).Within(1e-12)); + Assert.That(Euclid.Modulus(4.2, -3), Is.EqualTo(-1.8).Within(1e-12)); + Assert.That(Euclid.Modulus(6.2, -3), Is.EqualTo(-2.8).Within(1e-12)); + Assert.That(Euclid.Modulus(-1.2, -3), Is.EqualTo(-1.2).Within(1e-12)); + Assert.That(Euclid.Modulus(-2.2, -3), Is.EqualTo(-2.2).Within(1e-12)); + Assert.That(Euclid.Modulus(-3.2, -3), Is.EqualTo(-0.2).Within(1e-12)); + Assert.That(Euclid.Modulus(-4.2, -3), Is.EqualTo(-1.2).Within(1e-12)); + } + + [Test] + public void TestRemainder() + { + Assert.That(Euclid.Remainder(0, 3), Is.EqualTo(0)); + Assert.That(Euclid.Remainder(2, 3), Is.EqualTo(2)); + Assert.That(Euclid.Remainder(3, 3), Is.EqualTo(0)); + Assert.That(Euclid.Remainder(4, 3), Is.EqualTo(1)); + Assert.That(Euclid.Remainder(6, 3), Is.EqualTo(0)); + Assert.That(Euclid.Remainder(-1, 3), Is.EqualTo(-1)); + Assert.That(Euclid.Remainder(-2, 3), Is.EqualTo(-2)); + Assert.That(Euclid.Remainder(-3, 3), Is.EqualTo(0)); + Assert.That(Euclid.Remainder(-4, 3), Is.EqualTo(-1)); + + Assert.That(Euclid.Remainder(0, -3), Is.EqualTo(0)); + Assert.That(Euclid.Remainder(2, -3), Is.EqualTo(2)); + Assert.That(Euclid.Remainder(3, -3), Is.EqualTo(0)); + Assert.That(Euclid.Remainder(4, -3), Is.EqualTo(1)); + Assert.That(Euclid.Remainder(6, -3), Is.EqualTo(0)); + Assert.That(Euclid.Remainder(-1, -3), Is.EqualTo(-1)); + Assert.That(Euclid.Remainder(-2, -3), Is.EqualTo(-2)); + Assert.That(Euclid.Remainder(-3, -3), Is.EqualTo(0)); + Assert.That(Euclid.Remainder(-4, -3), Is.EqualTo(-1)); + } + [Test] + public void TestRemainderFloatingPoint() + { + Assert.That(Euclid.Remainder(0.2, 3), Is.EqualTo(0.2).Within(1e-12)); + Assert.That(Euclid.Remainder(2.2, 3), Is.EqualTo(2.2).Within(1e-12)); + Assert.That(Euclid.Remainder(3.2, 3), Is.EqualTo(0.2).Within(1e-12)); + Assert.That(Euclid.Remainder(4.2, 3), Is.EqualTo(1.2).Within(1e-12)); + Assert.That(Euclid.Remainder(6.2, 3), Is.EqualTo(0.2).Within(1e-12)); + Assert.That(Euclid.Remainder(-1.2, 3), Is.EqualTo(-1.2).Within(1e-12)); + Assert.That(Euclid.Remainder(-2.2, 3), Is.EqualTo(-2.2).Within(1e-12)); + Assert.That(Euclid.Remainder(-3.2, 3), Is.EqualTo(-0.2).Within(1e-12)); + Assert.That(Euclid.Remainder(-4.2, 3), Is.EqualTo(-1.2).Within(1e-12)); + + Assert.That(Euclid.Remainder(0.2, -3), Is.EqualTo(0.2).Within(1e-12)); + Assert.That(Euclid.Remainder(2.2, -3), Is.EqualTo(2.2).Within(1e-12)); + Assert.That(Euclid.Remainder(3.2, -3), Is.EqualTo(0.2).Within(1e-12)); + Assert.That(Euclid.Remainder(4.2, -3), Is.EqualTo(1.2).Within(1e-12)); + Assert.That(Euclid.Remainder(6.2, -3), Is.EqualTo(0.2).Within(1e-12)); + Assert.That(Euclid.Remainder(-1.2, -3), Is.EqualTo(-1.2).Within(1e-12)); + Assert.That(Euclid.Remainder(-2.2, -3), Is.EqualTo(-2.2).Within(1e-12)); + Assert.That(Euclid.Remainder(-3.2, -3), Is.EqualTo(-0.2).Within(1e-12)); + Assert.That(Euclid.Remainder(-4.2, -3), Is.EqualTo(-1.2).Within(1e-12)); + } + /// /// Test even/odd int32. /// diff --git a/src/UnitTests/NumberTheoryTests/GcdRelatedTest.cs b/src/UnitTests/NumberTheoryTests/GcdRelatedTest.cs deleted file mode 100644 index 40f01d12..00000000 --- a/src/UnitTests/NumberTheoryTests/GcdRelatedTest.cs +++ /dev/null @@ -1,202 +0,0 @@ -// -// Math.NET Numerics, part of the Math.NET Project -// http://numerics.mathdotnet.com -// http://github.com/mathnet/mathnet-numerics -// http://mathnetnumerics.codeplex.com -// Copyright (c) 2009-2010 Math.NET -// Permission is hereby granted, free of charge, to any person -// obtaining a copy of this software and associated documentation -// files (the "Software"), to deal in the Software without -// restriction, including without limitation the rights to use, -// copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the -// Software is furnished to do so, subject to the following -// conditions: -// The above copyright notice and this permission notice shall be -// included in all copies or substantial portions of the Software. -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES -// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT -// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, -// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR -// OTHER DEALINGS IN THE SOFTWARE. -// - -namespace MathNet.Numerics.UnitTests.NumberTheoryTests -{ - using System; - using NumberTheory; - using NUnit.Framework; - - /// - /// GreatestCommonDivisor related test. - /// - [TestFixture, Category("Functions")] - public class GcdRelatedTest - { - /// - /// GreatestCommonDivisor handles normal input correctly. - /// - [Test] - public void GcdHandlesNormalInputCorrectly() - { - Assert.AreEqual(0, IntegerTheory.GreatestCommonDivisor(0, 0), "Gcd(0,0)"); - Assert.AreEqual(6, IntegerTheory.GreatestCommonDivisor(0, 6), "Gcd(0,6)"); - Assert.AreEqual(1, IntegerTheory.GreatestCommonDivisor(7, 13), "Gcd(7,13)"); - Assert.AreEqual(7, IntegerTheory.GreatestCommonDivisor(7, 14), "Gcd(7,14)"); - Assert.AreEqual(1, IntegerTheory.GreatestCommonDivisor(7, 15), "Gcd(7,15)"); - Assert.AreEqual(3, IntegerTheory.GreatestCommonDivisor(6, 15), "Gcd(6,15)"); - } - - /// - /// GreatestCommonDivisor handles negative input correctly. - /// - [Test] - public void GcdHandlesNegativeInputCorrectly() - { - Assert.AreEqual(5, IntegerTheory.GreatestCommonDivisor(-5, 0), "Gcd(-5,0)"); - Assert.AreEqual(5, IntegerTheory.GreatestCommonDivisor(0, -5), "Gcd(0, -5)"); - Assert.AreEqual(1, IntegerTheory.GreatestCommonDivisor(-7, 15), "Gcd(-7,15)"); - Assert.AreEqual(1, IntegerTheory.GreatestCommonDivisor(-7, -15), "Gcd(-7,-15)"); - } - - /// - /// GreatestCommonDivisor supports large input. - /// - [Test] - public void GcdSupportsLargeInput() - { - Assert.AreEqual(Int32.MaxValue, IntegerTheory.GreatestCommonDivisor(0, Int32.MaxValue), "Gcd(0,Int32Max)"); - Assert.AreEqual(Int64.MaxValue, IntegerTheory.GreatestCommonDivisor(0, Int64.MaxValue), "Gcd(0,Int64Max)"); - Assert.AreEqual(1, IntegerTheory.GreatestCommonDivisor(Int32.MaxValue, Int64.MaxValue), "Gcd(Int32Max,Int64Max)"); - Assert.AreEqual(1 << 18, IntegerTheory.GreatestCommonDivisor(1 << 18, 1 << 20), "Gcd(1>>18,1<<20)"); - } - - /// - /// Extended GreatestCommonDivisor handles normal input correctly - /// - [Test] - public void ExtendedGcdHandlesNormalInputCorrectly() - { - long x, y; - - Assert.AreEqual(3, IntegerTheory.ExtendedGreatestCommonDivisor(6, 15, out x, out y), "Egcd(6,15)"); - Assert.AreEqual(3, (6 * x) + (15 * y), "Egcd(6,15) -> a*x+b*y"); - - Assert.AreEqual(3, IntegerTheory.ExtendedGreatestCommonDivisor(-6, 15, out x, out y), "Egcd(-6,15)"); - Assert.AreEqual(3, (-6 * x) + (15 * y), "Egcd(-6,15) -> a*x+b*y"); - - Assert.AreEqual(3, IntegerTheory.ExtendedGreatestCommonDivisor(-6, -15, out x, out y), "Egcd(-6,-15)"); - Assert.AreEqual(3, (-6 * x) + (-15 * y), "Egcd(-6,-15) -> a*x+b*y"); - } - - /// - /// List GreatestCommonDivisor handles normal input Correctly - /// - [Test] - public void ListGcdHandlesNormalInputCorrectly() - { - Assert.AreEqual(2, IntegerTheory.GreatestCommonDivisor(-10, 6, -8), "Gcd(-10,6,-8)"); - Assert.AreEqual(1, IntegerTheory.GreatestCommonDivisor(-10, 6, -8, 5, 9, 13), "Gcd(-10,6,-8,5,9,13)"); - Assert.AreEqual(5, IntegerTheory.GreatestCommonDivisor(-10, 20, 120, 60, -15, 1000), "Gcd(-10,20,120,60,-15,1000)"); - Assert.AreEqual(3, IntegerTheory.GreatestCommonDivisor(Int64.MaxValue - 1, Int64.MaxValue - 4, Int64.MaxValue - 7), "Gcd(Int64Max-1,Int64Max-4,Int64Max-7)"); - Assert.AreEqual(123, IntegerTheory.GreatestCommonDivisor(492, -2 * 492, 492 / 4), "Gcd(492, -984, 123)"); - } - - /// - /// List GreatestCommonDivisor handles special input correctly. - /// - [Test] - public void ListGcdHandlesSpecialInputCorrectly() - { - Assert.AreEqual(0, IntegerTheory.GreatestCommonDivisor(new long[0]), "Gcd()"); - Assert.AreEqual(100, IntegerTheory.GreatestCommonDivisor(-100), "Gcd(-100)"); - } - - /// - /// List GreatestCommonDivisor checks for null all arguments. - /// - [Test] - public void ListGcdChecksForNullArguments() - { - Assert.Throws( - typeof(ArgumentNullException), - () => IntegerTheory.GreatestCommonDivisor((long[])null)); - } - - /// - /// LeastCommonMultiple handles normal input correctly. - /// - [Test] - public void LcmHandlesNormalInputCorrectly() - { - Assert.AreEqual(10, IntegerTheory.LeastCommonMultiple(10, 10), "Lcm(10,10)"); - - Assert.AreEqual(0, IntegerTheory.LeastCommonMultiple(0, 10), "Lcm(0,10)"); - Assert.AreEqual(0, IntegerTheory.LeastCommonMultiple(10, 0), "Lcm(10,0)"); - - Assert.AreEqual(77, IntegerTheory.LeastCommonMultiple(11, 7), "Lcm(11,7)"); - Assert.AreEqual(33, IntegerTheory.LeastCommonMultiple(11, 33), "Lcm(11,33)"); - Assert.AreEqual(374, IntegerTheory.LeastCommonMultiple(11, 34), "Lcm(11,34)"); - } - - /// - /// LeastCommonMultiple handles negative input correctly. - /// - [Test] - public void LcmHandlesNegativeInputCorrectly() - { - Assert.AreEqual(352, IntegerTheory.LeastCommonMultiple(11, -32), "Lcm(11,-32)"); - Assert.AreEqual(352, IntegerTheory.LeastCommonMultiple(-11, 32), "Lcm(-11,32)"); - Assert.AreEqual(352, IntegerTheory.LeastCommonMultiple(-11, -32), "Lcm(-11,-32)"); - } - - /// - /// LeastCommonMultiple supports large input. - /// - [Test] - public void LcmSupportsLargeInput() - { - Assert.AreEqual(Int32.MaxValue, IntegerTheory.LeastCommonMultiple(Int32.MaxValue, Int32.MaxValue), "Lcm(Int32Max,Int32Max)"); - Assert.AreEqual(Int64.MaxValue, IntegerTheory.LeastCommonMultiple(Int64.MaxValue, Int64.MaxValue), "Lcm(Int64Max,Int64Max)"); - Assert.AreEqual(Int64.MaxValue, IntegerTheory.LeastCommonMultiple(-Int64.MaxValue, -Int64.MaxValue), "Lcm(-Int64Max,-Int64Max)"); - Assert.AreEqual(Int64.MaxValue, IntegerTheory.LeastCommonMultiple(-Int64.MaxValue, Int64.MaxValue), "Lcm(-Int64Max,Int64Max)"); - } - - /// - /// List LeastCommonMultiple handles normal input correctly. - /// - [Test] - public void ListLcmHandlesNormalInputCorrectly() - { - Assert.AreEqual(120, IntegerTheory.LeastCommonMultiple(-10, 6, -8), "Lcm(-10,6,-8)"); - Assert.AreEqual(4680, IntegerTheory.LeastCommonMultiple(-10, 6, -8, 5, 9, 13), "Lcm(-10,6,-8,5,9,13)"); - Assert.AreEqual(3000, IntegerTheory.LeastCommonMultiple(-10, 20, 120, 60, -15, 1000), "Lcm(-10,20,120,60,-15,1000)"); - Assert.AreEqual(984, IntegerTheory.LeastCommonMultiple(492, -2 * 492, 492 / 4), "Lcm(492, -984, 123)"); - Assert.AreEqual(2016, IntegerTheory.LeastCommonMultiple(32, 42, 36, 18), "Lcm(32,42,36,18)"); - } - - /// - /// List LeastCommonMultiple handles special input correctly. - /// - [Test] - public void ListLcmHandlesSpecialInputCorrectly() - { - Assert.AreEqual(1, IntegerTheory.LeastCommonMultiple(new long[0]), "Lcm()"); - Assert.AreEqual(100, IntegerTheory.LeastCommonMultiple(-100), "Lcm(-100)"); - } - - /// - /// List LeastCommonMultiple checks for null arguments. - /// - [Test] - public void ListLcmChecksForNullArguments() - { - Assert.Throws( - typeof(ArgumentNullException), - () => IntegerTheory.LeastCommonMultiple((long[])null)); - } - } -} diff --git a/src/UnitTests/NumberTheoryTests/GcdRelatedTestBigInteger.cs b/src/UnitTests/NumberTheoryTests/GcdRelatedTestBigInteger.cs deleted file mode 100644 index 60a9f9cd..00000000 --- a/src/UnitTests/NumberTheoryTests/GcdRelatedTestBigInteger.cs +++ /dev/null @@ -1,222 +0,0 @@ -// -// Math.NET Numerics, part of the Math.NET Project -// http://numerics.mathdotnet.com -// http://github.com/mathnet/mathnet-numerics -// http://mathnetnumerics.codeplex.com -// Copyright (c) 2009-2010 Math.NET -// Permission is hereby granted, free of charge, to any person -// obtaining a copy of this software and associated documentation -// files (the "Software"), to deal in the Software without -// restriction, including without limitation the rights to use, -// copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the -// Software is furnished to do so, subject to the following -// conditions: -// The above copyright notice and this permission notice shall be -// included in all copies or substantial portions of the Software. -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES -// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT -// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, -// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR -// OTHER DEALINGS IN THE SOFTWARE. -// - -#if !NOSYSNUMERICS - -using System; -using System.Numerics; -using MathNet.Numerics.NumberTheory; -using NUnit.Framework; - -namespace MathNet.Numerics.UnitTests.NumberTheoryTests -{ - /// - /// GreatestCommonDivisor related test for BigInteger. - /// - [TestFixture, Category("Functions")] - public class GcdRelatedTestBigInteger - { - /// - /// GreatestCommonDivisor handles normal input correctly. - /// - [Test] - public void GcdHandlesNormalInputCorrectly() - { - Assert.AreEqual((BigInteger)0, IntegerTheory.GreatestCommonDivisor(BigInteger.Zero, BigInteger.Zero), "Gcd(0,0)"); - Assert.AreEqual((BigInteger)6, IntegerTheory.GreatestCommonDivisor(BigInteger.Zero, 6), "Gcd(0,6)"); - Assert.AreEqual((BigInteger)1, IntegerTheory.GreatestCommonDivisor((BigInteger)7, 13), "Gcd(7,13)"); - Assert.AreEqual((BigInteger)7, IntegerTheory.GreatestCommonDivisor((BigInteger)7, 14), "Gcd(7,14)"); - Assert.AreEqual((BigInteger)1, IntegerTheory.GreatestCommonDivisor((BigInteger)7, 15), "Gcd(7,15)"); - Assert.AreEqual((BigInteger)3, IntegerTheory.GreatestCommonDivisor((BigInteger)6, 15), "Gcd(6,15)"); - } - - /// - /// GreatestCommonDivisor handles negative input correctly. - /// - [Test] - public void GcdHandlesNegativeInputCorrectly() - { - Assert.AreEqual((BigInteger)5, IntegerTheory.GreatestCommonDivisor((BigInteger)(-5), 0), "Gcd(-5,0)"); - Assert.AreEqual((BigInteger)5, IntegerTheory.GreatestCommonDivisor(BigInteger.Zero, -5), "Gcd(0, -5)"); - Assert.AreEqual((BigInteger)1, IntegerTheory.GreatestCommonDivisor((BigInteger)(-7), 15), "Gcd(-7,15)"); - Assert.AreEqual((BigInteger)1, IntegerTheory.GreatestCommonDivisor((BigInteger)(-7), -15), "Gcd(-7,-15)"); - } - - /// - /// GreatestCommonDivisor supports large input. - /// - [Test] - public void GcdSupportsLargeInput() - { - Assert.AreEqual((BigInteger)Int32.MaxValue, IntegerTheory.GreatestCommonDivisor(BigInteger.Zero, Int32.MaxValue), "Gcd(0,Int32Max)"); - Assert.AreEqual((BigInteger)Int64.MaxValue, IntegerTheory.GreatestCommonDivisor(BigInteger.Zero, Int64.MaxValue), "Gcd(0,Int64Max)"); - Assert.AreEqual((BigInteger)1, IntegerTheory.GreatestCommonDivisor((BigInteger)Int32.MaxValue, Int64.MaxValue), "Gcd(Int32Max,Int64Max)"); - Assert.AreEqual((BigInteger)(1 << 18), IntegerTheory.GreatestCommonDivisor((BigInteger)(1 << 18), 1 << 20), "Gcd(1>>18,1<<20)"); - Assert.AreEqual((BigInteger)(1 << 18), IntegerTheory.GreatestCommonDivisor((BigInteger)(1 << 18), 1 << 20), "Gcd(1>>18,1<<20)"); -#if !PORTABLE - Assert.AreEqual((BigInteger)4569031055798, IntegerTheory.GreatestCommonDivisor(BigInteger.Parse("7305316061155559483748611586449542122662"), BigInteger.Parse("57377277362010117405715236427413896")), "Gcd(large)"); -#endif - } - - /// - /// Extended GreatestCommonDivisor handles normal input correctly. - /// - [Test] - public void ExtendedGcdHandlesNormalInputCorrectly() - { - BigInteger x, y; - - Assert.AreEqual((BigInteger)3, IntegerTheory.ExtendedGreatestCommonDivisor(6, 15, out x, out y), "Egcd(6,15)"); - Assert.AreEqual((BigInteger)3, (6 * x) + (15 * y), "Egcd(6,15) -> a*x+b*y"); - - Assert.AreEqual((BigInteger)3, IntegerTheory.ExtendedGreatestCommonDivisor(-6, 15, out x, out y), "Egcd(-6,15)"); - Assert.AreEqual((BigInteger)3, (-6 * x) + (15 * y), "Egcd(-6,15) -> a*x+b*y"); - - Assert.AreEqual((BigInteger)3, IntegerTheory.ExtendedGreatestCommonDivisor(-6, -15, out x, out y), "Egcd(-6,-15)"); - Assert.AreEqual((BigInteger)3, (-6 * x) + (-15 * y), "Egcd(-6,-15) -> a*x+b*y"); - -#if !PORTABLE - var a = BigInteger.Parse("7305316061155559483748611586449542122662"); - var b = BigInteger.Parse("57377277362010117405715236427413896"); - Assert.AreEqual((BigInteger)4569031055798, IntegerTheory.ExtendedGreatestCommonDivisor(a, b, out x, out y), "Egcd(large)"); - Assert.AreEqual((BigInteger)4569031055798, (a * x) + (b * y), "Egcd(large) -> a*x+b*y"); - Assert.AreEqual((BigInteger)4569031055798, IntegerTheory.ExtendedGreatestCommonDivisor(-a, b, out x, out y), "Egcd(-large)"); - Assert.AreEqual((BigInteger)4569031055798, (-a * x) + (b * y), "Egcd(-large) -> a*x+b*y"); -#endif - } - - /// - /// List GreatestCommonDivisor handles normal input Correctly - /// - [Test] - public void ListGcdHandlesNormalInputCorrectly() - { - Assert.AreEqual((BigInteger)2, IntegerTheory.GreatestCommonDivisor((BigInteger)(-10), 6, -8), "Gcd(-10,6,-8)"); - Assert.AreEqual((BigInteger)1, IntegerTheory.GreatestCommonDivisor((BigInteger)(-10), 6, -8, 5, 9, 13), "Gcd(-10,6,-8,5,9,13)"); - Assert.AreEqual((BigInteger)5, IntegerTheory.GreatestCommonDivisor((BigInteger)(-10), 20, 120, 60, -15, 1000), "Gcd(-10,20,120,60,-15,1000)"); - Assert.AreEqual((BigInteger)3, IntegerTheory.GreatestCommonDivisor((BigInteger)(Int64.MaxValue - 1), Int64.MaxValue - 4, Int64.MaxValue - 7), "Gcd(Int64Max-1,Int64Max-4,Int64Max-7)"); - Assert.AreEqual((BigInteger)123, IntegerTheory.GreatestCommonDivisor((BigInteger)492, -2 * 492, 492 / 4), "Gcd(492, -984, 123)"); - } - - /// - /// List GreatestCommonDivisor handles special input correctly. - /// - [Test] - public void ListGcdHandlesSpecialInputCorrectly() - { - Assert.AreEqual((BigInteger)0, IntegerTheory.GreatestCommonDivisor(new BigInteger[0]), "Gcd()"); - Assert.AreEqual((BigInteger)100, IntegerTheory.GreatestCommonDivisor((BigInteger)(-100)), "Gcd(-100)"); - } - - /// - /// List GreatestCommonDivisor checks for null all arguments. - /// - [Test] - public void ListGcdChecksForNullArguments() - { - Assert.Throws( - typeof(ArgumentNullException), - () => IntegerTheory.GreatestCommonDivisor((BigInteger[])null)); - } - - /// - /// LeastCommonMultiple handles normal input correctly. - /// - [Test] - public void LcmHandlesNormalInputCorrectly() - { - Assert.AreEqual((BigInteger)10, IntegerTheory.LeastCommonMultiple((BigInteger)10, 10), "Lcm(10,10)"); - - Assert.AreEqual((BigInteger)0, IntegerTheory.LeastCommonMultiple(BigInteger.Zero, 10), "Lcm(0,10)"); - Assert.AreEqual((BigInteger)0, IntegerTheory.LeastCommonMultiple((BigInteger)10, 0), "Lcm(10,0)"); - - Assert.AreEqual((BigInteger)77, IntegerTheory.LeastCommonMultiple((BigInteger)11, 7), "Lcm(11,7)"); - Assert.AreEqual((BigInteger)33, IntegerTheory.LeastCommonMultiple((BigInteger)11, 33), "Lcm(11,33)"); - Assert.AreEqual((BigInteger)374, IntegerTheory.LeastCommonMultiple((BigInteger)11, 34), "Lcm(11,34)"); - } - - /// - /// LeastCommonMultiple handles negative input correctly. - /// - [Test] - public void LcmHandlesNegativeInputCorrectly() - { - Assert.AreEqual((BigInteger)352, IntegerTheory.LeastCommonMultiple((BigInteger)11, -32), "Lcm(11,-32)"); - Assert.AreEqual((BigInteger)352, IntegerTheory.LeastCommonMultiple((BigInteger)(-11), 32), "Lcm(-11,32)"); - Assert.AreEqual((BigInteger)352, IntegerTheory.LeastCommonMultiple((BigInteger)(-11), -32), "Lcm(-11,-32)"); - } - - /// - /// LeastCommonMultiple supports large input. - /// - [Test] - public void LcmSupportsLargeInput() - { - Assert.AreEqual((BigInteger)Int32.MaxValue, IntegerTheory.LeastCommonMultiple((BigInteger)Int32.MaxValue, Int32.MaxValue), "Lcm(Int32Max,Int32Max)"); - Assert.AreEqual((BigInteger)Int64.MaxValue, IntegerTheory.LeastCommonMultiple((BigInteger)Int64.MaxValue, Int64.MaxValue), "Lcm(Int64Max,Int64Max)"); - Assert.AreEqual((BigInteger)Int64.MaxValue, IntegerTheory.LeastCommonMultiple((BigInteger)(-Int64.MaxValue), -Int64.MaxValue), "Lcm(-Int64Max,-Int64Max)"); - Assert.AreEqual((BigInteger)Int64.MaxValue, IntegerTheory.LeastCommonMultiple((BigInteger)(-Int64.MaxValue), Int64.MaxValue), "Lcm(-Int64Max,Int64Max)"); -#if !PORTABLE - Assert.AreEqual(BigInteger.Parse("91739176367857263082719902034485224119528064014300888465614024"), IntegerTheory.LeastCommonMultiple(BigInteger.Parse("7305316061155559483748611586449542122662"), BigInteger.Parse("57377277362010117405715236427413896")), "Lcm(large)"); -#endif - } - - /// - /// List LeastCommonMultiple handles normal input correctly. - /// - [Test] - public void ListLcmHandlesNormalInputCorrectly() - { - Assert.AreEqual((BigInteger)120, IntegerTheory.LeastCommonMultiple((BigInteger)(-10), 6, -8), "Lcm(-10,6,-8)"); - Assert.AreEqual((BigInteger)4680, IntegerTheory.LeastCommonMultiple((BigInteger)(-10), 6, -8, 5, 9, 13), "Lcm(-10,6,-8,5,9,13)"); - Assert.AreEqual((BigInteger)3000, IntegerTheory.LeastCommonMultiple((BigInteger)(-10), 20, 120, 60, -15, 1000), "Lcm(-10,20,120,60,-15,1000)"); - Assert.AreEqual((BigInteger)984, IntegerTheory.LeastCommonMultiple((BigInteger)492, -2 * 492, 492 / 4), "Lcm(492, -984, 123)"); - Assert.AreEqual((BigInteger)2016, IntegerTheory.LeastCommonMultiple((BigInteger)32, 42, 36, 18), "Lcm(32,42,36,18)"); - } - - /// - /// List LeastCommonMultiple handles special input correctly. - /// - [Test] - public void ListLcmHandlesSpecialInputCorrectly() - { - Assert.AreEqual((BigInteger)1, IntegerTheory.LeastCommonMultiple(new BigInteger[0]), "Lcm()"); - Assert.AreEqual((BigInteger)100, IntegerTheory.LeastCommonMultiple((BigInteger)(-100)), "Lcm(-100)"); - } - - /// - /// List LeastCommonMultiple checks for null arguments. - /// - [Test] - public void ListLcmChecksForNullArguments() - { - Assert.Throws( - typeof(ArgumentNullException), - () => IntegerTheory.LeastCommonMultiple((BigInteger[])null)); - } - } -} -#endif diff --git a/src/UnitTests/UnitTests.csproj b/src/UnitTests/UnitTests.csproj index 491bf401..52071b22 100644 --- a/src/UnitTests/UnitTests.csproj +++ b/src/UnitTests/UnitTests.csproj @@ -355,9 +355,9 @@ - - - + + +