public void SetPositionThrowsExceptionWhenWindowMovedBackwards()
{
var points = CreateTestPoints();
var windowSize = 1;
var windowPositioningType = WindowPositioningType.CenteredAtPosition;
var sut = new SlidingWindow <Point2D>(points, p => p.X, windowSize, windowPositioningType);
Assert.That(() => sut.SetPosition(2), Throws.Nothing);
Assert.That(() => sut.SetPosition(1), Throws.InvalidOperationException);
}
public void SlidingWindowRemovesPointsInNoLongerInWindow()
{
var points = CreateTestPoints();
var windowSize = 1;
var windowPositioningType = WindowPositioningType.CenteredAtPosition;
var sut = new SlidingWindow <Point2D>(points, p => p.X, windowSize, windowPositioningType);
sut.SetPosition(2.2);
Assert.That(sut.Count(), Is.EqualTo(2));
Assert.That(sut.Select(p => p.X), Is.EquivalentTo(new[] { 2, 2.5 }));
sut.SetPosition(3.1);
Assert.That(sut.Count(), Is.EqualTo(1));
Assert.That(sut.Select(p => p.X), Is.EquivalentTo(new[] { 3 }));
}
public static IEnumerable <Point2D> MovingAverage(this IList <Point2D> data, double windowSize)
{
if (data.Count == 0)
{
yield break;
}
var orderedData = data.OrderBy(p => p.X).ToList();
var slidingWindow = new SlidingWindow <Point2D>(orderedData, p => p.X, windowSize, WindowPositioningType.CenteredAtPosition);
foreach (var point in orderedData)
{
slidingWindow.SetPosition(point.X);
yield return(new Point2D(point.X, slidingWindow.Average(p => p.Y)));
}
}
public static List <Beat> Merge(List <Beat> detectedBeats, List <Beat> regularBeats, int sampleRate)
{
var mergedBeats = new List <Beat>();
var beatTolerance = 0.05 * sampleRate;
var detectedBeatWindow = new SlidingWindow <Beat>(detectedBeats, beat => beat.SampleIndex, beatTolerance, WindowPositioningType.CenteredAtPosition);
foreach (var regularBeat in regularBeats)
{
detectedBeatWindow.SetPosition(regularBeat.SampleIndex);
if (detectedBeatWindow.Any())
{
var matchingDetectedBeat = detectedBeatWindow.MaximumItem(beat => beat.Strength);
mergedBeats.Add(matchingDetectedBeat);
}
else
{
mergedBeats.Add(regularBeat);
}
}
return(mergedBeats);
}
/// <summary>
/// Detects alpha helixes in a peptide. Does NOT add these annotations to peptide.
/// </summary>
public List <PeptideAnnotation <AminoAcidReference> > Detect(Peptide peptide)
{
var slidingWindow = new SlidingWindow <AminoAcidReference>(
peptide.AminoAcids,
x => x.SequenceNumber,
4.5,
WindowPositioningType.StartingAtPosition);
const int MinimumHelixLength = 7;
var helixAnnotations = new List <PeptideAnnotation <AminoAcidReference> >();
PeptideAnnotation <AminoAcidReference> currentAnnotation = null;
foreach (var aminoAcid in peptide.AminoAcids.OrderBy(x => x.SequenceNumber))
{
if (currentAnnotation != null && aminoAcid.SequenceNumber > currentAnnotation.AminoAcidReferences.Last().SequenceNumber)
{
if (currentAnnotation.AminoAcidReferences.Count >= MinimumHelixLength)
{
helixAnnotations.Add(currentAnnotation);
}
currentAnnotation = null;
}
slidingWindow.SetPosition(aminoAcid.SequenceNumber - 0.1); // -0.1 to avoid problems with rounding
var secondAminoAcid = slidingWindow.FirstOrDefault(x => x.SequenceNumber == aminoAcid.SequenceNumber + 1);
if (secondAminoAcid == null)
{
continue;
}
var thirdAminoAcid = slidingWindow.FirstOrDefault(x => x.SequenceNumber == aminoAcid.SequenceNumber + 2);
if (thirdAminoAcid == null)
{
continue;
}
var fourthAminoAcid = slidingWindow.FirstOrDefault(x => x.SequenceNumber == aminoAcid.SequenceNumber + 3);
if (fourthAminoAcid == null)
{
continue;
}
try
{
var firstVector = FindPositionVector(aminoAcid, secondAminoAcid);
var secondVector = FindPositionVector(aminoAcid, thirdAminoAcid);
var thirdVector = FindPositionVector(aminoAcid, fourthAminoAcid);
var isAlphaHelix = IsAlphaHelix(firstVector, secondVector, thirdVector);
if (isAlphaHelix)
{
if (currentAnnotation == null)
{
currentAnnotation = new PeptideAnnotation <AminoAcidReference>(
PeptideSecondaryStructure.AlphaHelix,
new List <AminoAcidReference> {
aminoAcid, secondAminoAcid, thirdAminoAcid, fourthAminoAcid
});
}
else
{
currentAnnotation.AminoAcidReferences.Add(fourthAminoAcid);
}
}
else
{
if (currentAnnotation != null)
{
if (currentAnnotation.AminoAcidReferences.Count >= MinimumHelixLength)
{
helixAnnotations.Add(currentAnnotation);
}
currentAnnotation = null;
}
}
}
catch (KeyNotFoundException)
{
continue;
}
}
return(helixAnnotations);
}
