csharpfftfsharpintegrationinterpolationlinear-algebramathdifferentiationmatrixnumericsrandomregressionstatisticsmathnet
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
294 lines
14 KiB
294 lines
14 KiB
// <copyright file="IntegerTheoryTest.cs" company="Math.NET">
|
|
// Math.NET Numerics, part of the Math.NET Project
|
|
// http://mathnet.opensourcedotnet.info
|
|
//
|
|
// Copyright (c) 2009 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.
|
|
// </copyright>
|
|
|
|
namespace MathNet.Numerics.UnitTests.NumberTheoryTests
|
|
{
|
|
using System;
|
|
using NumberTheory;
|
|
using MbUnit.Framework;
|
|
|
|
[TestFixture]
|
|
public class IntegerTheoryTest
|
|
{
|
|
[Test]
|
|
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");
|
|
}
|
|
|
|
[Test]
|
|
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");
|
|
}
|
|
|
|
[Test]
|
|
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 (-)");
|
|
}
|
|
|
|
[Test]
|
|
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 (-)");
|
|
}
|
|
|
|
[Test]
|
|
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");
|
|
}
|
|
|
|
[Test]
|
|
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");
|
|
}
|
|
|
|
[Test]
|
|
public void CeilingToPowerOfTwoReturnsZeroForNegativeNumbers32()
|
|
{
|
|
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo(-1), "-1");
|
|
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo(-2), "-2");
|
|
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo(-3), "-3");
|
|
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo(-4), "-4");
|
|
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo(Int32.MinValue), "Int32.MinValue");
|
|
Assert.AreEqual(0, IntegerTheory.CeilingToPowerOfTwo(Int32.MinValue + 1), "Int32.MinValue+1");
|
|
}
|
|
|
|
[Test]
|
|
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");
|
|
}
|
|
|
|
[Test]
|
|
public void CeilingToPowerOfTwoThrowsWhenResultWouldOverflow32()
|
|
{
|
|
Assert.Throws(
|
|
typeof (ArgumentOutOfRangeException),
|
|
() => IntegerTheory.CeilingToPowerOfTwo(Int32.MaxValue));
|
|
|
|
const int maxPowerOfTwo = 0x40000000;
|
|
Assert.Throws(
|
|
typeof(ArgumentOutOfRangeException),
|
|
() => IntegerTheory.CeilingToPowerOfTwo(maxPowerOfTwo + 1));
|
|
|
|
Assert.DoesNotThrow(
|
|
() => IntegerTheory.CeilingToPowerOfTwo(maxPowerOfTwo - 1));
|
|
}
|
|
|
|
[Test]
|
|
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));
|
|
}
|
|
|
|
[Test]
|
|
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 (-)");
|
|
}
|
|
|
|
[Test]
|
|
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 (-)");
|
|
}
|
|
}
|
|
}
|