public void DoDemonstration()
{
// Two instances of the calculator are created. One is named "Odd"
// (it calculates the 1st, 3rd, 5th... values in the sequence) the
// other is named "Even". They message each other back and forth
// with the latest two values and successively build the sequence.
var limit = 1000;
// Two channels for communication. Naming convention is inbound.
var oddChannel = new Channel <IntPair>();
var evenChannel = new Channel <IntPair>();
using (ThreadFiber oddFiber = new ThreadFiber(), evenFiber = new ThreadFiber())
{
oddFiber.Start();
var oddCalculator = new FibonacciCalculator(oddFiber, "Odd", oddChannel, evenChannel, limit);
evenFiber.Start();
new FibonacciCalculator(evenFiber, "Even", evenChannel, oddChannel, limit);
oddCalculator.Begin(new IntPair(0, 1));
oddFiber.Join();
evenFiber.Join();
}
}
public ActionResult <BigInteger> Get()
{
using (var reader = new StreamReader(Request.Body))
{
var body = reader.ReadToEnd();
switch (Request.ContentType)
{
case "text/plain; charset=utf-8":
case "text/plain":
if (long.TryParse(body, out var index))
{
try
{
Response.Headers.Add(FibonacciRequestedTag, index.ToString());
return(FibonacciCalculator.Calculate(index));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
return(BadRequest($"Invalid Index Value: ''{body}''"));
default:
return(BadRequest("Only Contenttype text/plain accepted"));
}
}
}
public void GetFibonacciIterator_GetDescIterator()
{
var calculator = new FibonacciCalculator();
var iterator = calculator.GetFibonacciIterator(10, -5);
Assert.IsInstanceOf(typeof(FibonacciDescIterator), iterator);
}
public void CanFindPositionOfValueEightWithDefaultConstructor()
{
var x = new FibonacciCalculator();
var y = x.CalculatePositionOfValue(8);
Assert.AreEqual(5, y);
}
public void CanFindPositionOfValueFortyWithConstructorParam()
{
var x = new FibonacciCalculator(5);
var y = x.CalculatePositionOfValue(40);
Assert.AreEqual(5, y);
}
public void ValueOfPositionFiveIsEightWithDefaultConstructor()
{
var x = new FibonacciCalculator();
var y = x.CalculateValueOfPosition(5);
Assert.AreEqual(8, y);
}
public void DoDemonstration()
{
// Two instances of the calculator are created. One is named "Odd"
// (it calculates the 1st, 3rd, 5th... values in the sequence) the
// other is named "Even". They message each other back and forth
// with the latest two values and successively build the sequence.
var limit = 1000;
// Two channels for communication. Naming convention is inbound.
var oddChannel = new Channel<IntPair>();
var evenChannel = new Channel<IntPair>();
using (ThreadFiber oddFiber = new ThreadFiber(), evenFiber = new ThreadFiber())
{
oddFiber.Start();
var oddCalculator = new FibonacciCalculator(oddFiber, "Odd", oddChannel, evenChannel, limit);
evenFiber.Start();
new FibonacciCalculator(evenFiber, "Even", evenChannel, oddChannel, limit);
oddCalculator.Begin(new IntPair(0, 1));
oddFiber.Join();
evenFiber.Join();
}
}
static void Main(string[] args)
{
var fibonacciNumbers = FileUtility.ReadNumbersFromFile(INPUT_FILE);
var processingType = FibonacciCalculator.GetProcessingType();
Console.Write("Enter the number of Actors: ");
var numberOfActors = Int32.Parse(Console.ReadLine());
Console.WriteLine($"\nRuning with {numberOfActors} Actors.");
ProcessFibonacciWithActors(fibonacciNumbers, numberOfActors, processingType);
//Task.Run(() =>
//{
// for (int i = 1; i <= 32; i *= 2)
// {
// Console.WriteLine($"\nRuning with {i} Actors.");
// ProcessFibonacciWithActors(fibonacciNumbers, i, processingType);
// Thread.Sleep(25 * 1000);
// }
//});
Console.ReadLine();
}
public void Fibonacci_When100_ShouldReturn354224848179261915075()
{
var expected = BigInteger.Parse("354224848179261915075");
FibonacciCalculator Calculator = new FibonacciCalculator();
var result = Calculator.CalculateValue(100);
Assert.AreEqual(expected.ToString(), result);
}
public void ReturnFibonacciNumberWhenTestFails()
{
FibonacciCalculator fibonacciCalculator = new FibonacciCalculator();
const int ExpectedResult = -1;
var result = fibonacciCalculator.Fibonacci(10);
Assert.AreEqual(ExpectedResult, result);
}
public void ReturnFibonacciNumberWhenInputIsLessThanOne()
{
FibonacciCalculator fibonacciCalculator = new FibonacciCalculator();
const int ExpectedResult = -1;
var result = fibonacciCalculator.Fibonacci(0);
Assert.AreEqual(ExpectedResult, result);
}
public void TestFibonacciOutsideLimit()
{
FibonacciCalculator fibCal = new FibonacciCalculator();
var exception = Assert.Throws <System.NotSupportedException>(() => fibCal.Calculate(11));
Assert.That(exception.Message, Is.EqualTo("n > 10 is not supported"));
}
public void ReturnFibonacciNumberWhenRegularCase()
{
FibonacciCalculator fibonacciCalculator = new FibonacciCalculator();
const int ExpectedResult = 2;
var result = fibonacciCalculator.Fibonacci(3);
Assert.AreEqual(ExpectedResult, result);
}
public void Next(int n, string guid)
{
// Добавляем запрос в очередь на обработку
FibonacciCalculator.Enqueue(new FibonacciReq()
{
id = guid, previousNumber = n
});
}
public MathController(
FactorialCalculator factorialCalculator,
FibonacciCalculator fibonacciCalculator,
RandomSquareCalculator randomSquareCalculator)
{
_factorialCalculator = factorialCalculator;
_fibonacciCalculator = fibonacciCalculator;
_randomSquareCalculator = randomSquareCalculator;
}
public void GetFibonacciConsequence_0_10()
{
var calculator = new FibonacciCalculator();
var result = calculator.GetConsequence(0, 10);
string etalon = "1 1 2 3 5 8 13 21 34 55 ";
Assert.AreEqual(etalon, result.Replace("\r\n", " "));
}
public int SumOfTheEvenNumbersBelow4Million()
{
var fibonacciCalculator = new FibonacciCalculator();
var mathOperations = new MathOperationsForProblem002();
var fibonacciNumbersBelow4Million = fibonacciCalculator.FibonacciNumbersBelow(4000000);
return(mathOperations.SumEvenNumbersFromAListOfNumbers(fibonacciNumbersBelow4Million));
}
public void GetFibonacciConsequence_10_negative10()
{
var calculator = new FibonacciCalculator();
var result = calculator.GetConsequence(10, -10);
string etalon = "34 21 13 8 5 3 2 1 1 ";
Assert.AreEqual(etalon, result.Replace("\r\n", " "));
}
public void GetFibonacciIterator_GetIteratorOrder_Desc()
{
var calculator = new FibonacciCalculator();
var orderName = calculator.GetIteratorOrder(-10);
string etalon = "DESC";
Assert.AreEqual(etalon, orderName);
}
public void GetFibonacciIterator_GetIteratorOrder_Asc_ForNormalCount()
{
var calculator = new FibonacciCalculator();
var orderName = calculator.GetIteratorOrder(10);
string etalon = "ASC";
Assert.AreEqual(etalon, orderName);
}
public string FibonacciRow_ValidParameters(int count)
{
string actualResult = "";
foreach (var number in FibonacciCalculator.GenerateFibonacciNumbers(count))
{
actualResult += number.ToString() + " ";
}
return(actualResult);
}
public void ShouldReturnFibonacciNumbersBelow10()
{
var fibonacciNumbers = new List <int> {
1, 2, 3, 5, 8
};
var fibonacciCalculator = new FibonacciCalculator();
var fibonacciNumbersBelow10 = fibonacciCalculator.FibonacciNumbersBelow(10);
fibonacciNumbersBelow10.Should().BeEquivalentTo(fibonacciNumbers);
}
private void ProcessFibonacci(FibonacciMessage message)
{
var fibonacciCalculator = new FibonacciCalculator();
for (int i = 0; i < message.NumbersToProcess; i++)
{
var numberIndex = message.StartIndex + i;
var result = fibonacciCalculator.Calculate(message.FibonacciNumbers[numberIndex], message.ProcessingType);
SynchronizationContext.AddNumberAndCheckIfIsDone(result);
}
}
static void Main(string[] args)
{
FibonacciInput input = new FibonacciInput();
FibonacciCalculator calculator = new FibonacciCalculator();
input.GetParam();
long n = input.TotNum;
Console.WriteLine("Fib ({0}) = {1}", n, calculator.Fibonacci(n, input.MyNumbers));
Console.ReadKey();
}
private static void Main()
{
System.AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionTrapper;
var fCacluator = new FibonacciCalculator();
Console.WriteLine($"Position 10 in the fibonacci sequence is {fCacluator.CalculateValueOfPosition(10)}.");
Console.WriteLine($"Position 40 in the fibonacci sequence is {fCacluator.CalculateValueOfPosition(40)}.");
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("- Press any key to end the program -");
Console.ReadLine();
}
public ActionResult <BigInteger> Get(long index)
{
try
{
Response.Headers.Add(FibonacciRequestedTag, index.ToString());
return(FibonacciCalculator.Calculate(index));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public void CalculateFibonacciTest()
{
var request = new FibonacciListerRequest();
request.givenNumber = 5;
var response = new FibonacciCalculator();
var output = response.FibonacciLister(request);
var actual = output.fibonacciList;
int[] expected = { 1, 1, 2, 3, 5 };
Assert.AreEqual(actual, expected);
}
static async Task Main(string[] args)
{
var fibonacciNumbers = FileUtility.ReadNumbersFromFile(INPUT_FILE);
var processingType = FibonacciCalculator.GetProcessingType();
for (int i = 1; i <= 32; i *= 2)
{
Console.WriteLine($"\nRuning with {i} Threads.");
var result = await ProcessFibonacciWithTasks(fibonacciNumbers, i, processingType);
FileUtility.WriteNumbersToFile(OUTPUT_FILE, result);
}
Console.ReadLine();
}
static void ConsumeMessage(object model, BasicDeliverEventArgs ea)
{
try
{
var number = Int64.Parse(Encoding.UTF8.GetString(ea.Body.ToArray()));
Console.WriteLine("[x] Received {0}", number);
var fibonacciCalculator = new FibonacciCalculator();
var result = fibonacciCalculator.Calculate(number, ProcessingType.Sleepy);
FileUtility.AppendNumberToFile(OUTPUT_FILE, result);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public ActionResult FibonacciInput(FibonacciModel request)
{
if (ModelState.IsValid)
{
var fibCalc = new FibonacciCalculator();
var fibData = new FibonacciListerRequest();
fibData.givenNumber = request.givenNumber;
var result = fibCalc.FibonacciLister(fibData);
return(View("FibonacciOutput", result));
}
else
{
return(View(request));
}
}
private static void CalculateFibonacci(long[] fibonacciNumbers, int numberOfTasks, int taskIndex, ProcessingType processingType)
{
var fibonacciCalculator = new FibonacciCalculator();
int numbersPerTask = fibonacciNumbers.Length / numberOfTasks; // ideal case, even tasks and even numbers count
int numbersToProcess = 0;
if (taskIndex == numberOfTasks - 1) // if is last task
{
numbersToProcess = fibonacciNumbers.Length - (numbersPerTask * (numberOfTasks - 1));
}
else
{
numbersToProcess = numbersPerTask;
}
for (int i = 0; i < numbersToProcess; i++)
{
var numberIndex = taskIndex * numbersPerTask + i;
var result = fibonacciCalculator.Calculate(fibonacciNumbers[numberIndex], processingType);
ConcurrentStore.AddNumberToStore(result);
}
}
