public void HasNextTest()
{
int lengthCut = 3;
int step = 1;
int countSteps = 0;
var iterator = new StartIterator(chain, lengthCut, step);
while (iterator.HasNext())
{
iterator.Next();
countSteps = countSteps + 1;
}
Assert.True(countSteps == iterator.MaxShifts);
countSteps = 0;
iterator = new StartIterator(chain, lengthCut, step + 1);
while (iterator.HasNext())
{
iterator.Next();
countSteps = countSteps + 1;
}
Assert.True(countSteps == iterator.MaxShifts);
}
public void GetMaxShiftsTest()
{
int lengthCut = 3;
int step = 1;
int maxShifts = 16;
var iterator = new StartIterator(chain, lengthCut, step);
Assert.True(iterator.MaxShifts == maxShifts);
}
public void GetPositionTest()
{
int lengthCut = 2;
int step = 1;
var iterator = new StartIterator(chain, lengthCut, step);
iterator.Next();
Assert.True(iterator.CursorPosition == 0);
iterator.Next();
Assert.True(iterator.CursorPosition == 1);
for (int index = 2; index < iterator.MaxShifts; index++)
{
iterator.Next();
}
Assert.True(iterator.CursorPosition == 16);
}
/// <summary>
/// Do not ask any questions, because it really very fast and redundant is also to the point
/// Please do learn java performance
/// </summary>
/// <param name="it">it only iterator from start</param>
protected void FindLess(StartIterator it)
{
int zero = 0;
int minLength = 2;
List<string> accord = it.Current();
int length = accord.Count;
int position = it.Position();
// for less one
if (position == zero)
{
// first less one
minusOneEntry.Add(accord.GetRange(0, length - 1), position, 0);
minusOneEntry.Add(accord.GetRange(1, length - 1), position, 0);
}
else
{
// common less one
minusOneEntry.Add(accord.GetRange(1, length - 1), position, 0);
}
// for less two
if (length == minLength)
{
// do not handle words of length 2
return;
}
if (position == zero)
{
// first less two
minusTwoEntry.Add(accord.GetRange(1, length - 2), position, 0);
return;
}
int param = it.MaxShifts == it.Shifts ? 0 : 1;
minusTwoEntry.Add(accord.GetRange(param, length - 2), position, 0);
}
/// <summary>
/// The find.
/// </summary>
/// <param name="par">
/// The par.
/// </param>
/// <returns>
/// The <see cref="T:KeyValuePair{List{String},List{Int32}}"/>.
/// </returns>
public override sealed KeyValuePair<List<string>, List<int>>? Find(ContentValues par)
{
var convoluted = (ComplexChain)par.Get(Enum.GetName(typeof(Formalism), Formalism.Sequence));
var windowLen = (int)par.Get(Enum.GetName(typeof(Parameter), Parameter.Window));
var alphabet = (FrequencyDictionary)par.Get(Enum.GetName(typeof(Formalism), Formalism.Alphabet));
var level = (double)par.Get(Enum.GetName(typeof(Parameter), Parameter.CurrentThreshold));
int scanStep = 1;
int disp = 0;
var it = new StartIterator(convoluted, windowLen, scanStep);
while (it.HasNext())
{
it.Next();
fullEntry.Add(it, disp);
}
CalculateStd(convoluted, windowLen);
return DiscardCompositeWords(alphabet, level);
}
/// <summary>
/// The find.
/// </summary>
/// <param name="par">
/// The par.
/// </param>
/// <returns>
/// The <see cref="T:KeyValuePair{List{string},List{int}}?"/>.
/// </returns>
public override sealed KeyValuePair<List<string>, List<int>>? Find(ContentValues par)
{
var convoluted = (ComplexChain)par.Get(Enum.GetName(typeof(Formalism), Formalism.Sequence));
double pbalance = (int)par.Get(Enum.GetName(typeof(Parameter), Parameter.Balance)) / 100.0;
int windowLen = (int)par.Get(Enum.GetName(typeof(Parameter), Parameter.Window));
var alphabet = (FrequencyDictionary)par.Get(Enum.GetName(typeof(Formalism), Formalism.Alphabet));
var level = (double)par.Get(Enum.GetName(typeof(Parameter), Parameter.CurrentThreshold));
int scanStep = 1;
int disp = 0;
int length = convoluted.GetLength();
fullEntry = new DataCollector();
minusOneEntry = new DataCollector();
minusTwoEntry = new DataCollector();
var it = new StartIterator(convoluted, windowLen, scanStep);
CriterionMethod criteriaCalculator = new ConvolutedCriterionMethod();
while (it.HasNext())
{
it.Next();
fullEntry.Add(it, disp);
FindLess(it);
}
CalculateStd(convoluted, pbalance, windowLen, length, criteriaCalculator);
return DiscardCompositeWords(alphabet, level);
}
/// <summary>
/// The add.
/// </summary>
/// <param name="iterator">
/// The iterator.
/// </param>
/// <param name="step">
/// The step.
/// </param>
public void Add(StartIterator iterator, int step)
{
List<string> str = iterator.Current();
int position = iterator.Position();
Add(str, position, step);
}
public void MoveTest()
{
int length = 2;
int step = 1;
int position = 3;
var iterator = new StartIterator(chain, length, step);
iterator.Move(position);
Assert.True(iterator.CursorPosition == position);
position = 100;
iterator.Move(position);
Assert.True(iterator.CursorPosition != position);
position = chain.GetLength() / 2;
iterator.Move(position);
Assert.True(iterator.CursorPosition == position);
position = -1;
iterator.Move(position);
Assert.True(iterator.CursorPosition != position);
length = 3;
step = 2;
position = 3;
string triple = "GTG";
iterator = new StartIterator(chain, length, step);
iterator.Move(position);
iterator.Next();
Assert.AreEqual(triple, Helper.ToString(iterator.Current()));
}
public void ResetTest()
{
int length = 2;
int step = 1;
var iterator = new StartIterator(chain, length, step);
if (iterator.Move(3))
{
iterator.Reset();
}
Assert.True(iterator.CursorPosition == -step);
}
public void NextTest()
{
List<string> cut;
string[] triplesForStepOne =
{
"AAC", "ACA", "CAG", "AGG", "GGT", "GTG", "TGC", "GCC", "CCC", "CCC", "CCT",
"CTT", "TTA", "TAT", "ATT", "TTT"
};
string[] triplesForStepTwo = { "AAC", "CAG", "GGT", "TGC", "CCC", "CCT", "TTA", "ATT" };
int lengthCut = 3;
int step = 1;
var iterator = new StartIterator(chain, lengthCut, step);
for (int i = 0; i < iterator.MaxShifts; i++)
{
cut = iterator.Next();
Assert.True(Helper.ToString(cut).Equals(triplesForStepOne[i]));
}
iterator = new StartIterator(chain, lengthCut, step + 1);
for (int i = 0; i < iterator.MaxShifts; i++)
{
cut = iterator.Next();
Assert.True(Helper.ToString(cut).Equals(triplesForStepTwo[i]));
}
}
