public static IExampleSpace <TResult> MergeInternal <T, TResult>(
List <IExampleSpace <T> > exampleSpaces,
Func <List <T>, TResult> mergeValues,
ShrinkFunc <List <IExampleSpace <T> > > shrinkExampleSpaces,
MeasureFunc <List <IExampleSpace <T> > > measureMerge,
ImmutableHashSet <ExampleId> encounteredIds,
bool enableSmallestExampleSpacesOptimization,
bool isRoot)
{
IExampleSpace <TResult> GenerateNextExampleSpace(IEnumerable <IExampleSpace <T> > exampleSpaces, ImmutableHashSet <ExampleId> encounteredIds)
{
return(MergeInternal(
exampleSpaces.ToList(),
mergeValues,
shrinkExampleSpaces,
measureMerge,
encounteredIds,
enableSmallestExampleSpacesOptimization,
false));
}
var mergedId = exampleSpaces.Aggregate(
ExampleId.Primitive(exampleSpaces.Count()),
(acc, curr) => ExampleId.Combine(acc, curr.Current.Id));
var mergedValue = mergeValues(exampleSpaces.Select(es => es.Current.Value).ToList());
var mergedDistance = measureMerge(exampleSpaces);
var current = new Example <TResult>(
mergedId,
mergedValue,
mergedDistance);
var smallestExampleSpacesShrink = enableSmallestExampleSpacesOptimization && isRoot && exampleSpaces.Any(exampleSpace => exampleSpace.Subspace.Any())
? exampleSpaces
.Select(exampleSpace =>
{
var smallestExampleSpace = exampleSpace.Subspace.FirstOrDefault() ?? exampleSpace;
return(smallestExampleSpace);
})
.ToList()
: null;
var exampleSpaceCullingShrinks = shrinkExampleSpaces(exampleSpaces);
var subspaceMergingShrinks = exampleSpaces
.Select((exampleSpace, index) => LiftAndInsertSubspace(exampleSpaces, exampleSpace.Subspace, index))
.SelectMany(exampleSpaces => exampleSpaces);
var shrinks = TraverseUnencountered(
Enumerable.Concat(
smallestExampleSpacesShrink == null ? Enumerable.Empty <List <IExampleSpace <T> > >() : new[] { smallestExampleSpacesShrink }.AsEnumerable(),
Enumerable.Concat(exampleSpaceCullingShrinks, subspaceMergingShrinks)),
encounteredIds,
GenerateNextExampleSpace);
return(new ExampleSpace <TResult>(current, shrinks));
}
private static IExampleSpace <IEnumerable <T> > CreateInfiniteEnumerableSpace(
IGen <T> elementGen,
GenParameters parameters,
int?iterationLimit)
{
IEnumerable <T> SealEnumerable(IEnumerable <T> source) => ThrowOnLimit(source.Repeat(), iterationLimit);
var enumerable = CreateInfiniteEnumerable(elementGen, parameters, iterationLimit);
IExample <IEnumerable <T> > rootExample = new Example <IEnumerable <T> >(
ExampleId.Primitive(parameters.Rng.Seed),
enumerable.Select(x => x.Current.Value),
100);
return(ExampleSpaceFactory.Delay(
rootExample,
() =>
{
if (enumerable.MaxIterations == 0)
{
return Enumerable.Empty <IExampleSpace <IEnumerable <T> > >();
}
if (enumerable.MaxIterations == 1)
{
var exampleSpace = enumerable.First().Map(element => SealEnumerable(new[] { element }));
return new[] { exampleSpace };
}
var exampleSpaces = enumerable.Take(enumerable.MaxIterations).ToList();
var rootExampleExplored = ExampleSpaceFactory.Merge(
exampleSpaces,
xs => xs,
ShrinkTowardsLength(1),
(_) => 0,
enableSmallestExampleSpacesOptimization: false);
return rootExampleExplored.Subspace.Select(es => es.Map(SealEnumerable));
}));
}
public static IdentifyFunc <T> Default <T>() => (value) => ExampleId.Primitive(value);
private static ExampleId RandomId() => ExampleId.Primitive(Guid.NewGuid().GetHashCode());