public void ConstructMinMax_MaxIsLessThanMin_Throws()
{
var ex = Assert.Throws <ArgumentException>(() =>
{
var _ = new NaturalRange(3, 2);
});
}
public int[] FindIndicesOfFittestIndividuals(Array <Fitness> fitnesses)
{
var indices = NaturalRange
.CreateSorted(inclusiveStart: 0, exclusiveEnd: fitnesses.Length)
.ToArray();
var fitnessArray = fitnesses.ToArray();
Array.Sort(
keys: fitnessArray,
items: indices,
comparer: _comparer);
Array.Reverse(indices);
var fittest = indices
.AsSpan()
.Slice(start: 0, length: _fittestCount)
.ToArray();
return(fittest);
}
public HyperRectangle?TryCreateLargestNonIntersectingRectangle(int seedIndex, Array <HyperRectangle> existingHyperRectangles, NaturalRange dimensionExpansionOrder)
{
if (dimensionExpansionOrder.Length != Dataset.FeatureCount)
{
throw new InvalidOperationException();
}
if (existingHyperRectangles.IsEmpty)
{
var tempBuilder = HyperRectangleBuilder.InitializeWithLargestRectangle(Dataset);
var hyperRectangle = tempBuilder.TryBuild();
if (hyperRectangle is null)
{
throw new InvalidOperationException();
}
else
{
return(hyperRectangle);
}
}
var builder = HyperRectangleBuilder.InitializeWithSeed(
dataset: Dataset,
seedIndex: seedIndex);
var seed = Dataset.GetInstanceData(seedIndex);
for (int i = 0; i < dimensionExpansionOrder.Length; i++)
{
var dimensionIndex = dimensionExpansionOrder[i];
switch (Dataset.GetFeatureType(dimensionIndex))
{
case FeatureType.Continuous:
UpdateContinuousDimension(
builder: builder,
existingHyperRectangles: existingHyperRectangles,
dimensionIndex: dimensionIndex,
seed: seed);
break;
default:
throw CommonExceptions.UnknownFeatureType;
}
}
var largestHyperRectangle = builder.TryBuild();
return(largestHyperRectangle);
}
public void Max_ConstructMinMax_IsMax()
{
var underTest = new NaturalRange(_min, _max);
Assert.Equal(_max, underTest.Max);
}
public void Min_ConstructMax_IsZero()
{
var underTest = new NaturalRange(_max);
Assert.Equal(0, underTest.Min);
}
public void ConstructMinMax_MaxIsZero_Constructs()
{
// min must also be zero so that max >= min
var _ = new NaturalRange(0, 0);
}
public void Construct_MaxIsMin_Constructs()
{
var _ = new NaturalRange(_min, _min);
}
public void ConstructMinMax_MinIsZero_Constructs()
{
var _ = new NaturalRange(0, _max);
}
public void ConstructMinMax_ValidArgs_Constructs()
{
var _ = new NaturalRange(_min, _max);
}
public void ConstructMax_MaxIsZero_Constructs()
{
var _ = new NaturalRange(0);
}
public void Includes_ValueIsGreaterThanMax_True()
{
var underTest = new NaturalRange(_min, _max);
Assert.False(underTest.Includes(_max + 1));
}
public void Includes_ValueIsMax_True()
{
var underTest = new NaturalRange(_min, _max);
Assert.True(underTest.Includes(_max));
}
public void Includes_ValueIsLessThanMin_False()
{
var underTest = new NaturalRange(_min, _max);
Assert.False(underTest.Includes(_min - 1));
}
public Rule?TryCreateRule(ReadOnlySpan <Rule> existingRules)
{
var seedsIndices = _seedSelector.FindSeedsIndices(existingRules);
if (seedsIndices.IsEmpty)
{
return(null);
}
var seedIndex = Random.Choice(seedsIndices);
var seed = _dataset.GetInstanceData(seedIndex);
var boxes = _boxConverter.FromRules(existingRules);
if (_runExpensiveSanityChecks)
{
for (int i = 0; i < boxes.Length; i++)
{
var box = boxes[i];
if (box.Contains(seed))
{
throw new InvalidOperationException();
}
}
}
var dimensionExpansionOrder = NaturalRange.CreateShuffled(
inclusiveStart: 0,
exclusiveEnd: _dataset.FeatureCount);
var secureRectangle = _boxCreator.TryCreateLargestNonIntersectingRectangle(
seedIndex: seedIndex,
existingHyperRectangles: boxes,
dimensionExpansionOrder: dimensionExpansionOrder);
if (secureRectangle is null)
{
return(null);
}
if (_runExpensiveSanityChecks)
{
for (int i = 0; i < boxes.Length; i++)
{
var box = boxes[i];
if (_rectangleIntersector.IntersectsInAllDimension(secureRectangle, box))
{
throw new InvalidOperationException();
}
}
}
var secureRectangleCoverage = _coverageComputer.ComputeCoverage(secureRectangle);
var coveredInstancesIndices = secureRectangleCoverage.IndicesOfCoveredInstances.ToArray();
if (coveredInstancesIndices.Length == 0)
{
return(null);
}
var coveredInstancesDistancesToSeed = _dataset.ComputeDistances(
targetInstanceIndex: seedIndex,
otherInstancesIndices: coveredInstancesIndices);
Array.Sort(
keys: coveredInstancesDistancesToSeed,
items: coveredInstancesIndices);
var instancesToCover = Math.Min(_targetNumberOfInstancesToCover, coveredInstancesIndices.Length);
var relevantInstances = coveredInstancesIndices
.AsSpan()
.Slice(start: 0, length: instancesToCover);
var ruleAntecedent = _antecedentCreator.CreateAntecedent(
seedIndex: seedIndex,
nearestInstancesIndices: relevantInstances);
if (ruleAntecedent is null)
{
return(null);
}
var ruleConsequent = _consequentCreator.CreateConsequent(relevantInstances);
return(new Rule(
antecedent: ruleAntecedent,
consequent: ruleConsequent));
}
