//Получение чисел через шину
public FibonacciNumbers GetNumbers(ref bool isInitialization)
{
FibonacciNumbers numbers = null;
try
{
LogConfig.Log.Info("Получение данных через шину");
//Если инициализация расчета, то возвращаем первые числа последовательности из FibonacciInitials - GetNumbers
if (!isInitialization)
{
var bus = Bus.Factory.CreateUsingRabbitMq(x =>
{
var host = x.Host(new Uri("rabbitmq://localhost/"), h => { });
x.ReceiveEndpoint(host, "FibonacciNumbers", e => e.Consumer <ConsumerService>());
});
bus.Start();
//Для получения чисел после Start происходит вызов подписанного ConsumerService
bus.Stop();
}
isInitialization = false;
numbers = Models.Fibonacci.GetNumbers();
}
catch (Exception ex)
{
LogConfig.Log.Error($"Ошибка при получении данных через шину: {ex}");
}
return(numbers);
}
public override Result Run(Params p)
{
if (p.Alfa.Size != 2)
{
throw new Exception(Name + " ошибка: интервал локализации минимума не состоит из двух точек");
}
// устанавливаем функцию
f = p.Y;
Params cP = (Params)p.Clone();
if (NormalizationDirections && cP.P.Norma > 1.0)
{
cP.P = cP.P.Rationing();
}
Result result = cP.ToResult();
Vector x = result.ListX[0], P = result.ListP[0];
int n = 0; // номер числа фибоначчи
double Fn = FibonacciNumbers.getPrevNumberFibonacci(System.Math.Abs(result.Alfas[0] - result.Alfas[1]) / Lim.Eps, ref n),
Fnm = FibonacciNumbers.getNNumberFibonacci(n - 1);
int chet = n % 2 == 1 ? -1 : 1;
double lambda = result.Alfas[0] + Fnm * System.Math.Abs(result.Alfas[0] - result.Alfas[1]) / Fn + chet * Lim.Eps / Fn, mu,
f1, f2;
while (result.K <= Lim.K)
{
mu = result.Alfas[0] + result.Alfas[1] - lambda;
f1 = f.Parse(X(x, lambda, P));
f2 = f.Parse(X(x, mu, P));
if (lambda < mu && f1 < f2)
{
result.Alfas[1] = mu;
}
else if (lambda < mu && f1 > f2)
{
result.Alfas[0] = lambda;
lambda = mu;
}
else if (lambda > mu && f1 < f2)
{
result.Alfas[0] = mu;
}
else if (lambda > mu && f1 > f2)
{
result.Alfas[1] = lambda;
lambda = mu;
}
if (result.K == n)
{
break;
}
result.K++;
}
result.AlfaMin = (result.Alfas[1] + result.Alfas[0]) / 2.0;
result.XMin = X(x, result.AlfaMin, P);
return(result);
}
public static void GetNumsUpToIndexTests(
int i, IEnumerable <long> expected)
{
var actual = FibonacciNumbers.GetNumsUpToIndex(i);
Assert.AreEqual(expected, actual);
}
public void EvenFibonacciNumbers_SumOfEvenNumbersInSequence_ToFourMillion()
{
var fn = new FibonacciNumbers(1, 2, 4000000);
long expected = 4613730;
Assert.AreEqual(expected, fn.SumOfEvenNumbersInSequence());
}
public ulong Run(ulong targetNumber)
{
var fibonacci = new FibonacciNumbers();
var numbers = fibonacci.GetFibonacciNumbersUpToN(targetNumber);
return (ulong) numbers.Sum(num => num % 2 == 0 ? num : 0d);
}
public void FibonacciShouldPrintFirstNumber()
{
FibonacciNumbers fib = new FibonacciNumbers();
int expected = 0;
int actual = fib.GetFirst();
Assert.AreEqual(expected, actual);
}
public void Handler(FibonacciNumbers numbers)
{
//Вычисление следующего числа последовательности
var nextSequenceNumbers = _fibonacciService.Calculate(numbers);
//Отправка чисел через MassTransitBus
_busService.SendNumbers(nextSequenceNumbers);
}
public void FibonacciNumbersFindFibonacciByIndex_11()
{
FibonacciNumbers fb = new FibonacciNumbers();
double actual = fb.FindFibonacciNumber(11);
double expected = 89;
Assert.AreEqual(expected, actual);
}
static void Main()
{
FibonacciNumbers fn = new FibonacciNumbers();
for (int i = 0; i <= 100;i++ )
{
Console.WriteLine("Fibonacci Number {0} is:{1}",i,fn.fibonacci(i));
}
}
public void FibonacciNumbersRedisCache()
{
FibonacciNumbers fibonacci = new FibonacciNumbers(new FibonacciRedisCache("localhost"));
for (int i = 0; i < expectedValues.Length; i++)
{
Assert.AreEqual(expectedValues[i], fibonacci.Get(i));
}
}
public void FibonacciPrintSequenceOfNumbers()
{
FibonacciNumbers fib = new FibonacciNumbers();
int length = 7;
string expected = "0 1 1 2 3 5 8";
string actual = fib.ToString(fib.GetSequence(length));
Assert.AreEqual(expected, actual);
}
public void DPSumThrowsForNegativeValues()
{
Action action1 = () => FibonacciNumbers.DPSum(-1);
action1.ShouldThrow <ArgumentException>();
Action action2 = () => FibonacciNumbers.DPSum(-10);
action2.ShouldThrow <ArgumentException>();
}
public void FibonacciShouldPrintNextNumber()
{
FibonacciNumbers fib = new FibonacciNumbers();
int input = 1;
int expected = 1;
int actual = fib.GetNext(input);
Assert.AreEqual(expected, actual);
}
public void FibonacciShouldPrintAVariableSequenceOfNumbers()
{
FibonacciNumbers fib = new FibonacciNumbers();
int input = 8;
int[] expected = new int[] { 0, 1, 1, 2, 3, 5, 8, 13 };
int[] actual = fib.GetSequence(input);
CollectionAssert.AreEqual(expected, actual);
}
public void FibonacciNumbersMemoryCache()
{
FibonacciNumbers fibonacci = new FibonacciNumbers(new FibonacciMemoryCache());
for (int i = 0; i < expectedValues.Length; i++)
{
Assert.AreEqual(expectedValues[i], fibonacci.Get(i));
}
}
public void FibonacciNumbers_Generate_InvalidData_Test(ulong count)
{
Assert.Throws <ArgumentException>(() =>
{
foreach (var number in FibonacciNumbers.Generate(count))
{
}
});
}
public void FibFrogTest()
{
var fibFrog = new FibonacciNumbers();
Assert.True(fibFrog.FibCount(100000) > 23);
var A = new int[] { 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0 };
Assert.Equal(3, fibFrog.FibFrog(A));
}
static void Main(string[] args)
{
FibonacciNumbers f = new FibonacciNumbers(200000);
foreach (int n in f)
{
Console.WriteLine(n);
}
Console.ReadKey();
}
public void GetNumbersTest_PositiveNumber_Success(int arg)
{
var expectedResult = new List <int>()
{
1, 1, 2, 3, 5, 8, 13
};
var result = FibonacciNumbers.GetNumbers(arg).ToList();
CollectionAssert.AreEqual(expectedResult, result);
}
public void FiboGenerated_NumberOfElementsLessThenZero_ArgumentOutOfRangeException(int numberOfElements)
{
var ex = Assert.Catch <ArgumentOutOfRangeException>(() =>
{
List <int> list = new List <int>(FibonacciNumbers.FiboGenerate(numberOfElements));
}
);
StringAssert.Contains($"{nameof(numberOfElements)} must be a positive number", ex.Message);
}
private static void FibonacciFunctionality()
{
var fibonacci = FibonacciNumbers.GetNumbers(6).ToList();
foreach (var num in fibonacci)
{
Console.Write($"{num} ");
}
Console.WriteLine();
}
static void Main()
{
int i = 0;
foreach (var number in FibonacciNumbers.GetNumbers(92))
{
i++;
Console.WriteLine("{0}: {1}", i, number);
}
Console.ReadKey();
}
public void FibonacciNumbersBoundsWithOneNumber()
{
int a = 5;
int b = 5;
string expected = "5";
FibonacciNumbers fb = new FibonacciNumbers(a, b);
string actual = fb.ToString();
Assert.AreEqual(expected, actual);
}
public void FibonacciNumbersBoundsWithFibonacciNumber()
{
int a = 5;
int b = 144;
string expected = "5,8,13,21,34,55,89,144";
FibonacciNumbers fb = new FibonacciNumbers(a, b);
string actual = fb.ToString();
Assert.AreEqual(expected, actual);
}
public void ReturnFibonacciNumbersTest()
{
var input = 6;
var fibonacciNumber = FibonacciNumbers.ReturnFibonacciNumbers(input);
var actual = new List <int>(fibonacciNumber);
var expected = new List <int> {
0, 1, 1, 2, 3, 5
};
CollectionAssert.AreEqual(expected, actual, "{0} != {1}", expected, actual);
}
public void FibonacciNumbersBoundsWithSmallUsualValues()
{
int a = 4;
int b = 50;
string expected = "5,8,13,21,34";
FibonacciNumbers fb = new FibonacciNumbers(a, b);
string actual = fb.ToString();
Assert.AreEqual(expected, actual);
}
public void GetFibonacciNumber_ArgumentOutOfRangeExceptionTests(int count, int firstNumber)
{
Assert.Throws <ArgumentOutOfRangeException>(() =>
{
FibonacciNumbers fibonacciNumbersGetter = new FibonacciNumbers(firstNumber);
foreach (var fibonacciNumber in fibonacciNumbersGetter.GetFibonacciNumber(count))
{
}
});
}
public void GenerateSequence_Pass25CountOfNumbres_ReturnFibanacciSequence(int count)
{
// Arrange
BigInteger[] expectedResult = new BigInteger[] { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025 };
// Act
BigInteger[] actualResult = FibonacciNumbers.GenerateSequence(count).ToArray();
// Assert
CollectionAssert.AreEqual(expectedResult, actualResult);
}
public IEnumerable <ulong> FibonacciNumbers_Generate_ValidData_Test(ulong count)
{
List <ulong> fibonucciList = new List <ulong>();
foreach (var number in FibonacciNumbers.Generate(count))
{
fibonucciList.Add(number);
}
return(fibonucciList);
}
public void FiboGenerate_NumberOfElementsToBeGenerated_IEnumerableObjectOfFibonacciNumbers
(int numberOfElements, IEnumerable <int> expectedCollection)
{
List <int> result = new List <int>(FibonacciNumbers.FiboGenerate(numberOfElements));
int index = 0;
Assert.AreEqual(result.Count(), expectedCollection.Count());
foreach (int i in expectedCollection)
{
Assert.AreEqual(result.ElementAt(index++), i);
}
}
public void FibonacciShouldPrintNextNumber()
{
FibonacciNumbers fib = new FibonacciNumbers();
int[] array = new int[] { 0, 1, 1, 2, 3, 5 };
int input = array.Last();
int expected = 8;
int actual = // fib.GetNextFib(input);
input + array.ElementAt(array.Length - 2);
Assert.AreEqual(expected, actual);
}
