/// <summary>
/// Composite N-point approximation of the definite integral in the provided interval by Simpson's rule.
/// </summary>
public double IntegrateComposite(
CustomFunction f,
double intervalBegin,
double intervalEnd,
int numberOfPartitions)
{
if (numberOfPartitions <= 0)
{
throw new ArgumentOutOfRangeException("numberOfPartitions", Properties.LocalStrings.ArgumentPositive);
}
if (IntegerTheory.IsOdd(numberOfPartitions))
{
throw new ArgumentException(Properties.LocalStrings.ArgumentEven, "numberOfPartitions");
}
double step = (intervalEnd - intervalBegin) / numberOfPartitions;
double factor = step / 3;
double offset = step;
int m = 4;
double sum = f(intervalBegin) + f(intervalEnd);
for (int i = 0; i < numberOfPartitions - 1; i++)
{
// NOTE (ruegg, 2009-01-07): Do not combine intervalBegin and offset (numerical stability!)
sum += m * f(intervalBegin + offset);
m = 6 - m;
offset += step;
}
return(factor * sum);
}
public void TestIsPowerOfTwo64()
{
for (int i = 2; i < 63; i++)
{
long x = ((long)1) << i;
Assert.IsTrue(IntegerTheory.IsPowerOfTwo(x), x + " (+)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(x - 1), x + "-1 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(x + 1), x + "+1 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(-x), "-" + x + " (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(-x + 1), "-" + x + "+1 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(-x - 1), "-" + x + "-1 (-)");
}
Assert.IsTrue(IntegerTheory.IsPowerOfTwo((long)4), "4 (+)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo((long)3), "3 (-)");
Assert.IsTrue(IntegerTheory.IsPowerOfTwo((long)2), "2 (+)");
Assert.IsTrue(IntegerTheory.IsPowerOfTwo((long)1), "1 (+)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo((long)0), "0 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo((long)-1), "-1 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo((long)-2), "-2 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo((long)-3), "-3 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo((long)-4), "-4 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(Int64.MinValue), "Int32.MinValue (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(Int64.MinValue + 1), "Int32.MinValue+1 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(Int64.MaxValue), "Int32.MaxValue (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(Int64.MaxValue - 1), "Int32.MaxValue-1 (-)");
}
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)");
}
public void TestIsPerfectSquare64()
{
// Test all known suares
for (int i = 0; i < 32; i++)
{
long t = ((long)1) << i;
Assert.IsTrue(IntegerTheory.IsPerfectSquare(t * t), t + "^2 (+)");
}
// Test 1-offset from all known squares
for (int i = 1; i < 32; i++)
{
long t = ((long)1) << i;
Assert.IsFalse(IntegerTheory.IsPerfectSquare((t * t) - 1), t + "^2-1 (-)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare((t * t) + 1), t + "^2+1 (-)");
}
// Selected Cases
Assert.IsTrue(IntegerTheory.IsPerfectSquare((long)1000000000000000000), "1000000000000000000 (+)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare((long)1000000000000000001), "1000000000000000001 (-)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare((long)999999999999999999), "999999999999999999 (-)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare((long)999999999999999993), "999999999999999993 (-)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare((long)-4), "-4 (-)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare(Int64.MinValue), "Int32.MinValue (-)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare(Int64.MaxValue), "Int32.MaxValue (-)");
Assert.IsTrue(IntegerTheory.IsPerfectSquare((long)1), "1 (+)");
Assert.IsTrue(IntegerTheory.IsPerfectSquare((long)0), "0 (+)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare((long)-1), "-1 (-)");
}
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)");
}
UpperMedian(IEnumerable <double> samples)
{
List <double> list = new List <double>(samples);
int lowerMidpoint = IntegerTheory.IsEven(list.Count) ? ((list.Count / 2) + 1) : (list.Count / 2);
return(OrderSelect(list, 0, list.Count - 1, lowerMidpoint + 1));
}
public void TestIsPerfectSquare32()
{
// Test all known suares
int lastRadix = (int)Math.Floor(Math.Sqrt(Int32.MaxValue));
for (int i = 0; i <= lastRadix; i++)
{
Assert.IsTrue(IntegerTheory.IsPerfectSquare(i * i), i + "^2 (+)");
}
// Test 1-offset from all known squares
for (int i = 2; i <= lastRadix; i++)
{
Assert.IsFalse(IntegerTheory.IsPerfectSquare((i * i) - 1), i + "^2-1 (-)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare((i * i) + 1), i + "^2+1 (-)");
}
// Selected Cases
Assert.IsTrue(IntegerTheory.IsPerfectSquare(100000000), "100000000 (+)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare(100000001), "100000001 (-)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare(99999999), "99999999 (-)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare(-4), "-4 (-)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare(Int32.MinValue), "Int32.MinValue (-)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare(Int32.MaxValue), "Int32.MaxValue (-)");
Assert.IsTrue(IntegerTheory.IsPerfectSquare(1), "1 (+)");
Assert.IsTrue(IntegerTheory.IsPerfectSquare(0), "0 (+)");
Assert.IsFalse(IntegerTheory.IsPerfectSquare(-1), "-1 (-)");
}
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)");
}
public void PowerOfTwoMatchesFloatingPointPower64()
{
for (int i = 0; i < 63; i++)
{
Assert.AreEqual(Math.Round(Math.Pow(2, i)), IntegerTheory.PowerOfTwo((long)i));
}
}
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)");
}
public void TestIsPowerOfTwo32()
{
for (int i = 2; i < 31; i++)
{
int x = 1 << i;
Assert.IsTrue(IntegerTheory.IsPowerOfTwo(x), x + " (+)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(x - 1), x + "-1 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(x + 1), x + "+1 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(-x), "-" + x + " (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(-x + 1), "-" + x + "+1 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(-x - 1), "-" + x + "-1 (-)");
}
Assert.IsTrue(IntegerTheory.IsPowerOfTwo(4), "4 (+)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(3), "3 (-)");
Assert.IsTrue(IntegerTheory.IsPowerOfTwo(2), "2 (+)");
Assert.IsTrue(IntegerTheory.IsPowerOfTwo(1), "1 (+)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(0), "0 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(-1), "-1 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(-2), "-2 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(-3), "-3 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(-4), "-4 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(Int32.MinValue), "Int32.MinValue (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(Int32.MinValue + 1), "Int32.MinValue+1 (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(Int32.MaxValue), "Int32.MaxValue (-)");
Assert.IsFalse(IntegerTheory.IsPowerOfTwo(Int32.MaxValue - 1), "Int32.MaxValue-1 (-)");
}
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)");
}
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)");
}
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)");
Assert.AreEqual(BigInteger.Parse("91739176367857263082719902034485224119528064014300888465614024"), IntegerTheory.LeastCommonMultiple(BigInteger.Parse("7305316061155559483748611586449542122662"), BigInteger.Parse("57377277362010117405715236427413896")), "Lcm(large)");
}
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)");
}
public void CeilingToPowerOfTwoReturnsZeroForNegativeNumbers64()
{
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo((long)-1), "-1");
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo((long)-2), "-2");
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo((long)-3), "-3");
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo((long)-4), "-4");
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo(Int64.MinValue), "Int64.MinValue");
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo(Int64.MinValue + 1), "Int64.MinValue+1");
}
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)");
Assert.AreEqual((BigInteger)4569031055798, IntegerTheory.GreatestCommonDivisor(BigInteger.Parse("7305316061155559483748611586449542122662"), BigInteger.Parse("57377277362010117405715236427413896")), "Gcd(large)");
}
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)");
}
/// <summary>
/// Run example
/// </summary>
public void Run()
{
// 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();
// 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();
// 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();
// 4. Find the closest perfect power of two that is larger or equal to 97
Console.WriteLine(@"4. Find the closest perfect power of two that is larger or equal to 97");
Console.WriteLine(97.CeilingToPowerOfTwo());
Console.WriteLine();
// 5. Raise 2 to the 16
Console.WriteLine(@"5. Raise 2 to the 16");
Console.WriteLine(16.PowerOfTwo());
Console.WriteLine();
// 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();
// 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();
// 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();
// 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);
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();
}
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)");
}
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)");
}
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");
}
public void CeilingToPowerOfTwoThrowsWhenResultWouldOverflow64()
{
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => IntegerTheory.CeilingToPowerOfTwo(Int64.MaxValue));
const long maxPowerOfTwo = 0x4000000000000000;
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => IntegerTheory.CeilingToPowerOfTwo(maxPowerOfTwo + 1));
Assert.DoesNotThrow(
() => IntegerTheory.CeilingToPowerOfTwo(maxPowerOfTwo - 1));
}
public void TestEvenOdd32()
{
Assert.IsTrue(IntegerTheory.IsEven(0), "0 is even");
Assert.IsFalse(IntegerTheory.IsOdd(0), "0 is not odd");
Assert.IsFalse(IntegerTheory.IsEven(1), "1 is not even");
Assert.IsTrue(IntegerTheory.IsOdd(1), "1 is odd");
Assert.IsFalse(IntegerTheory.IsEven(-1), "-1 is not even");
Assert.IsTrue(IntegerTheory.IsOdd(-1), "-1 is odd");
Assert.IsFalse(IntegerTheory.IsEven(Int32.MaxValue), "Int32.Max is not even");
Assert.IsTrue(IntegerTheory.IsOdd(Int32.MaxValue), "Int32.Max is odd");
Assert.IsTrue(IntegerTheory.IsEven(Int32.MinValue), "Int32.Min is even");
Assert.IsFalse(IntegerTheory.IsOdd(Int32.MinValue), "Int32.Min is not odd");
}
public void TestEvenOdd64()
{
Assert.IsTrue(IntegerTheory.IsEven((long)0), "0 is even");
Assert.IsFalse(IntegerTheory.IsOdd((long)0), "0 is not odd");
Assert.IsFalse(IntegerTheory.IsEven((long)1), "1 is not even");
Assert.IsTrue(IntegerTheory.IsOdd((long)1), "1 is odd");
Assert.IsFalse(IntegerTheory.IsEven((long)-1), "-1 is not even");
Assert.IsTrue(IntegerTheory.IsOdd((long)-1), "-1 is odd");
Assert.IsFalse(IntegerTheory.IsEven(Int64.MaxValue), "Int64.Max is not even");
Assert.IsTrue(IntegerTheory.IsOdd(Int64.MaxValue), "Int64.Max is odd");
Assert.IsTrue(IntegerTheory.IsEven(Int64.MinValue), "Int64.Min is even");
Assert.IsFalse(IntegerTheory.IsOdd(Int64.MinValue), "Int64.Min is not odd");
}
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");
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");
}
public void CeilingToPowerOfHandlesPositiveIntegersCorrectly64()
{
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo((long)0), "0");
Assert.AreEqual(1, IntegerTheory.CeilingToPowerOfTwo((long)1), "1");
Assert.AreEqual(2, IntegerTheory.CeilingToPowerOfTwo((long)2), "2");
Assert.AreEqual(4, IntegerTheory.CeilingToPowerOfTwo((long)3), "3");
Assert.AreEqual(4, IntegerTheory.CeilingToPowerOfTwo((long)4), "4");
for (int i = 2; i < 63; i++)
{
long x = ((long)1) << i;
Assert.AreEqual(x, IntegerTheory.CeilingToPowerOfTwo(x), x.ToString());
Assert.AreEqual(x, IntegerTheory.CeilingToPowerOfTwo(x - 1), x + "-1");
Assert.AreEqual(x, IntegerTheory.CeilingToPowerOfTwo((x >> 1) + 1), x + "/2+1");
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo(-x), "-" + x);
}
const long maxPowerOfTwo = 0x4000000000000000;
Assert.AreEqual(maxPowerOfTwo, IntegerTheory.CeilingToPowerOfTwo(maxPowerOfTwo), "max");
Assert.AreEqual(maxPowerOfTwo, IntegerTheory.CeilingToPowerOfTwo(maxPowerOfTwo - 1), "max");
}
public void CeilingToPowerOfHandlesPositiveIntegersCorrectly32()
{
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo(0), "0");
Assert.AreEqual(1, IntegerTheory.CeilingToPowerOfTwo(1), "1");
Assert.AreEqual(2, IntegerTheory.CeilingToPowerOfTwo(2), "2");
Assert.AreEqual(4, IntegerTheory.CeilingToPowerOfTwo(3), "3");
Assert.AreEqual(4, IntegerTheory.CeilingToPowerOfTwo(4), "4");
for (int i = 2; i < 31; i++)
{
int x = 1 << i;
Assert.AreEqual(x, IntegerTheory.CeilingToPowerOfTwo(x), x.ToString());
Assert.AreEqual(x, IntegerTheory.CeilingToPowerOfTwo(x - 1), x + "-1");
Assert.AreEqual(x, IntegerTheory.CeilingToPowerOfTwo((x >> 1) + 1), x + "/2+1");
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo(-x), "-" + x);
}
const int maxPowerOfTwo = 0x40000000;
Assert.AreEqual(maxPowerOfTwo, IntegerTheory.CeilingToPowerOfTwo(maxPowerOfTwo), "max");
Assert.AreEqual(maxPowerOfTwo, IntegerTheory.CeilingToPowerOfTwo(maxPowerOfTwo - 1), "max");
}
public void PowerOfTwoThrowsWhenOutOfRange32()
{
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => IntegerTheory.PowerOfTwo(-1));
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => IntegerTheory.PowerOfTwo(31));
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => IntegerTheory.PowerOfTwo(Int32.MinValue));
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => IntegerTheory.PowerOfTwo(Int32.MaxValue));
Assert.DoesNotThrow(
() => IntegerTheory.PowerOfTwo(30));
Assert.DoesNotThrow(
() => IntegerTheory.PowerOfTwo(0));
}
public void PowerOfTwoThrowsWhenOutOfRange64()
{
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => IntegerTheory.PowerOfTwo((long)-1));
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => IntegerTheory.PowerOfTwo((long)63));
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => IntegerTheory.PowerOfTwo(Int64.MinValue));
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => IntegerTheory.PowerOfTwo(Int64.MaxValue));
Assert.DoesNotThrow(
() => IntegerTheory.PowerOfTwo((long)62));
Assert.DoesNotThrow(
() => IntegerTheory.PowerOfTwo((long)0));
}
