private static string FormatResult(IEnumerable <int> numbers, GcdResult result)
{
var s = new StringBuilder();
s.Append("GCD( ")
.Append(string.Concat(numbers.Select(x => $"{x.ToString()} ")))
.Append($") = {result.GreatestCommonDivisor}")
.Append(result.IterationsCount == 0 ? "\n" : $" and number of iterations = {result.IterationsCount}\n");
return(s.ToString());
}
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);
}
private static GcdResult RunAlgorithmStain(int firstNumber, int secondNumber, int step = 0, GcdResult intermediateResult = null)
{
if (intermediateResult == null)
{
intermediateResult = new GcdResult();
}
while (true)
{
step++;
intermediateResult.AddCalculationHistory(firstNumber, secondNumber, step);
intermediateResult.IterationsCount = step;
if (firstNumber == secondNumber)
{
intermediateResult.GreatestCommonDivisor = firstNumber;
return(intermediateResult);
}
if (firstNumber == 1 || secondNumber == 1)
{
intermediateResult.GreatestCommonDivisor = 1;
return(intermediateResult);
}
if (IsEven(firstNumber) && IsEven(secondNumber))
{
intermediateResult = RunAlgorithmStain(firstNumber >> 1, secondNumber >> 1, step, intermediateResult);
intermediateResult.GreatestCommonDivisor <<= 1;
return(intermediateResult);
}
if (IsEven(firstNumber))
{
firstNumber = firstNumber >> 1;
continue;
}
if (IsEven(secondNumber))
{
secondNumber = secondNumber >> 1;
continue;
}
var previousFirstNumber = firstNumber;
firstNumber = secondNumber;
secondNumber = Math.Abs(previousFirstNumber - secondNumber);
}
}
private void RunAlgorithm(AlgorithmType algorithmType)
{
if (!ValidateUserInput(GetUserInput()))
{
ShowWarningMessage();
return;
}
var numbers = ParseUserInput(GetUserInput());
_result = GreatestCommonDivisorCalculator.Calculate(numbers, algorithmType);
EnableCreatingChart(numbers.Length);
lblresult.Text += FormatResult(numbers, _result);
}
private static GcdResult RunAlgorithmEuclidean(int first, int second, GcdResult intermediateResult = null)
{
if (intermediateResult == null)
{
intermediateResult = new GcdResult();
}
while (second != 0)
{
intermediateResult.IterationsCount++;
intermediateResult.AddCalculationHistory(first, second, intermediateResult.IterationsCount);
second = first % (first = second);
}
intermediateResult.AddCalculationHistory(first, first, ++intermediateResult.IterationsCount);
intermediateResult.GreatestCommonDivisor = first;
return(intermediateResult);
}
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 void CalculateGcd(string userInput, GcdAlgorithmType algorithmType)
{
var algorithm = GetAlgorithmByType(algorithmType);
Result = CalculateGcd(userInput, algorithm);
}
public GcdCalculationDriver()
{
Numbers = new int[0];
Result = new GcdResult();
}
