/// <summary>
/// Clears the terms in the current <see cref="InfiniteSequence{T}" />, leaving in place the seed terms.
/// </summary>
public void Reset()
{
lock (SyncRoot)
{
CalculatedTerms = new List <T>(CalculatedTerms.Take(SeedTermCount));
}
}
/// <summary>
/// Calculates the next term in the sequence.
/// </summary>
/// <returns>
/// The next term in the sequence.
/// </returns>
public T CalculateNext()
{
lock (SyncRoot)
{
var nextTerm = CalculateNext(CalculatedTerms);
CalculatedTerms.Add(nextTerm);
return(nextTerm);
}
}
/// <summary>
/// Calculates the specified range of terms and returns them as an array.
/// </summary>
/// <param name="startIndex">
/// The zero-based index of the first returned term.
/// </param>
/// <param name="count">
/// The number of terms to return.
/// </param>
/// <returns>
/// An array containing the calculated terms in the specified range.
/// </returns>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="startIndex" /> is less than zero or <paramref name="count" /> is less than zero.
/// </exception>
public T[] ToArray(Int32 startIndex, Int32 count)
{
var indexCeiling = (startIndex.RejectIf().IsLessThan(0, nameof(startIndex)) + count.RejectIf().IsLessThan(0, nameof(count)));
lock (SyncRoot)
{
while (CalculatedTerms.Count < indexCeiling)
{
CalculatedTerms.Add(CalculateNext(CalculatedTerms));
}
return(CalculatedTerms.Skip(startIndex).Take(count).ToArray());
}
}
/// <summary>
/// Calculates the next terms in the sequence.
/// </summary>
/// <param name="count">
/// The number of terms to calculate.
/// </param>
/// <returns>
/// An array containing the calculated terms.
/// </returns>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="count" /> is less than zero.
/// </exception>
public T[] CalculateNext(Int32 count)
{
lock (SyncRoot)
{
var nextTerms = new T[count.RejectIf().IsLessThan(0, nameof(count))];
for (var i = 0; i < count; i++)
{
var nextTerm = CalculateNext(CalculatedTerms);
CalculatedTerms.Add(nextTerm);
nextTerms[i] = nextTerm;
}
return(nextTerms);
}
}
/// <summary>
/// Gets the term at the specified index.
/// </summary>
/// <param name="index">
/// The zero-based index of the term to get.
/// </param>
/// <returns>
/// The term at the specified index.
/// </returns>
/// <exception cref="IndexOutOfRangeException">
/// <paramref name="index" /> is less than zero.
/// </exception>
public T this[Int32 index]
{
get
{
if (index < 0)
{
throw new IndexOutOfRangeException();
}
var indexCeiling = (index + 1);
lock (SyncRoot)
{
while (CalculatedTerms.Count < indexCeiling)
{
CalculatedTerms.Add(CalculateNext(CalculatedTerms));
}
return(CalculatedTerms[index]);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="InfiniteSequence{T}" /> class.
/// </summary>
/// <param name="seedTerms">
/// The first terms in the sequence.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="seedTerms" /> is <see langword="null" />.
/// </exception>
protected InfiniteSequence(T[] seedTerms)
{
CalculatedTerms.AddRange(seedTerms);
SeedTermCount = seedTerms.Length;
}
