tsai
/
mathnet-numerics
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Math.NET Numerics
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.
2786 Commits
25 Branches
121 Tags
187 MiB
 
 
 
Tree: d95c5ccd49
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd95c5ccd49'
${ noResults }
mathnet-numerics/src/Numerics.Tests/EuclidTests/IntegerTheoryTest.cs

529 lines
23 KiB
Raw Blame History

// <copyright file="IntegerTheoryTest.cs" company="Math.NET">
// Math.NET Numerics, part of the Math.NET Project
// http://numerics.mathdotnet.com
// http://github.com/mathnet/mathnet-numerics
//
// Copyright (c) 2009-2016 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>
using System;
using System.Globalization;
using NUnit.Framework;
namespace MathNet.Numerics.UnitTests.EuclidTests
{
/// <summary>
/// Integer theory tests.
/// </summary>
[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));
}
/// <summary>
/// Test even/odd int32.
/// </summary>
[Test]
public void TestEvenOdd32()
{
Assert.IsTrue(0.IsEven(), "0 is even");
Assert.IsFalse(0.IsOdd(), "0 is not odd");
Assert.IsFalse(1.IsEven(), "1 is not even");
Assert.IsTrue(1.IsOdd(), "1 is odd");
Assert.IsFalse((-1).IsEven(), "-1 is not even");
Assert.IsTrue((-1).IsOdd(), "-1 is odd");
Assert.IsFalse(Int32.MaxValue.IsEven(), "Int32.Max is not even");
Assert.IsTrue(Int32.MaxValue.IsOdd(), "Int32.Max is odd");
Assert.IsTrue(Int32.MinValue.IsEven(), "Int32.Min is even");
Assert.IsFalse(Int32.MinValue.IsOdd(), "Int32.Min is not odd");
}
/// <summary>
/// Test even/odd int64.
/// </summary>
[Test]
public void TestEvenOdd64()
{
Assert.IsTrue(((long)0).IsEven(), "0 is even");
Assert.IsFalse(((long)0).IsOdd(), "0 is not odd");
Assert.IsFalse(((long)1).IsEven(), "1 is not even");
Assert.IsTrue(((long)1).IsOdd(), "1 is odd");
Assert.IsFalse(((long)-1).IsEven(), "-1 is not even");
Assert.IsTrue(((long)-1).IsOdd(), "-1 is odd");
Assert.IsFalse(Int64.MaxValue.IsEven(), "Int64.Max is not even");
Assert.IsTrue(Int64.MaxValue.IsOdd(), "Int64.Max is odd");
Assert.IsTrue(Int64.MinValue.IsEven(), "Int64.Min is even");
Assert.IsFalse(Int64.MinValue.IsOdd(), "Int64.Min is not odd");
}
/// <summary>
/// Test if int32 is power of 2.
/// </summary>
[Test]
public void TestIsPowerOfTwo32()
{
for (var i = 2; i < 31; i++)
{
var x = 1 << i;
Assert.IsTrue(x.IsPowerOfTwo(), x + " (+)");
Assert.IsFalse((x - 1).IsPowerOfTwo(), x + "-1 (-)");
Assert.IsFalse((x + 1).IsPowerOfTwo(), x + "+1 (-)");
Assert.IsFalse((-x).IsPowerOfTwo(), "-" + x + " (-)");
Assert.IsFalse((-x + 1).IsPowerOfTwo(), "-" + x + "+1 (-)");
Assert.IsFalse((-x - 1).IsPowerOfTwo(), "-" + x + "-1 (-)");
}
Assert.IsTrue(4.IsPowerOfTwo(), "4 (+)");
Assert.IsFalse(3.IsPowerOfTwo(), "3 (-)");
Assert.IsTrue(2.IsPowerOfTwo(), "2 (+)");
Assert.IsTrue(1.IsPowerOfTwo(), "1 (+)");
Assert.IsFalse(0.IsPowerOfTwo(), "0 (-)");
Assert.IsFalse((-1).IsPowerOfTwo(), "-1 (-)");
Assert.IsFalse((-2).IsPowerOfTwo(), "-2 (-)");
Assert.IsFalse((-3).IsPowerOfTwo(), "-3 (-)");
Assert.IsFalse((-4).IsPowerOfTwo(), "-4 (-)");
Assert.IsFalse(Int32.MinValue.IsPowerOfTwo(), "Int32.MinValue (-)");
Assert.IsFalse((Int32.MinValue + 1).IsPowerOfTwo(), "Int32.MinValue+1 (-)");
Assert.IsFalse(Int32.MaxValue.IsPowerOfTwo(), "Int32.MaxValue (-)");
Assert.IsFalse((Int32.MaxValue - 1).IsPowerOfTwo(), "Int32.MaxValue-1 (-)");
}
/// <summary>
/// Test if int64 is power of 2.
/// </summary>
[Test]
public void TestIsPowerOfTwo64()
{
for (var i = 2; i < 63; i++)
{
var x = ((long)1) << i;
Assert.IsTrue(x.IsPowerOfTwo(), x + " (+)");
Assert.IsFalse((x - 1).IsPowerOfTwo(), x + "-1 (-)");
Assert.IsFalse((x + 1).IsPowerOfTwo(), x + "+1 (-)");
Assert.IsFalse((-x).IsPowerOfTwo(), "-" + x + " (-)");
Assert.IsFalse((-x + 1).IsPowerOfTwo(), "-" + x + "+1 (-)");
Assert.IsFalse((-x - 1).IsPowerOfTwo(), "-" + x + "-1 (-)");
}
Assert.IsTrue(((long)4).IsPowerOfTwo(), "4 (+)");
Assert.IsFalse(((long)3).IsPowerOfTwo(), "3 (-)");
Assert.IsTrue(((long)2).IsPowerOfTwo(), "2 (+)");
Assert.IsTrue(((long)1).IsPowerOfTwo(), "1 (+)");
Assert.IsFalse(((long)0).IsPowerOfTwo(), "0 (-)");
Assert.IsFalse(((long)-1).IsPowerOfTwo(), "-1 (-)");
Assert.IsFalse(((long)-2).IsPowerOfTwo(), "-2 (-)");
Assert.IsFalse(((long)-3).IsPowerOfTwo(), "-3 (-)");
Assert.IsFalse(((long)-4).IsPowerOfTwo(), "-4 (-)");
Assert.IsFalse(Int64.MinValue.IsPowerOfTwo(), "Int32.MinValue (-)");
Assert.IsFalse((Int64.MinValue + 1).IsPowerOfTwo(), "Int32.MinValue+1 (-)");
Assert.IsFalse(Int64.MaxValue.IsPowerOfTwo(), "Int32.MaxValue (-)");
Assert.IsFalse((Int64.MaxValue - 1).IsPowerOfTwo(), "Int32.MaxValue-1 (-)");
}
/// <summary>
/// Ceiling to power of two handles positive int32 correctly.
/// </summary>
[Test]
public void CeilingToPowerOfHandlesPositiveIntegersCorrectly32()
{
Assert.AreEqual(0, 0.CeilingToPowerOfTwo(), "0");
Assert.AreEqual(1, 1.CeilingToPowerOfTwo(), "1");
Assert.AreEqual(2, 2.CeilingToPowerOfTwo(), "2");
Assert.AreEqual(4, 3.CeilingToPowerOfTwo(), "3");
Assert.AreEqual(4, 4.CeilingToPowerOfTwo(), "4");
for (var i = 2; i < 31; i++)
{
var x = 1 << i;
Assert.AreEqual(x, x.CeilingToPowerOfTwo(), x.ToString(CultureInfo.InvariantCulture));
Assert.AreEqual(x, (x - 1).CeilingToPowerOfTwo(), x + "-1");
Assert.AreEqual(x, ((x >> 1) + 1).CeilingToPowerOfTwo(), x + "/2+1");
Assert.AreEqual(0, (-x).CeilingToPowerOfTwo(), "-" + x);
}
const int MaxPowerOfTwo = 0x40000000;
Assert.AreEqual(MaxPowerOfTwo, MaxPowerOfTwo.CeilingToPowerOfTwo(), "max");
Assert.AreEqual(MaxPowerOfTwo, (MaxPowerOfTwo - 1).CeilingToPowerOfTwo(), "max");
}
/// <summary>
/// Ceiling to power of two handles positive int64 correctly.
/// </summary>
[Test]
public void CeilingToPowerOfHandlesPositiveIntegersCorrectly64()
{
Assert.AreEqual(0, ((long)0).CeilingToPowerOfTwo(), "0");
Assert.AreEqual(1, ((long)1).CeilingToPowerOfTwo(), "1");
Assert.AreEqual(2, ((long)2).CeilingToPowerOfTwo(), "2");
Assert.AreEqual(4, ((long)3).CeilingToPowerOfTwo(), "3");
Assert.AreEqual(4, ((long)4).CeilingToPowerOfTwo(), "4");
for (var i = 2; i < 63; i++)
{
var x = ((long)1) << i;
Assert.AreEqual(x, x.CeilingToPowerOfTwo(), x.ToString(CultureInfo.InvariantCulture));
Assert.AreEqual(x, (x - 1).CeilingToPowerOfTwo(), x + "-1");
Assert.AreEqual(x, ((x >> 1) + 1).CeilingToPowerOfTwo(), x + "/2+1");
Assert.AreEqual(0, (-x).CeilingToPowerOfTwo(), "-" + x);
}
const long MaxPowerOfTwo = 0x4000000000000000;
Assert.AreEqual(MaxPowerOfTwo, MaxPowerOfTwo.CeilingToPowerOfTwo(), "max");
Assert.AreEqual(MaxPowerOfTwo, (MaxPowerOfTwo - 1).CeilingToPowerOfTwo(), "max");
}
/// <summary>
/// Ceiling to power of two returns zero for negative int32.
/// </summary>
[Test]
public void CeilingToPowerOfTwoReturnsZeroForNegativeNumbers32()
{
Assert.AreEqual(0, (-1).CeilingToPowerOfTwo(), "-1");
Assert.AreEqual(0, (-2).CeilingToPowerOfTwo(), "-2");
Assert.AreEqual(0, (-3).CeilingToPowerOfTwo(), "-3");
Assert.AreEqual(0, (-4).CeilingToPowerOfTwo(), "-4");
Assert.AreEqual(0, Int32.MinValue.CeilingToPowerOfTwo(), "Int32.MinValue");
Assert.AreEqual(0, (Int32.MinValue + 1).CeilingToPowerOfTwo(), "Int32.MinValue+1");
}
/// <summary>
/// Ceiling to power of two returns zero for negative int64.
/// </summary>
[Test]
public void CeilingToPowerOfTwoReturnsZeroForNegativeNumbers64()
{
Assert.AreEqual(0, ((long)-1).CeilingToPowerOfTwo(), "-1");
Assert.AreEqual(0, ((long)-2).CeilingToPowerOfTwo(), "-2");
Assert.AreEqual(0, ((long)-3).CeilingToPowerOfTwo(), "-3");
Assert.AreEqual(0, ((long)-4).CeilingToPowerOfTwo(), "-4");
Assert.AreEqual(0, Int64.MinValue.CeilingToPowerOfTwo(), "Int64.MinValue");
Assert.AreEqual(0, (Int64.MinValue + 1).CeilingToPowerOfTwo(), "Int64.MinValue+1");
}
/// <summary>
/// Ceiling to power of two throws <c>ArgumentOutOfRangeException</c> when result would overflow int32.
/// </summary>
[Test]
public void CeilingToPowerOfTwoThrowsWhenResultWouldOverflow32()
{
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => Int32.MaxValue.CeilingToPowerOfTwo());
const int MaxPowerOfTwo = 0x40000000;
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => (MaxPowerOfTwo + 1).CeilingToPowerOfTwo());
Assert.DoesNotThrow(
() => (MaxPowerOfTwo - 1).CeilingToPowerOfTwo());
}
/// <summary>
/// Ceiling to power of two throws <c>ArgumentOutOfRangeException</c> when result would overflow int64.
/// </summary>
[Test]
public void CeilingToPowerOfTwoThrowsWhenResultWouldOverflow64()
{
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => Int64.MaxValue.CeilingToPowerOfTwo());
const long MaxPowerOfTwo = 0x4000000000000000;
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => (MaxPowerOfTwo + 1).CeilingToPowerOfTwo());
Assert.DoesNotThrow(
() => (MaxPowerOfTwo - 1).CeilingToPowerOfTwo());
}
/// <summary>
/// Power of two matches floating point power int32.
/// </summary>
[Test]
public void PowerOfTwoMatchesFloatingPointPower32()
{
for (var i = 0; i < 31; i++)
{
Assert.AreEqual(Math.Round(Math.Pow(2, i)), i.PowerOfTwo());
}
}
/// <summary>
/// Power of two matches floating point power int64.
/// </summary>
[Test]
public void PowerOfTwoMatchesFloatingPointPower64()
{
for (var i = 0; i < 63; i++)
{
Assert.AreEqual(Math.Round(Math.Pow(2, i)), ((long)i).PowerOfTwo());
}
}
/// <summary>
/// Power of two throws <c>ArgumentOutOfRangeException</c> when int32 is out of range.
/// </summary>
[Test]
public void PowerOfTwoThrowsWhenOutOfRange32()
{
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => (-1).PowerOfTwo());
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => 31.PowerOfTwo());
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => Int32.MinValue.PowerOfTwo());
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => Int32.MaxValue.PowerOfTwo());
Assert.DoesNotThrow(
() => 30.PowerOfTwo());
Assert.DoesNotThrow(
() => 0.PowerOfTwo());
}
/// <summary>
/// Power of two throws <c>ArgumentOutOfRangeException</c> when int64 is out of range.
/// </summary>
[Test]
public void PowerOfTwoThrowsWhenOutOfRange64()
{
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => ((long)-1).PowerOfTwo());
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => ((long)63).PowerOfTwo());
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => Int64.MinValue.PowerOfTwo());
Assert.Throws(
typeof(ArgumentOutOfRangeException),
() => Int64.MaxValue.PowerOfTwo());
Assert.DoesNotThrow(
() => ((long)62).PowerOfTwo());
Assert.DoesNotThrow(
() => ((long)0).PowerOfTwo());
}
/// <summary>
/// Log2 matches floating point for int32.
/// </summary>
[Test]
public void Log2MatchesFloatingPoint32()
{
for (var i = 0; i < 31; i++)
{
int number = i.PowerOfTwo();
Assert.AreEqual((int)Math.Log(number, 2), number.Log2());
Assert.AreEqual((int)Math.Log(number + 1, 2), (number + 1).Log2());
if (number > 1)
{
Assert.AreEqual((int)Math.Log(number - 1, 2), (number - 1).Log2());
}
}
}
/// <summary>
/// Test if int32 is perfect square.
/// </summary>
[Test]
public void TestIsPerfectSquare32()
{
// Test all known suares
var lastRadix = (int)Math.Floor(Math.Sqrt(Int32.MaxValue));
for (var i = 0; i <= lastRadix; i++)
{
Assert.IsTrue((i * i).IsPerfectSquare(), i + "^2 (+)");
}
// Test 1-offset from all known squares
for (var i = 2; i <= lastRadix; i++)
{
Assert.IsFalse(((i * i) - 1).IsPerfectSquare(), i + "^2-1 (-)");
Assert.IsFalse(((i * i) + 1).IsPerfectSquare(), i + "^2+1 (-)");
}
// Selected Cases
Assert.IsTrue(100000000.IsPerfectSquare(), "100000000 (+)");
Assert.IsFalse(100000001.IsPerfectSquare(), "100000001 (-)");
Assert.IsFalse(99999999.IsPerfectSquare(), "99999999 (-)");
Assert.IsFalse((-4).IsPerfectSquare(), "-4 (-)");
Assert.IsFalse(Int32.MinValue.IsPerfectSquare(), "Int32.MinValue (-)");
Assert.IsFalse(Int32.MaxValue.IsPerfectSquare(), "Int32.MaxValue (-)");
Assert.IsTrue(1.IsPerfectSquare(), "1 (+)");
Assert.IsTrue(0.IsPerfectSquare(), "0 (+)");
Assert.IsFalse((-1).IsPerfectSquare(), "-1 (-)");
}
/// <summary>
/// Test if int64 is perfect square.
/// </summary>
[Test]
public void TestIsPerfectSquare64()
{
// Test all known suares
for (var i = 0; i < 32; i++)
{
var t = ((long)1) << i;
Assert.IsTrue((t * t).IsPerfectSquare(), t + "^2 (+)");
}
// Test 1-offset from all known squares
for (var i = 1; i < 32; i++)
{
var t = ((long)1) << i;
Assert.IsFalse(((t * t) - 1).IsPerfectSquare(), t + "^2-1 (-)");
Assert.IsFalse(((t * t) + 1).IsPerfectSquare(), t + "^2+1 (-)");
}
// Selected Cases
Assert.IsTrue(1000000000000000000.IsPerfectSquare(), "1000000000000000000 (+)");
Assert.IsFalse(1000000000000000001.IsPerfectSquare(), "1000000000000000001 (-)");
Assert.IsFalse(999999999999999999.IsPerfectSquare(), "999999999999999999 (-)");
Assert.IsFalse(999999999999999993.IsPerfectSquare(), "999999999999999993 (-)");
Assert.IsFalse(((long)-4).IsPerfectSquare(), "-4 (-)");
Assert.IsFalse(Int64.MinValue.IsPerfectSquare(), "Int32.MinValue (-)");
Assert.IsFalse(Int64.MaxValue.IsPerfectSquare(), "Int32.MaxValue (-)");
Assert.IsTrue(((long)1).IsPerfectSquare(), "1 (+)");
Assert.IsTrue(((long)0).IsPerfectSquare(), "0 (+)");
Assert.IsFalse(((long)-1).IsPerfectSquare(), "-1 (-)");
}
}
}