public void GreatestCommonDivisor_For_21_And_15_Is_3()
{
var greatestCommonDivisor = new GreatestCommonDivisor();
var result = greatestCommonDivisor.Calculate(21, 15);
Assert.AreEqual(3, result);
}
public void FindGCD_BothAreZero()
{
var gcdEuclidean = GreatestCommonDivisor.FindGCDEuclidean(0, 0);
Assert.Equal(0, gcdEuclidean);
var gcdStein = GreatestCommonDivisor.FindGCDStein(0, 0);
Assert.Equal(0, gcdStein);
}
public void FindGCD_BothNumberAreNegative(int a, int b, int expected)
{
var gcdEuclidean = GreatestCommonDivisor.FindGCDEuclidean(a, b);
Assert.Equal(expected, gcdEuclidean);
var gcdStein = GreatestCommonDivisor.FindGCDStein(a, b);
Assert.Equal(expected, gcdStein);
}
public void FindGCD_SecondIsZero(int a, int b, int expected)
{
var gcdEuclidean = GreatestCommonDivisor.FindGCDEuclidean(a, b);
Assert.Equal(expected, gcdEuclidean);
var gcdStein = GreatestCommonDivisor.FindGCDStein(a, b);
Assert.Equal(expected, gcdStein);
}
public GcdResult Calculate(int[] numbers)
{
var iterationsCount = 0;
var gcdResult = new GcdResult
{
Gcd = GreatestCommonDivisor.GCDStainAlgorithm(numbers[0], numbers[1], out iterationsCount),
IterationsCount = iterationsCount
};
return(gcdResult);
}
public void CalculateEuclideanGCD_1068And3096_12Returned()
{
//arrange
int a = 1068;
int b = 3096;
//act
int result = GreatestCommonDivisor.CalculateEuclideanGCD(a, b);
//assert
Assert.AreEqual(12, result);
}
public void CalculateSteinGCD_1071And462_21Returned()
{
//arrange
int a = 1071;
int b = 462;
//act
int result = GreatestCommonDivisor.CalculateSteinGCD(a, b);
//assert
Assert.AreEqual(21, result);
}
public static int[] DivisorRelativeRequences(int[] freq)
{
int maxDivisor = GreatestCommonDivisor.GetGreatestCommonDivisor(freq);
if (maxDivisor > 1)
{
for (int i = 0; i < freq.Length; i++)
{
freq[i] /= maxDivisor;
}
}
return(freq);
}
public void GetGCDTest()
{
GreatestCommonDivisor gcd = new GreatestCommonDivisor();
int result = gcd.GetGCDbyEvclideAl(15, 0);
Assert.AreEqual(result, 15);
result = gcd.GetGCDbyEvclideAl(15, -5);
Assert.AreEqual(result, 5);
result = gcd.GetGCDSteinAl(15, 0);
Assert.AreEqual(result, 15);
result = gcd.GetGCDSteinAl(15, -5);
Assert.AreEqual(result, 5);
}
public GcdResult Calculate(int[] numbers)
{
var iterationsCount = 0;
var gcdResult = new GcdResult();
if (numbers.Length == 5)
{
gcdResult.Gcd = GreatestCommonDivisor.GCDEuclideanAlgorithm(numbers[0], numbers[1], numbers[2], numbers[3], numbers[4]);
}
if (numbers.Length == 4)
{
gcdResult.Gcd = GreatestCommonDivisor.GCDEuclideanAlgorithm(numbers[0], numbers[1], numbers[2], numbers[3]);
}
if (numbers.Length == 3)
{
gcdResult.Gcd = GreatestCommonDivisor.GCDEuclideanAlgorithm(numbers[0], numbers[1], numbers[2]);
}
if (numbers.Length == 2)
{
gcdResult.Gcd = GreatestCommonDivisor.GCDEuclideanAlgorithm(numbers[0], numbers[1], out iterationsCount);
gcdResult.IterationsCount = iterationsCount;
}
return(gcdResult);
}
public static void EuclidsAlgorithmTest(int expected, params int[] numbers)
{
Assert.AreEqual(expected, GreatestCommonDivisor.EuclidsAlgorithm(numbers));
}
public static void EuclidsAlgorithmTest_Numbers_ArgumentNullException(FindingDelegateGCD findingDelegateGCD, params int[] numbers) => Assert.Throws <ArgumentNullException>(() => GreatestCommonDivisor.EuclidMethodForFindingGCD(findingDelegateGCD, numbers));
public static void EuclidsAlgorithmTest(FindingDelegateGCD findingDelegateGCD, int expected, int a, int b)
{
Assert.AreEqual(expected, GreatestCommonDivisor.EuclidMethodForFindingGCD(findingDelegateGCD, a, b));
}
public static void EuclidsAlgorithmTest(FindingDelegateGCD findingDelegateGCD, int expected, params int[] numbers)
{
Assert.AreEqual(expected, GreatestCommonDivisor.EuclidMethodForFindingGCD(findingDelegateGCD, numbers));
}
public int EuclideanAlgorithmSimpleTest(params int[] numbers) => GreatestCommonDivisor.EuclideanAlgorithm(numbers);
public int Test(int a, int b) => GreatestCommonDivisor.Gcd(a, b);
public void Gcd_For_NullValue_ThrowArgumentNullException()
{
var actual = GreatestCommonDivisor.Find(null);
}
public void Gcd_For_0p9_And_1p2_Is_0p3(double a, double b, double expected)
{
var actual = GreatestCommonDivisor.Find(a, b);
Assert.IsTrue(Math.Abs(actual - expected) < double.Epsilon);
}
public void Gcd_For_Equal_Numbers_Is_Number(double a, double b, double expected)
{
var actual = GreatestCommonDivisor.Find(a, b);
Assert.IsTrue(Math.Abs(actual - expected) < double.Epsilon);
}
public int BinaryAlgorithmSimpleTest(params int[] numbers) => GreatestCommonDivisor.BinaryAlgorithm(numbers);
public int BinaryAlgorithmTwoArguments(int a, int b) => GreatestCommonDivisor.BinaryAlgorithm(a, b);
public void BinaryAlgorithmArgumentException(params int[] numbers)
{
Assert.Throws <ArgumentException>(() => GreatestCommonDivisor.BinaryAlgorithm(numbers));
}
public int EuclideanAlgorithmTwoArguments(int a, int b) => GreatestCommonDivisor.EuclideanAlgorithm(a, b);
public static void EuclidsAlgorithmTest(int expected, int a, int b)
{
Assert.AreEqual(expected, GreatestCommonDivisor.BinaryEuclideanAlgoritm(a, b));
}
public void EuclideanAlgorithm_ab_gcdReturn(int expected, int a, int b)
{
TimeSpan ts;
Assert.AreEqual(expected, GreatestCommonDivisor.EuclideanAlgorithm(out ts, a, b));
}
public static void EuclidsAlgorithmTest_Numbers_ArgumentNullException(params int[] numbers) => Assert.Throws <ArgumentNullException>(() => GreatestCommonDivisor.BinaryEuclideanAlgoritm(numbers));
public void BinaryAlgorithm_abc_gcdReturn(int expected, int a, int b, int c)
{
TimeSpan ts;
Assert.AreEqual(expected, GreatestCommonDivisor.BinaryAlgorithm(out ts, a, b, c));
}
public void Gcd_For_ZeroItems_ThrowArgumentOutOfRangeException()
{
var actual = GreatestCommonDivisor.Find(new List <double>());
}
public void BinaryAlgorithm_params_gcdReturn(int expected, params int[] arrayValue)
{
TimeSpan ts;
Assert.AreEqual(expected, GreatestCommonDivisor.BinaryAlgorithm(out ts, arrayValue));
}
public GreatestCommonDivisorTest()
{
_greatestCommonDivisor = new GreatestCommonDivisor();
}
/**
* Calculates the least common multiple of two numbers
*
* @param int firstNumber
* @param int secondNumber
* @return int
*/
public int leastCommonMultiple(int firstNumber, int secondNumber)
{
GreatestCommonDivisor gcd = new GreatestCommonDivisor();
return(Math.Abs(firstNumber * secondNumber) / gcd.greatestCommonDivisor(firstNumber, secondNumber));
}
