public void Sorting_Shortlex()
{
var a = new string[0];
var b = new[] { "Athens" };
var c = new[] { "Añasco", "Madrid" };
var d = new[] { "Madrid", "Añasco" };
var e = new[] { "Paris", "Añasco" };
var f = new[] { "Paris", "Athens" };
var g = new[] { "Athens", "Madrid", "Añasco" };
var h = new[] { "Madrid", "Paris", "Añasco" };
var i = new[] { "Paris", "Añasco", "Athens" };
var j = new[] { "Paris", "Athens", "Añasco" };
var k = new[] { "Madrid", "Paris", "Athens", "New York" };
var l = new[] { "Paris", "Añasco", "Athens", "New York" };
var m = new[] { "Paris", "Añasco", "Athens", "Madrid", "New York" };
var source = new[] { h, d, e, l, g, a, m, c, f, j, b, k, i };
using (new CultureSwapper(PredefinedCulture.EnglishUnitedStates))
{
EnumerableAssert.AreEqual(
new[] { a, b, c, d, e, f, g, h, i, j, k, l, m },
source.OrderBy(s => s, SequenceComparer <string> .Shortlex));
EnumerableAssert.AreEqual(
new[] { a, b, c, d, f, e, g, h, j, i, k, l, m },
source.OrderBy(s => s, SequenceComparer.Create(SequenceComparison.Shortlex, StringComparer.Ordinal)));
}
}
public void TestBasic()
{
Variant v = new Variant(new byte[] { 0x01, 0x02, 0x03 });
Assert.AreEqual(v.Type, Variant.EnumType.Buffer);
Assert.IsTrue(v.Is(Variant.EnumType.Buffer));
Assert.IsTrue(SequenceComparer.Compare(v.AsBuffer(), new byte[] { 0x01, 0x02, 0x03 }) == 0);
}
public void SequenceComparer_SecondSequenceSmaller_ReturnsGreaterThan()
{
var x = new int[] { 1, 1, 3 };
var y = new int[] { 1, 0, 3 };
int result = new SequenceComparer <int>().Compare(x, y);
Assert.IsTrue(result > 0, "Smaller sequence should be less than larger sequence.");
}
public void SequenceComparer_FirstSequenceSmaller_ReturnsLessThan()
{
var x = new int[] { 1, 1, 3 };
var y = new int[] { 1, 2, 3 };
int result = new SequenceComparer <int>().Compare(x, y);
Assert.IsTrue(result < 0, "Smaller sequence should be less than larger sequence.");
}
public void SequenceComparer_EqualSequences_ReturnsEqual()
{
var x = new int[] { 1, 2, 3 };
var y = new int[] { 1, 2, 3 };
int result = new SequenceComparer <int>().Compare(x, y);
Assert.IsTrue(result == 0, "Equal sequences should be equal.");
}
public void SequenceComparer_SecondSequenceEmpty_ReturnsGreaterThan()
{
var x = new int[] { 1 };
var y = new int[] { };
int result = new SequenceComparer <int>().Compare(x, y);
Assert.IsTrue(result > 0, "Empty sequence should be less than non-empty sequence.");
}
public static void GetByIndexTestHelper(IComparer<char> comparer, params string[] strings)
{
var target = QIndexedStringSet.Create(strings, comparer);
var sequenceComparer = new SequenceComparer<char>(comparer);
var expected = strings.OrderBy(s => s, sequenceComparer).ToArray();
for (int i = 0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i], target.GetByIndex(i));
}
}
public static void GetByPrefixTestHelper(IComparer<char> comparer, string prefix, params string[] strings)
{
var target = QStringSet.Create(strings, comparer);
var sequenceComparer = new SequenceComparer<char>(comparer);
var expected =
strings.Where(s => s.StartsWith(prefix, StringComparison.Ordinal))
.OrderBy(s => s, sequenceComparer)
.ToArray();
var actual = target.EnumerateByPrefix(prefix).ToArray();
CollectionAssert.AreEqual(expected, actual, sequenceComparer);
}
public void Compare_Nulls()
{
var x = new[] { "Madrid", "Añasco" };
foreach (var comparisonType in EnumUtility.GetValues <SequenceComparison>())
{
var comparer = SequenceComparer.Create <string>(comparisonType);
CompareAssert.IsLessThan(null, x, comparer);
CompareAssert.IsEqualTo(null, null, comparer);
CompareAssert.IsGreaterThan(x, null, comparer);
}
}
public static void CreateTestHelper(IComparer<char> comparer, params string[] strings)
{
var watch = new Stopwatch();
watch.Start();
var target = QStringSet.Create(strings, comparer);
Console.WriteLine(@"QStringSet.Create() took {0}", watch.Elapsed);
var sequenceComparer = new SequenceComparer<char>(comparer);
var expected = strings.OrderBy(s => s, sequenceComparer).ToArray();
watch.Restart();
string[] actual = target.Enumerate().ToArray();
Console.WriteLine(@"QStringSet.ToArray() took {0}", watch.Elapsed);
Assert.AreEqual(strings.Length, target.Count);
CollectionAssert.AreEqual(expected, actual, sequenceComparer);
}
public static void GetByPrefixWithValueTestHelper(
IComparer<char> comparer, string prefix, params string[] words)
{
var map = QStringMap<int>.Create(words, comparer);
foreach (var word in words)
{
map[word] = word.GetHashCode();
}
var sequenceComparer = new SequenceComparer<char>(comparer);
var expected =
words.Where(s => s.StartsWith(prefix, StringComparison.Ordinal))
.OrderBy(s => s, sequenceComparer)
.Select(s => new KeyValuePair<string, int>(s, s.GetHashCode()))
.ToArray();
var actual = map.EnumerateByPrefixWithValue(prefix).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Serialize_BinaryFormatter()
{
var x = new[] { "abc", "def" };
var y = new[] { "abc", "DEF" };
var z = new[] { "xyz" };
var binaryFormatter = new BinaryFormatter();
using (var stream = new MemoryStream())
{
var original = SequenceComparer.Create(SequenceComparison.Shortlex, StringComparer.OrdinalIgnoreCase);
binaryFormatter.Serialize(stream, original);
stream.Position = 0;
var comparer = (SequenceComparer <string>)binaryFormatter.Deserialize(stream);
CompareAssert.IsEqualTo(x, y, comparer);
CompareAssert.IsGreaterThan(x, z, comparer);
}
}
public void Compare_Strings()
{
var x = new[] { "Madrid", "Añasco" };
var y = new[] { "Madrid", "Athens" };
using (new CultureSwapper(PredefinedCulture.EnglishUnitedStates))
{
foreach (var comparisonType in EnumUtility.GetValues <SequenceComparison>())
{
var message = "'ñ' should be less than 't' for default comparison (current culture, en-US).";
var comparer = SequenceComparer.Create <string>(comparisonType);
CompareAssert.IsLessThan(x, y, comparer, message);
CompareAssert.IsEqualTo(x, x, comparer);
CompareAssert.IsGreaterThan(y, x, comparer, message);
message = "'ñ' should be greater than 't' for ordinal comparison.";
comparer = SequenceComparer.Create(comparisonType, StringComparer.Ordinal);
CompareAssert.IsGreaterThan(x, y, comparer, message);
CompareAssert.IsEqualTo(x, x, comparer);
CompareAssert.IsLessThan(y, x, comparer, message);
}
}
}
private void ReducePsms(IList<InputFile> csvFiles, UniquePeptideType uniquePeptideType, bool isBatched = false)
{
string msg = "Converting PSMs into unique peptides based ";
IEqualityComparer<Peptide> comparer;
switch (uniquePeptideType)
{
default:
msg += "on sequence only";
comparer = new SequenceComparer();
break;
case UniquePeptideType.Mass:
msg += "on mass";
comparer = new MassComparer();
break;
case UniquePeptideType.SequenceAndModifications:
msg += "on sequence and positional modifications";
comparer = new SequenceModComparer();
break;
case UniquePeptideType.SequenceAndModLocations:
msg += "on sequence and modification locations";
comparer = new SequenceAndModPositionComparer();
break;
case UniquePeptideType.SequenceAndMass:
msg += "on sequence and mass";
comparer = new SequenceMassComparer();
break;
case UniquePeptideType.Nothing:
msg += "on nothing (no reduction)";
comparer = new IdentityComparer<Peptide>();
break;
}
Log(msg);
foreach (InputFile csvFile in csvFiles)
{
csvFile.ReducePsms(comparer);
Log(string.Format("{0:N0} unique peptides remain from {1:N0} PSMs from {2}", csvFile.Peptides.Count, csvFile.PeptideSpectralMatches.Count, csvFile.Name));
}
if (!isBatched)
return;
Dictionary<Peptide, Peptide> peptideDictionary = new Dictionary<Peptide, Peptide>(comparer);
foreach (Peptide peptide in csvFiles.SelectMany(csvFile => csvFile.Peptides))
{
Peptide realPeptide;
if (peptideDictionary.TryGetValue(peptide, out realPeptide))
{
foreach (PSM psm in peptide.PSMs)
{
realPeptide.AddPsm(psm);
}
}
else
{
Peptide newPeptide = new Peptide(peptide);
peptideDictionary.Add(newPeptide, newPeptide);
}
}
_allPeptides = peptideDictionary.Values.ToList();
Log(string.Format("{0:N0} unique peptides from all files [Batched]", _allPeptides.Count));
}
