public void FibonacciSequence_Next()
{
var fs = new FibonacciSequence(new FibonacciState(0));
Assert.That(fs.Next(fs.Next(fs.Next(fs.Next(new FibonacciState(1))))).Value, Is.EqualTo(5));
Assert.That(fs.Previous.Value, Is.EqualTo(3));
}
private void ClickMeButton_Click(object sender, RoutedEventArgs e)
{
OutputListBox.Items.Clear();
var sequence = new FibonacciSequence(10);
foreach (var item in sequence)
OutputListBox.Items.Add(item);
}
public void FibonacciSequence_Element_IsValue(int n, int expected)
{
var seq = new FibonacciSequence();
var result = seq.ElementAt(n);
Assert.AreEqual(expected, result);
}
private static Boolean KawigiEdit_RunTest(int testNum, int p0, int p1, Boolean hasAnswer, int p2)
{
Console.Write("Test " + testNum + ": [" + p0 + "," + p1);
Console.WriteLine("]");
FibonacciSequence obj;
int answer;
obj = new FibonacciSequence();
DateTime startTime = DateTime.Now;
answer = obj.numFibs(p0, p1);
DateTime endTime = DateTime.Now;
Boolean res;
res = true;
Console.WriteLine("Time: " + (endTime - startTime).TotalSeconds + " seconds");
if (hasAnswer) {
Console.WriteLine("Desired answer:");
Console.WriteLine("\t" + p2);
}
Console.WriteLine("Your answer:");
Console.WriteLine("\t" + answer);
if (hasAnswer) {
res = answer == p2;
}
if (!res) {
Console.WriteLine("DOESN'T MATCH!!!!");
} else if ((endTime - startTime).TotalSeconds >= 2) {
Console.WriteLine("FAIL the timeout");
res = false;
} else if (hasAnswer) {
Console.WriteLine("Match :-)");
} else {
Console.WriteLine("OK, but is it right?");
}
Console.WriteLine("");
return res;
}
private ISequence CreateSequence()
{
SequenceDTO sequenceDTO = _sequenceView.GetSequence();
Log.Information("Getted sequence: {sequenceType}, {minRange}, {maxRange}",
sequenceDTO.SequenceType, sequenceDTO.MinRange, sequenceDTO.MaxRange);
ValidateSequenceDTO(sequenceDTO);
ISequence sequence;
switch (sequenceDTO.SequenceType)
{
case SequenceType.Fibonacci:
{
sequence = new FibonacciSequence(sequenceDTO);
break;
}
case SequenceType.SquareLess:
{
sequence = new SquareLessSequence(sequenceDTO);
break;
}
default:
{
throw new ArgumentOutOfRangeException(sequenceDTO.SequenceType.ToString(),
"No such mode of sequence");
}
}
return(sequence);
}
public void FunctionalLifeSpanTest_ShouldProduceDesiredResults()
{
// Arrange.
var firstTerm = new BigInteger(3);
var secondTerm = new BigInteger(3);
// Act.
var target = new FibonacciSequence(firstTerm, secondTerm);
// Assert.
target.CalculatedTermCount.Should().Be(2);
target[0].Should().Be(firstTerm);
target[1].Should().Be(secondTerm);
target[2].Should().Be(6);
target[3].Should().Be(9);
target[4].Should().Be(15);
target.CalculatedTermCount.Should().Be(5);
target[5].Should().Be(24);
target[6].Should().Be(39);
target[7].Should().Be(63);
target[8].Should().Be(102);
target[9].Should().Be(165);
target.CalculatedTermCount.Should().Be(10);
target.Reset();
target.CalculatedTermCount.Should().Be(2);
target[0].Should().Be(firstTerm);
target[1].Should().Be(secondTerm);
target[2].Should().Be(6);
}
static void Main(string[] args)
{
Console.WriteLine("First task:");
FibonacciSequence fibonacciSequence = new FibonacciSequence();
fibonacciSequence.FibonacciCounter(10);
fibonacciSequence.FibonacciCounterLINQ(11);
fibonacciSequence.FibonacciAggr(11);
Console.WriteLine("Second task:");
Factorial factorialResult = new Factorial();
factorialResult.FactorialCounter(7);
Console.WriteLine("Third task:");
TeaManager teaManager = new TeaManager();
teaManager.GroupingTeaItem(teaManager.GetListTea());
Console.WriteLine("Forth task:");
ArrayManager arrayManager = new ArrayManager();
arrayManager.SplittArray_v1();
arrayManager.SplittArray_v2();
Console.ReadKey();
}
public void First10ElementsCorrect()
{
var sequence = new FibonacciSequence().Sequence.Take(10);
sequence.SequenceEqual(new BigInteger[] { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 })
.Should().BeTrue();
}
public void GetNumberOfSequence_ShouldCorrectly(int index, int expected)
{
var sequence = new FibonacciSequence();
var actual = sequence[index];
Assert.Equal(expected, actual);
}
public void XNumber_ShouldBe_NthElementOfSequence(int expectedNumber, int elementNumber)
{
// Arrange / Act
var fibonacciSequence = new FibonacciSequence(elementNumber);
// Assert
Assert.AreEqual(expectedNumber, fibonacciSequence.Last());
}
public void NthElement_ShouldBe_SumOfTwoPreviousElements(int elementNumber)
{
// Arrange / Act
var fibonacciSequence = new FibonacciSequence(elementNumber);
// Assert
Assert.AreEqual(fibonacciSequence.Last(), fibonacciSequence.SkipLast(1).TakeLast(2).Sum());
}
public void FibonacciSequence_DoesNotOverflowAtElement46()
{
var seq = new FibonacciSequence();
var value46 = seq.ElementAt(45);
var value47 = seq.ElementAt(46);
Assert.Greater(value47, value46);
}
public void FirstNElementsSequenceCount_ShouldBe_N(int expectedCount, int sequenceCount)
{
// Arrange / Act
var fibonacciSequence = new FibonacciSequence(sequenceCount);
// Assert
Assert.AreEqual(expectedCount, fibonacciSequence.ToList().Count);
}
public void Calculate_GetFibonacciNumberWhenNotInFibonacci()
{
var fibonacci = new FibonacciSequence();
var result = fibonacci.Calculate(9);
Assert.AreEqual("1 1 2 3 5 8 9", result);
}
public void EvenFibonacciNumbers()
{
uint sum = new FibonacciSequence()
.TakeWhile(curr => curr <= 4000000)
.Where(curr => curr % 2 == 0)
.Aggregate((uint) 0, (curr, next) => curr + next);
Assert.Equal(sum, (uint)4613732);
}
public void Calculate_GetFibonacciNumber()
{
var fibonacci = new FibonacciSequence();
var result = fibonacci.Calculate(5);
Assert.AreEqual("1 1 2 3 5", result);
}
static void Main(string[] args)
{
var sum = new FibonacciSequence(4000000).Where(t => t % 2 == 0).Sum();
foreach (var i in new FibonacciSequence(4000000))
{
Console.WriteLine("{0} has {1} digits", i, Math.Floor(Math.Log10(i)) + 1);
}
}
public void FibonacciNumbersAtAGivenIndexAreAsExpected()
{
var sequence = new FibonacciSequence();
Assert.AreEqual(0, sequence[0]);
Assert.AreEqual(3, sequence[4]);
Assert.AreEqual(610, sequence[15]);
Assert.AreEqual(2880067194370816120, sequence[90]);
}
public void Sequence()
{
var seq = new FibonacciSequence().Take(10).ToArray();
seq[0].ShouldBe(1);
seq[1].ShouldBe(1);
seq[2].ShouldBe(2);
seq[3].ShouldBe(3);
seq[4].ShouldBe(5);
}
static void Main(string[] args)
{
var sequence = new FibonacciSequence();
foreach (var item in sequence.Take(50))
{
Console.WriteLine(item);
}
Console.ReadLine();
}
public object Solve()
{
var seq = new FibonacciSequence();
var sum = seq.TakeWhile(fib => fib <= Limit)
.Where(fib => fib.IsEven)
.Sum(b => (long)b);
return(sum);
}
public void FibonacciSequence_MoveNextAndCurrentTests(int count, long[] expected)
{
var sequence = new FibonacciSequence(count);
int i = 0;
while (sequence.MoveNext())
{
Assert.AreEqual(new BigInteger(expected[i++]), sequence.Current);
}
}
public void Iterator_FibonacciEnumerator()
{
var sequence = new FibonacciSequence(10);
foreach (var item in sequence)
{
Console.WriteLine(item);
}
Assert.IsNotNull(sequence);
}
static void Main(string[] args)
{
var sequence = new FibonacciSequence(3);
foreach(var i in sequence)
{
Console.WriteLine(i);
}
Console.ReadKey();
}
public void FibonacciSequence_LongSequenceTests(int count)
{
var sequence = new FibonacciSequence(count);
int k = 0;
while (sequence.MoveNext())
{
k++;
}
Assert.IsTrue(k == count);
}
static void Main(string[] args)
{
var seq = new FibonacciSequence(7);
IMyEnumerator <int> iter = seq;
while (iter.MoveNext())
{
Console.Write(iter.Current + " ");
}
iter.Reset();
Console.ReadLine();
}
public void Test_Find_Fibonacii_Sequence_At_Position_Corrent_5()
{
//Arrange
var expected = new List <int> {
0, 1, 1, 2, 3, 5, 8
};
//Actual
var actual = FibonacciSequence.GetAllFibonacciNumbers(5);
//Assert
CollectionAssert.AreEqual(expected, actual);
}
public void Constructor_ShouldRaiseArgumentException_ForSeedsWithSumZero()
{
// Arrange.
var firstTerm = new BigInteger(-3);
var secondTerm = new BigInteger(3);
// Act.
var action = new Action(() =>
{
var target = new FibonacciSequence(firstTerm, secondTerm);
});
// Assert.
action.Should().Throw <ArgumentException>();
}
public void Constructor_ShouldRaiseArgumentOutOfRangeException_ForInvalidSeedCombination()
{
// Arrange.
var firstTerm = new BigInteger(3);
var secondTerm = new BigInteger(2);
// Act.
var action = new Action(() =>
{
var target = new FibonacciSequence(firstTerm, secondTerm);
});
// Assert.
action.Should().Throw <ArgumentOutOfRangeException>();
}
public void FibonacciSequence_ResetTests(int count, int k, long[] expected)
{
var sequence = new FibonacciSequence(count);
while (sequence.MoveNext())
{
}
sequence.Reset();
for (int i = 0; i < k; i++)
{
sequence.MoveNext();
}
Assert.AreEqual(new BigInteger(expected[k - 1]), sequence.Current);
}
public int Fibonacci(int n)
{
// Uncomment for the WaitingForm test
//Thread.Sleep(2000);
log.Info(String.Format("In : Fibonacci : n = {0}", n));
int result = 0;
try
{
result = FibonacciSequence.Calculate(n);
}
catch (Exception ex)
{
log.Error("Exception : Fibonacci : " + ex.Message);
}
return(result);
}
// Use this for initialization
void Awake()
{
// Make the game object a singleton
if (Instance == null)
{
Instance = this;
FibonacciSequence = new FibonacciSequence();
_gameState = new GameState();
LoadHighScoreBoard();
}
else
{
Destroy(gameObject);
}
DontDestroyOnLoad(gameObject);
}
private async void GenerateClick(object sender, RoutedEventArgs e)
{
_tokenSource?.Cancel();
_tokenSource = new CancellationTokenSource();
// Grab values from screen
var phi = Phi.Value;
var phiIncrement = PhiIncrement.Value;
var points = (int)Points.Value;
var imageSize = (int)ImageSize.Value;
var imageCount = (int)ImageCount.Value;
var pointSize = PointSize.Value;
var tempPath = TempImagePath.Text;
if (!Directory.Exists(tempPath))
{
Directory.CreateDirectory(tempPath);
}
var token = _tokenSource.Token;
//ImagePanel.BeginInit();
Status.Text = $"Creating {imageCount} images...";
for (var i = 0; i < imageCount; i++)
{
var sequence = await Task.Run(
() => FibonacciSequence.Calculate(points, phi),
token);
if (token.IsCancellationRequested)
{
break;
}
var imagePath = $"{tempPath}Fibonacci_{points}_{phi:N3}.jpg";
Status.Text = $"Exporting to {imagePath}";
ImageGenerator.ExportToJpeg(sequence, imagePath, imageSize, imageSize, pointSize);
AddImageToPanel(imagePath, imageSize);
phi += phiIncrement;
}
//ImagePanel.EndInit();
Status.Text = $"Created {imageCount} images";
}
public static void Main ()
{
FibonacciSequence f = new FibonacciSequence ();
//Console.WriteLine (f.RecursiveFibonacci (47));
Console.WriteLine (f.Fibonacci (47));
}
