Number Theory: Gcd/Egcd/Lcm for BigInteger

src/Numerics/NumberTheory/IntegerTheory.Euclid.Big.cs

@@ -0,0 +1,193 @@
+// <copyright file="IntegerTheory.Euclid.Big.cs" company="Math.NET">
+// Math.NET Numerics, part of the Math.NET Project
+// http://mathnet.opensourcedotnet.info
+//
+// 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.
+// </copyright>
+
+namespace MathNet.Numerics.NumberTheory
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Numerics;
+
+	/// <summary>
+    /// Number theory utility functions for integers.
+    /// </summary>
+    public static partial class IntegerTheory
+    {
+        /// <summary>
+        /// Returns the greatest common divisor (<c>gcd</c>) of two big integers.
+        /// </summary>
+        /// <param name="a">First Integer: a.</param>
+        /// <param name="b">Second Integer: b.</param>
+        /// <returns>Greatest common divisor <c>gcd</c>(a,b)</returns>
+        public static BigInteger GreatestCommonDivisor(BigInteger a, BigInteger b)
+        {
+        	return BigInteger.GreatestCommonDivisor(a, b);
+        }
+
+        /// <summary>
+        /// Returns the greatest common divisor (<c>gcd</c>) of a set of big integers.
+        /// </summary>
+        /// <param name="integers">List of Integers.</param>
+        /// <returns>Greatest common divisor <c>gcd</c>(list of integers)</returns>
+		public static BigInteger GreatestCommonDivisor(IList<BigInteger> integers)
+        {
+            if (null == integers)
+            {
+                throw new ArgumentNullException("integers");
+            }
+
+            if (integers.Count == 0)
+            {
+                return 0;
+            }
+
+            var gcd = BigInteger.Abs(integers[0]);
+
+            for (int i = 1; (i < integers.Count) && (gcd > BigInteger.One); i++)
+            {
+                gcd = GreatestCommonDivisor(gcd, integers[i]);
+            }
+
+            return gcd;
+        }
+
+        /// <summary>
+        /// Returns the greatest common divisor (<c>gcd</c>) of a set of big integers.
+        /// </summary>
+        /// <param name="integers">List of Integers.</param>
+        /// <returns>Greatest common divisor <c>gcd</c>(list of integers)</returns>
+		public static BigInteger GreatestCommonDivisor(params BigInteger[] integers)
+        {
+			return GreatestCommonDivisor((IList<BigInteger>)integers);
+        }
+
+		/// <summary>
+		/// Computes the extended greatest common divisor, such that a*x + b*y = <c>gcd</c>(a,b).
+		/// </summary>
+		/// <param name="a">First Integer: a.</param>
+		/// <param name="b">Second Integer: b.</param>
+		/// <param name="x">Resulting x, such that a*x + b*y = <c>gcd</c>(a,b).</param>
+		/// <param name="y">Resulting y, such that a*x + b*y = <c>gcd</c>(a,b)</param>
+		/// <returns>Greatest common divisor <c>gcd</c>(a,b)</returns>
+		/// <example>
+		/// <code>
+		/// long x,y,d;
+		/// d = Fn.GreatestCommonDivisor(45,18,out x, out y);
+		/// -> d == 9 &amp;&amp; x == 1 &amp;&amp; y == -2
+		/// </code>
+		/// The <c>gcd</c> of 45 and 18 is 9: 18 = 2*9, 45 = 5*9. 9 = 1*45 -2*18, therefore x=1 and y=-2.
+		/// </example>
+		public static BigInteger ExtendedGreatestCommonDivisor(
+			BigInteger a,
+			BigInteger b,
+			out BigInteger x,
+			out BigInteger y)
+		{
+			BigInteger mp = BigInteger.One, np = BigInteger.Zero, m = BigInteger.Zero, n = BigInteger.One;
+
+			while (!b.IsZero)
+			{
+				BigInteger rem;
+				BigInteger quot = BigInteger.DivRem(a, b, out rem);
+				a = b;
+				b = rem;
+
+				BigInteger tmp = m;
+				m = mp - (quot * m);
+				mp = tmp;
+
+				tmp = n;
+				n = np - (quot * n);
+				np = tmp;
+			}
+
+			if (a >= BigInteger.Zero)
+			{
+				x = mp;
+				y = np;
+				return a;
+			}
+
+			x = -mp;
+			y = -np;
+			return -a;
+		}
+
+		/// <summary>
+		/// Returns the least common multiple (<c>lcm</c>) of two big integers.
+		/// </summary>
+		/// <param name="a">First Integer: a.</param>
+		/// <param name="b">Second Integer: b.</param>
+		/// <returns>Least common multiple <c>lcm</c>(a,b)</returns>
+		public static BigInteger LeastCommonMultiple(BigInteger a, BigInteger b)
+		{
+			if (a.IsZero || b.IsZero)
+			{
+				return BigInteger.Zero;
+			}
+
+			return BigInteger.Abs((a / BigInteger.GreatestCommonDivisor(a, b)) * b);
+		}
+
+		/// <summary>
+		/// Returns the least common multiple (<c>lcm</c>) of a set of big integers.
+		/// </summary>
+		/// <param name="integers">List of Integers.</param>
+		/// <returns>Least common multiple <c>lcm</c>(list of integers)</returns>
+		public static BigInteger LeastCommonMultiple(IList<BigInteger> integers)
+		{
+			if (null == integers)
+			{
+				throw new ArgumentNullException("integers");
+			}
+
+			if (integers.Count == 0)
+			{
+				return 1;
+			}
+
+			var lcm = BigInteger.Abs(integers[0]);
+
+			for (int i = 1; i < integers.Count; i++)
+			{
+				lcm = LeastCommonMultiple(lcm, integers[i]);
+			}
+
+			return lcm;
+		}
+
+		/// <summary>
+		/// Returns the least common multiple (<c>lcm</c>) of a set of big integers.
+		/// </summary>
+		/// <param name="integers">List of Integers.</param>
+		/// <returns>Least common multiple <c>lcm</c>(list of integers)</returns>
+		public static BigInteger LeastCommonMultiple(params BigInteger[] integers)
+		{
+			return LeastCommonMultiple((IList<BigInteger>)integers);
+		}
+	}
+}

src/Numerics/NumberTheory/IntegerTheory.Euclid.cs

@@ -2,7 +2,7 @@
 // Math.NET Numerics, part of the Math.NET Project
 // http://mathnet.opensourcedotnet.info
 //
-// Copyright (c) 2009 Math.NET
+// 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
@@ -72,7 +72,7 @@ namespace MathNet.Numerics.NumberTheory
                 return 0;
             }
 
-            long gcd = Math.Abs(integers[0]);
+            var gcd = Math.Abs(integers[0]);
 
             for (int i = 1; (i < integers.Count) && (gcd > 1); i++)
             {
@@ -118,8 +118,8 @@ namespace MathNet.Numerics.NumberTheory
 
             while (b != 0)
             {
-                long quot = a / b;
+            	long rem;
-                long rem = a % b;
+            	long quot = Math.DivRem(a, b, out rem);
                 a = b;
                 b = rem;
 
@@ -177,7 +177,7 @@ namespace MathNet.Numerics.NumberTheory
                 return 1;
             }
 
-            long lcm = Math.Abs(integers[0]);
+            var lcm = Math.Abs(integers[0]);
 
             for (int i = 1; i < integers.Count; i++)
             {

src/Numerics/NumberTheory/IntegerTheory.cs

@@ -2,7 +2,7 @@
 // Math.NET Numerics, part of the Math.NET Project
 // http://mathnet.opensourcedotnet.info
 //
-// Copyright (c) 2009 Math.NET
+// 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
@@ -29,8 +29,9 @@
 namespace MathNet.Numerics.NumberTheory
 {
     using System;
+    using System.Numerics;
 
-    /// <summary>
+	/// <summary>
     /// Number theory utility functions for integers.
     /// </summary>
     public static partial class IntegerTheory

src/Numerics/Numerics.csproj

@@ -144,6 +144,7 @@
     <Compile Include="LinearAlgebra\Double\DenseVector.cs" />
     <Compile Include="LinearAlgebra\Double\Matrix.cs" />
     <Compile Include="LinearAlgebra\Double\Vector.cs" />
+    <Compile Include="NumberTheory\IntegerTheory.Euclid.Big.cs" />
     <Compile Include="NumberTheory\IntegerTheory.cs" />
     <Compile Include="NumberTheory\IntegerTheory.Euclid.cs" />
     <Compile Include="Precision.cs" />

src/UnitTests/NumberTheoryTests/GcdRelatedTest.cs

@@ -92,7 +92,7 @@ namespace MathNet.Numerics.UnitTests.NumberTheoryTests
         [Test]
         public void ListGcdHandlesSpecialInputCorrectly()
         {
-            Assert.AreEqual(0, IntegerTheory.GreatestCommonDivisor(), "Gcd()");
+            Assert.AreEqual(0, IntegerTheory.GreatestCommonDivisor(new long[0]), "Gcd()");
             Assert.AreEqual(100, IntegerTheory.GreatestCommonDivisor(-100), "Gcd(-100)");
         }
 
@@ -101,7 +101,7 @@ namespace MathNet.Numerics.UnitTests.NumberTheoryTests
         {
             Assert.Throws(
                 typeof (ArgumentNullException),
-                () => IntegerTheory.GreatestCommonDivisor(null));
+                () => IntegerTheory.GreatestCommonDivisor((long[])null));
         }
 
         [Test]
@@ -147,7 +147,7 @@ namespace MathNet.Numerics.UnitTests.NumberTheoryTests
         [Test]
         public void ListLcmHandlesSpecialInputCorrectly()
         {
-            Assert.AreEqual(1, IntegerTheory.LeastCommonMultiple(), "Lcm()");
+            Assert.AreEqual(1, IntegerTheory.LeastCommonMultiple(new long[0]), "Lcm()");
             Assert.AreEqual(100, IntegerTheory.LeastCommonMultiple(-100), "Lcm(-100)");
         }
 
@@ -156,7 +156,7 @@ namespace MathNet.Numerics.UnitTests.NumberTheoryTests
         {
             Assert.Throws(
                 typeof(ArgumentNullException),
-                () => IntegerTheory.LeastCommonMultiple(null));
+                () => IntegerTheory.LeastCommonMultiple((long[])null));
         }
     }
 }

src/UnitTests/NumberTheoryTests/GcdRelatedTestBigInteger.cs

@@ -0,0 +1,173 @@
+// <copyright file="GcdRelatedTest.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 System.Numerics;
+    using MbUnit.Framework;
+    using NumberTheory;
+
+    [TestFixture]
+    public class GcdRelatedTestBigInteger
+    {
+        [Test]
+        public void GcdHandlesNormalInputCorrectly()
+        {
+			Assert.AreEqual(0, IntegerTheory.GreatestCommonDivisor(BigInteger.Zero, BigInteger.Zero), "Gcd(0,0)");
+			Assert.AreEqual(6, IntegerTheory.GreatestCommonDivisor(BigInteger.Zero, 6), "Gcd(0,6)");
+			Assert.AreEqual(1, IntegerTheory.GreatestCommonDivisor((BigInteger)7, 13), "Gcd(7,13)");
+			Assert.AreEqual(7, IntegerTheory.GreatestCommonDivisor((BigInteger)7, 14), "Gcd(7,14)");
+			Assert.AreEqual(1, IntegerTheory.GreatestCommonDivisor((BigInteger)7, 15), "Gcd(7,15)");
+			Assert.AreEqual(3, IntegerTheory.GreatestCommonDivisor((BigInteger)6, 15), "Gcd(6,15)");
+        }
+
+        [Test]
+        public void GcdHandlesNegativeInputCorrectly()
+        {
+			Assert.AreEqual(5, IntegerTheory.GreatestCommonDivisor((BigInteger)(-5), 0), "Gcd(-5,0)");
+			Assert.AreEqual(5, IntegerTheory.GreatestCommonDivisor(BigInteger.Zero, -5), "Gcd(0, -5)");
+			Assert.AreEqual(1, IntegerTheory.GreatestCommonDivisor((BigInteger)(-7), 15), "Gcd(-7,15)");
+			Assert.AreEqual(1, IntegerTheory.GreatestCommonDivisor((BigInteger)(-7), -15), "Gcd(-7,-15)");
+        }
+
+        [Test]
+        public void GcdSupportsLargeInput()
+        {
+			Assert.AreEqual(Int32.MaxValue, IntegerTheory.GreatestCommonDivisor(BigInteger.Zero, Int32.MaxValue), "Gcd(0,Int32Max)");
+			Assert.AreEqual(Int64.MaxValue, IntegerTheory.GreatestCommonDivisor(BigInteger.Zero, Int64.MaxValue), "Gcd(0,Int64Max)");
+			Assert.AreEqual(1, IntegerTheory.GreatestCommonDivisor((BigInteger)Int32.MaxValue, Int64.MaxValue), "Gcd(Int32Max,Int64Max)");
+			Assert.AreEqual(1 << 18, IntegerTheory.GreatestCommonDivisor((BigInteger)(1 << 18), 1 << 20), "Gcd(1>>18,1<<20)");
+			Assert.AreEqual(1 << 18, IntegerTheory.GreatestCommonDivisor((BigInteger)(1 << 18), 1 << 20), "Gcd(1>>18,1<<20)");
+			Assert.AreEqual(4569031055798, IntegerTheory.GreatestCommonDivisor(BigInteger.Parse("7305316061155559483748611586449542122662"), BigInteger.Parse("57377277362010117405715236427413896")), "Gcd(large)");
+        }
+
+		[Test]
+		public void ExtendedGcdHandlesNormalInputCorrectly()
+		{
+			BigInteger x, y;
+
+			Assert.AreEqual(3, IntegerTheory.ExtendedGreatestCommonDivisor((BigInteger)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((BigInteger)(-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((BigInteger)(-6), -15, out x, out y), "Egcd(-6,-15)");
+			Assert.AreEqual(3, -6 * x + -15 * y, "Egcd(-6,-15) -> a*x+b*y");
+
+			var a = BigInteger.Parse("7305316061155559483748611586449542122662");
+			var b = BigInteger.Parse("57377277362010117405715236427413896");
+			Assert.AreEqual(4569031055798, IntegerTheory.ExtendedGreatestCommonDivisor(a, b, out x, out y), "Egcd(large)");
+			Assert.AreEqual(4569031055798, a * x + b * y, "Egcd(large) -> a*x+b*y");
+			Assert.AreEqual(4569031055798, IntegerTheory.ExtendedGreatestCommonDivisor(-a, b, out x, out y), "Egcd(-large)");
+			Assert.AreEqual(4569031055798, -a * x + b * y, "Egcd(-large) -> a*x+b*y");
+		}
+
+        [Test]
+        public void ListGcdHandlesNormalInputCorrectly()
+        {
+			Assert.AreEqual(2, IntegerTheory.GreatestCommonDivisor((BigInteger)(-10), 6, -8), "Gcd(-10,6,-8)");
+			Assert.AreEqual(1, IntegerTheory.GreatestCommonDivisor((BigInteger)(-10), 6, -8, 5, 9, 13), "Gcd(-10,6,-8,5,9,13)");
+			Assert.AreEqual(5, IntegerTheory.GreatestCommonDivisor((BigInteger)(-10), 20, 120, 60, -15, 1000), "Gcd(-10,20,120,60,-15,1000)");
+			Assert.AreEqual(3, IntegerTheory.GreatestCommonDivisor((BigInteger)(Int64.MaxValue - 1), Int64.MaxValue - 4, Int64.MaxValue - 7), "Gcd(Int64Max-1,Int64Max-4,Int64Max-7)");
+			Assert.AreEqual(123, IntegerTheory.GreatestCommonDivisor((BigInteger)492, -2 * 492, 492 / 4), "Gcd(492, -984, 123)");
+        }
+
+        [Test]
+        public void ListGcdHandlesSpecialInputCorrectly()
+        {
+            Assert.AreEqual(0, IntegerTheory.GreatestCommonDivisor(new BigInteger[0]), "Gcd()");
+			Assert.AreEqual(100, IntegerTheory.GreatestCommonDivisor((BigInteger)(-100)), "Gcd(-100)");
+        }
+
+        [Test]
+        public void ListGcdChecksForNullArguments()
+        {
+            Assert.Throws(
+                typeof (ArgumentNullException),
+				() => IntegerTheory.GreatestCommonDivisor((BigInteger[])null));
+        }
+
+        [Test]
+        public void LcmHandlesNormalInputCorrectly()
+        {
+			Assert.AreEqual(10, IntegerTheory.LeastCommonMultiple((BigInteger)10, 10), "Lcm(10,10)");
+
+			Assert.AreEqual(0, IntegerTheory.LeastCommonMultiple(BigInteger.Zero, 10), "Lcm(0,10)");
+			Assert.AreEqual(0, IntegerTheory.LeastCommonMultiple((BigInteger)10, 0), "Lcm(10,0)");
+
+			Assert.AreEqual(77, IntegerTheory.LeastCommonMultiple((BigInteger)11, 7), "Lcm(11,7)");
+			Assert.AreEqual(33, IntegerTheory.LeastCommonMultiple((BigInteger)11, 33), "Lcm(11,33)");
+			Assert.AreEqual(374, IntegerTheory.LeastCommonMultiple((BigInteger)11, 34), "Lcm(11,34)");
+        }
+
+        [Test]
+        public void LcmHandlesNegativeInputCorrectly()
+        {
+			Assert.AreEqual(352, IntegerTheory.LeastCommonMultiple((BigInteger)11, -32), "Lcm(11,-32)");
+			Assert.AreEqual(352, IntegerTheory.LeastCommonMultiple((BigInteger)(-11), 32), "Lcm(-11,32)");
+			Assert.AreEqual(352, IntegerTheory.LeastCommonMultiple((BigInteger)(-11), -32), "Lcm(-11,-32)");
+        }
+
+        [Test]
+        public void LcmSupportsLargeInput()
+        {
+			Assert.AreEqual(Int32.MaxValue, IntegerTheory.LeastCommonMultiple((BigInteger)Int32.MaxValue, Int32.MaxValue), "Lcm(Int32Max,Int32Max)");
+			Assert.AreEqual(Int64.MaxValue, IntegerTheory.LeastCommonMultiple((BigInteger)Int64.MaxValue, Int64.MaxValue), "Lcm(Int64Max,Int64Max)");
+			Assert.AreEqual(Int64.MaxValue, IntegerTheory.LeastCommonMultiple((BigInteger)(-Int64.MaxValue), -Int64.MaxValue), "Lcm(-Int64Max,-Int64Max)");
+			Assert.AreEqual(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)");
+        }
+
+        [Test]
+        public void ListLcmHandlesNormalInputCorrectly()
+        {
+			Assert.AreEqual(120, IntegerTheory.LeastCommonMultiple((BigInteger)(-10), 6, -8), "Lcm(-10,6,-8)");
+			Assert.AreEqual(4680, IntegerTheory.LeastCommonMultiple((BigInteger)(-10), 6, -8, 5, 9, 13), "Lcm(-10,6,-8,5,9,13)");
+			Assert.AreEqual(3000, IntegerTheory.LeastCommonMultiple((BigInteger)(-10), 20, 120, 60, -15, 1000), "Lcm(-10,20,120,60,-15,1000)");
+			Assert.AreEqual(984, IntegerTheory.LeastCommonMultiple((BigInteger)492, -2 * 492, 492 / 4), "Lcm(492, -984, 123)");
+			Assert.AreEqual(2016, IntegerTheory.LeastCommonMultiple((BigInteger)32, 42, 36, 18), "Lcm(32,42,36,18)");
+        }
+
+        [Test]
+        public void ListLcmHandlesSpecialInputCorrectly()
+        {
+            Assert.AreEqual(1, IntegerTheory.LeastCommonMultiple(new BigInteger[0]), "Lcm()");
+			Assert.AreEqual(100, IntegerTheory.LeastCommonMultiple((BigInteger)(-100)), "Lcm(-100)");
+        }
+
+        [Test]
+        public void ListLcmChecksForNullArguments()
+        {
+            Assert.Throws(
+                typeof(ArgumentNullException),
+                () => IntegerTheory.LeastCommonMultiple((BigInteger[])null));
+        }
+    }
+}

src/UnitTests/NumberTheoryTests/IntegerTheoryTest.cs

@@ -29,6 +29,7 @@
 namespace MathNet.Numerics.UnitTests.NumberTheoryTests
 {
     using System;
+    using System.Numerics;
     using NumberTheory;
     using MbUnit.Framework;
 

src/UnitTests/UnitTests.csproj

@@ -128,6 +128,7 @@
     <Compile Include="LinearAlgebraTests\Double\DenseVectorTests.cs" />
     <Compile Include="LinearAlgebraTests\Double\UserDefinedVectorTests.cs" />
     <Compile Include="LinearAlgebraTests\Double\VectorTests.cs" />
+    <Compile Include="NumberTheoryTests\GcdRelatedTestBigInteger.cs" />
     <Compile Include="NumberTheoryTests\GcdRelatedTest.cs" />
     <Compile Include="NumberTheoryTests\IntegerTheoryTest.cs" />
     <Compile Include="PrecisionTest.cs" />