public static void Union_Unordered_NotPipelined(Labeled <ParallelQuery <int> > left, int leftCount, Labeled <ParallelQuery <int> > right, int rightCount)
{
ParallelQuery <int> leftQuery = left.Item;
ParallelQuery <int> rightQuery = right.Item;
IntegerRangeSet seen = new IntegerRangeSet(0, leftCount + rightCount);
Assert.All(leftQuery.Union(rightQuery).ToList(), x => seen.Add(x));
seen.AssertComplete();
}
public static void Union_NotPipelined(Labeled <ParallelQuery <int> > left, int leftCount, Labeled <ParallelQuery <int> > right, int rightCount)
{
ParallelQuery <int> leftQuery = left.Item;
ParallelQuery <int> rightQuery = right.Item;
int seen = 0;
Assert.All(leftQuery.Union(rightQuery).ToList(), x => Assert.Equal(seen++, x));
Assert.Equal(leftCount + rightCount, seen);
}
public static void Union_Unordered_NotPipelined(int leftCount, int rightCount)
{
ParallelQuery <int> leftQuery = UnorderedSources.Default(leftCount);
ParallelQuery <int> rightQuery = UnorderedSources.Default(leftCount, rightCount);
IntegerRangeSet seen = new IntegerRangeSet(0, leftCount + rightCount);
Assert.All(leftQuery.Union(rightQuery).ToList(), x => seen.Add(x));
seen.AssertComplete();
}
public static void Union_Unordered_SourceMultiple(ParallelQuery <int> leftQuery, int leftCount, ParallelQuery <int> rightQuery, int rightCount, int count)
{
// The difference between this test and the previous, is that it's not possible to
// get non-unique results from ParallelEnumerable.Range()...
// Those tests either need modification of source (via .Select(x => x / DuplicateFactor) or similar,
// or via a comparator that considers some elements equal.
IntegerRangeSet seen = new IntegerRangeSet(0, count);
Assert.All(leftQuery.Union(rightQuery), x => seen.Add(x));
seen.AssertComplete();
}
public static void Union(Labeled <ParallelQuery <int> > left, int leftCount, Labeled <ParallelQuery <int> > right, int rightCount)
{
ParallelQuery <int> leftQuery = left.Item;
ParallelQuery <int> rightQuery = right.Item;
int seen = 0;
foreach (int i in leftQuery.Union(rightQuery))
{
Assert.Equal(seen++, i);
}
Assert.Equal(leftCount + rightCount, seen);
}
public static void Union_Unordered(Labeled <ParallelQuery <int> > left, int leftCount, Labeled <ParallelQuery <int> > right, int rightCount)
{
ParallelQuery <int> leftQuery = left.Item;
ParallelQuery <int> rightQuery = right.Item;
IntegerRangeSet seen = new IntegerRangeSet(0, leftCount + rightCount);
foreach (int i in leftQuery.Union(rightQuery))
{
seen.Add(i);
}
seen.AssertComplete();
}
public static void Union_Unordered(int leftCount, int rightCount)
{
ParallelQuery <int> leftQuery = UnorderedSources.Default(leftCount);
ParallelQuery <int> rightQuery = UnorderedSources.Default(leftCount, rightCount);
IntegerRangeSet seen = new IntegerRangeSet(0, leftCount + rightCount);
foreach (int i in leftQuery.Union(rightQuery))
{
seen.Add(i);
}
seen.AssertComplete();
}
public static void Union_Unordered_CustomComparator(Labeled <ParallelQuery <int> > left, int leftCount, Labeled <ParallelQuery <int> > right, int rightCount)
{
ParallelQuery <int> leftQuery = left.Item;
ParallelQuery <int> rightQuery = right.Item;
IntegerRangeSet seen = new IntegerRangeSet(0, Math.Min(DuplicateFactor, leftCount + rightCount));
foreach (int i in leftQuery.Union(rightQuery, new ModularCongruenceComparer(DuplicateFactor)))
{
Assert.InRange(i, 0, leftCount + rightCount - 1);
seen.Add(i % DuplicateFactor);
}
seen.AssertComplete();
}
public static void Union_CustomComparator(Labeled <ParallelQuery <int> > left, int leftCount, Labeled <ParallelQuery <int> > right, int rightCount)
{
ParallelQuery <int> leftQuery = left.Item;
ParallelQuery <int> rightQuery = right.Item;
int seen = 0;
foreach (int i in leftQuery.Union(rightQuery, new ModularCongruenceComparer(DuplicateFactor)))
{
Assert.Equal(seen++, i);
}
Assert.Equal(Math.Min(DuplicateFactor, leftCount + rightCount), seen);
}
internal static ParallelQuery <int> MakeUnion(bool orderPreserved)
{
int[] a = Enumerable.Range(0, 80).ToArray();
int[] b = Enumerable.Range(20, 80).ToArray();
ParallelQuery <int> ipe = a.AsParallel();
if (orderPreserved)
{
ipe = ipe.AsOrdered();
}
return(ipe.Union(b.AsParallel()));
}
public static void Union_SecondOrdered_SourceMultiple(ParallelQuery <int> leftQuery, int leftCount, ParallelQuery <int> rightQuery, int rightCount, int count)
{
IntegerRangeSet seenUnordered = new IntegerRangeSet(0, leftCount);
int seen = leftCount;
foreach (int i in leftQuery.Union(rightQuery.AsOrdered()))
{
if (i >= leftCount)
{
Assert.Equal(seen++, i);
}
else
{
seenUnordered.Add(i);
}
}
Assert.Equal(count, seen);
seenUnordered.AssertComplete();
}
public static void Union_SecondOrdered_NotPipelined(Labeled <ParallelQuery <int> > left, int leftCount, Labeled <ParallelQuery <int> > right, int rightCount)
{
ParallelQuery <int> leftQuery = left.Item;
ParallelQuery <int> rightQuery = right.Item;
IntegerRangeSet seenUnordered = new IntegerRangeSet(0, leftCount);
int seen = leftCount;
Assert.All(leftQuery.Union(rightQuery).ToList(), x =>
{
if (x >= leftCount)
{
Assert.Equal(seen++, x);
}
else
{
seenUnordered.Add(x);
}
});
Assert.Equal(leftCount + rightCount, seen);
seenUnordered.AssertComplete();
}
public static void Union_SecondOrdered(Labeled <ParallelQuery <int> > left, int leftCount, Labeled <ParallelQuery <int> > right, int rightCount)
{
ParallelQuery <int> leftQuery = left.Item;
ParallelQuery <int> rightQuery = right.Item;
IntegerRangeSet seenUnordered = new IntegerRangeSet(0, leftCount);
int seen = leftCount;
foreach (int i in leftQuery.Union(rightQuery))
{
if (i >= leftCount)
{
Assert.Equal(seen++, i);
}
else
{
seenUnordered.Add(i);
}
}
Assert.Equal(leftCount + rightCount, seen);
seenUnordered.AssertComplete();
}
private static void RunAllTests(
TestTracker result, ParallelQuery <int> q, bool orderPreserved,
string leftOpName, bool leftOrderDefined)
{
LogTestRun(leftOpName, "All1", orderPreserved);
result.MustEqual(
q.All(i => i > 100),
q.ToArray().Any(i => i > 100));
LogTestRun(leftOpName, "All2", orderPreserved);
result.MustEqual(
q.All(i => i == 75),
q.ToArray().All(i => i == 75));
LogTestRun(leftOpName, "Any1", orderPreserved);
result.MustEqual(
q.Any(i => i > 100),
q.ToArray().Any(i => i > 100));
LogTestRun(leftOpName, "Any2", orderPreserved);
result.MustEqual(
q.Any(i => i == 75),
q.ToArray().Any(i => i == 75));
LogTestRun(leftOpName, "Concat", orderPreserved);
result.MustSequenceEqual(
q.Concat(q).Concat(new int[] { 1, 2, 3 }.AsParallel()),
q.Reverse().Reverse().ToArray().Concat(q.Reverse().Reverse()).Concat(new int[] { 1, 2, 3 }),
leftOrderDefined && orderPreserved);
LogTestRun(leftOpName, "DefaultIfEmpty", orderPreserved);
result.MustSequenceEqual(
q.DefaultIfEmpty(),
q.ToArray().DefaultIfEmpty(), orderPreserved && leftOrderDefined);
LogTestRun(leftOpName, "ElementAt", orderPreserved);
IEnumerable <int> q2 = q.ToArray();
int count1 = q.Count(), count2 = q2.Count();
List <int> list1 = new List <int>();
List <int> list2 = new List <int>();
for (int i = 0; i < count1; i++)
{
list1.Add(q.ElementAt(i));
}
for (int i = 0; i < count2; i++)
{
list2.Add(q2.ElementAt(i));
}
result.MustSequenceEqual(list1, list2, leftOrderDefined);
LogTestRun(leftOpName, "Except", orderPreserved);
result.MustSequenceEqual(
q.Except(Enumerable.Range(90, 50).AsParallel()),
q.ToArray().Except(Enumerable.Range(90, 50)),
false);
LogTestRun(leftOpName, "First", orderPreserved);
CheckFirstOrLast(
result,
q.First(),
q.ToArray().First(),
leftOrderDefined);
LogTestRun(leftOpName, "GroupBy", orderPreserved);
result.MustGroupByEqual(
q.GroupBy(i => i % 5, (i, e) => new Pair <int, IEnumerable <int> >(i, e)),
q.ToArray().GroupBy(i => i % 5, (i, e) => new Pair <int, IEnumerable <int> >(i, e)));
LogTestRun(leftOpName, "GroupJoin", orderPreserved);
result.MustSequenceEqual(
q.GroupJoin(q, i => i, i => i, (i, e) => e.FirstOrDefault()),
q.ToArray().GroupJoin(q.ToArray(), i => i, i => i, (i, e) => e.FirstOrDefault()),
false);
LogTestRun(leftOpName, "Intersect", orderPreserved);
result.MustSequenceEqual(
q.Intersect(Enumerable.Range(90, 50).AsParallel()),
q.ToArray().Intersect(Enumerable.Range(90, 50)),
false);
LogTestRun(leftOpName, "Join1", orderPreserved);
result.MustSequenceEqual(
q.Join((new int[] { 1, 1, 2, 3, 3 }).AsParallel(), i => i, i => i, (i, j) => i + j),
q.ToArray().Join(new int[] { 1, 1, 2, 3, 3 }, i => i, i => i, (i, j) => i + j),
false);
LogTestRun(leftOpName, "Join2", orderPreserved);
result.MustSequenceEqual(
q.Join((new int[] { 1, 1, 100, 3, 3 }).AsParallel(), i => new String('a', i), i => new String('a', i), (i, j) => i + j),
q.ToArray().Join(new int[] { 1, 1, 100, 3, 3 }, i => new String('a', i), i => new String('a', i), (i, j) => i + j),
false);
LogTestRun(leftOpName, "Last", orderPreserved);
CheckFirstOrLast(
result,
q.Last(),
q.ToArray().Last(),
leftOrderDefined);
LogTestRun(leftOpName, "Min", orderPreserved);
CheckFirstOrLast(
result,
q.Min(),
q.ToArray().Min(),
leftOrderDefined);
LogTestRun(leftOpName, "Max", orderPreserved);
CheckFirstOrLast(
result,
q.Min(),
q.ToArray().Min(),
leftOrderDefined);
LogTestRun(leftOpName, "OrderBy-ThenBy", orderPreserved);
result.MustSequenceEqual(
q.Concat(q).OrderBy(i => i % 5).ThenBy(i => - i),
q.ToArray().Concat(q).OrderBy(i => i % 5).ThenBy(i => - i),
true);
LogTestRun(leftOpName, "OrderByDescending-ThenByDescending", orderPreserved);
result.MustSequenceEqual(
q.Concat(q).OrderByDescending(i => i % 5).ThenByDescending(i => - i),
q.ToArray().Concat(q).OrderByDescending(i => i % 5).ThenByDescending(i => - i),
true);
LogTestRun(leftOpName, "Reverse", orderPreserved);
result.MustSequenceEqual(
q.Concat(q).Reverse(),
q.ToArray().Concat(q).Reverse(),
orderPreserved && leftOrderDefined);
LogTestRun(leftOpName, "Select", orderPreserved);
result.MustSequenceEqual(
q.Select(i => 5 * i - 17),
q.ToArray().Select(i => 5 * i - 17),
orderPreserved && leftOrderDefined);
LogTestRun(leftOpName, "SelectMany", orderPreserved);
result.MustSequenceEqual(
q.SelectMany(i => new int[] { 1, 2, 3 }, (i, j) => i + 100 * j),
q.ToArray().SelectMany(i => new int[] { 1, 2, 3 }, (i, j) => i + 100 * j),
false);
LogTestRun(leftOpName, "SequenceEqual", orderPreserved);
if (orderPreserved && leftOrderDefined)
{
result.MustEqual(q.SequenceEqual(q), true);
}
else
{
// We don't check the return value as it can be either true or false
q.SequenceEqual(q);
}
LogTestRun(leftOpName, "Skip", orderPreserved);
CheckTakeSkip(
result,
q.Skip(10),
q.ToArray().Skip(10),
leftOrderDefined && orderPreserved);
LogTestRun(leftOpName, "SkipWhile", orderPreserved);
CheckTakeSkip(
result,
q.SkipWhile(i => i < 30),
q.ToArray().SkipWhile(i => i < 30),
leftOrderDefined && orderPreserved);
LogTestRun(leftOpName, "SkipWhileIndexed", orderPreserved);
CheckTakeSkip(
result,
q.SkipWhile((i, j) => j < 30),
q.ToArray().SkipWhile((i, j) => j < 30),
leftOrderDefined && orderPreserved);
LogTestRun(leftOpName, "Take", orderPreserved);
CheckTakeSkip(
result,
q.Take(10),
q.ToArray().Take(10),
leftOrderDefined && orderPreserved);
LogTestRun(leftOpName, "TakeWhile", orderPreserved);
CheckTakeSkip(
result,
q.TakeWhile(i => i < 30),
q.ToArray().TakeWhile(i => i < 30),
leftOrderDefined && orderPreserved);
LogTestRun(leftOpName, "TakeWhileIndexed", orderPreserved);
CheckTakeSkip(
result,
q.TakeWhile((i, j) => j < 30),
q.ToArray().TakeWhile((i, j) => j < 30),
leftOrderDefined && orderPreserved);
LogTestRun(leftOpName, "Union", orderPreserved);
result.MustSequenceEqual(
q.Union(Enumerable.Range(90, 50).AsParallel()),
q.ToArray().Union(Enumerable.Range(90, 50)),
false);
LogTestRun(leftOpName, "Where", orderPreserved);
result.MustSequenceEqual(
q.Where(i => i < 20 || i > 80),
q.ToArray().Where(i => i < 20 || i > 80),
orderPreserved && leftOrderDefined);
LogTestRun(leftOpName, "Zip", orderPreserved);
IEnumerable <KeyValuePair <int, int> > zipQ = q.Zip(q, (i, j) => new KeyValuePair <int, int>(i, j));
result.MustSequenceEqual(
zipQ.Select(p => p.Key),
q.Reverse().Reverse().ToArray(),
orderPreserved && leftOrderDefined);
result.MustSequenceEqual(
zipQ.Select(p => p.Value),
q.Reverse().Reverse().ToArray(),
orderPreserved && leftOrderDefined);
}
public static void Union_Unordered_SourceMultiple(ParallelQuery<int> leftQuery, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int count)
{
// The difference between this test and the previous, is that it's not possible to
// get non-unique results from ParallelEnumerable.Range()...
// Those tests either need modification of source (via .Select(x => x / DuplicateFactor) or similar,
// or via a comparator that considers some elements equal.
IntegerRangeSet seen = new IntegerRangeSet(0, count);
Assert.All(leftQuery.Union(rightQuery), x => seen.Add(x));
seen.AssertComplete();
}
public static void Union_SecondOrdered_SourceMultiple(ParallelQuery<int> leftQuery, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int count)
{
IntegerRangeSet seenUnordered = new IntegerRangeSet(0, leftCount);
int seen = leftCount;
foreach (int i in leftQuery.Union(rightQuery.AsOrdered()))
{
if (i >= leftCount)
{
Assert.Equal(seen++, i);
}
else
{
seenUnordered.Add(i);
}
}
Assert.Equal(count, seen);
seenUnordered.AssertComplete();
}
/// <summary>
/// Produces the set union of two sequences of ILexical constructs by using the specified
/// comparison function to compare values.
/// </summary>
/// <typeparam name="TLexical">Any type which implements the ILexical interface.</typeparam>
/// <param name="first">
/// A sequence of TLexical whose distinct elements form the first set of the union.
/// </param>
/// <param name="second">
/// A sequence of TLexical whose distinct elements form the second set of the union.
/// </param>
/// <param name="equate">A function to compare two TLexicals for equality.</param>
/// <returns>
/// A sequence that contains the elements from both input sequences, excluding duplicates.
/// </returns>
/// <example>
/// <code>
/// var distinctActionsAcross = doc1.Verbals
/// .Union(doc2.Verbals, (a1, a2) => a1.IsSimilarTo(A2));
/// </code>
/// </example>
public static ParallelQuery <TLexical> Union <TLexical>(this ParallelQuery <TLexical> first, ParallelQuery <TLexical> second, Func <TLexical, TLexical, bool> equate)
where TLexical : ILexical => first.Union(second, Equality.Create(equate));