private void EnlargeContinuousInterval(HyperRectangleBuilder builder, Array <float> instance, int dimensionIndex)
{
var(Start, End) = builder.GetContinuousDimensionPreview(dimensionIndex);
var target = instance[dimensionIndex];
if (target < Start)
{
builder.UpdateContinuousDimensionIntervalStart(
dimensionIndex: dimensionIndex,
value: target);
return;
}
if (target >= End)
{
var possibleValues = _dataset.GetSortedUniqueFeatureValues(featureIndex: dimensionIndex);
var indexOfStart = possibleValues.BinarySearch(target);
if (indexOfStart == possibleValues.Length - 1)
{
builder.UpdateContinuousDimensionIntervalEnd(
dimensionIndex: dimensionIndex,
value: float.PositiveInfinity);
}
else
{
var nextLarger = possibleValues[indexOfStart + 1];
builder.UpdateContinuousDimensionIntervalEnd(
dimensionIndex: dimensionIndex,
value: nextLarger);
}
}
}
public Antecedent?CreateAntecedent(int seedIndex, ReadOnlySpan <int> nearestInstancesIndices)
{
var builder = HyperRectangleBuilder.InitializeWithSeed(
dataset: _dataset,
seedIndex: seedIndex);
for (int i = 0; i < nearestInstancesIndices.Length; i++)
{
var index = nearestInstancesIndices[i];
EnlargeToCoverInstance(
builder: builder,
instanceIndex: index);
}
var box = builder.TryBuild();
if (box is null)
{
return(null);
}
var featureTests = _converter.FromHyperRectangle(box);
return(new Antecedent(featureTests));
}
private bool Intersects(HyperRectangleBuilder builder, HyperRectangle rect, int dimensionIndex)
{
return(Dataset.GetFeatureType(dimensionIndex) switch
{
FeatureType.Continuous => IntersectsContinuous(builder, rect, dimensionIndex),
_ => throw CommonExceptions.UnknownFeatureType
});
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);
}
private void EnlargeToCoverInstance(HyperRectangleBuilder builder, int instanceIndex)
{
var dimensionCount = _dataset.FeatureCount;
var instance = _dataset.GetInstanceData(instanceIndex);
for (int i = 0; i < dimensionCount; i++)
{
switch (_dataset.GetFeatureType(i))
{
case FeatureType.Continuous:
EnlargeContinuousInterval(
builder: builder,
instance: instance,
dimensionIndex: i);
break;
default:
throw CommonExceptions.UnknownFeatureType;
}
}
}
private void UpdateContinuousDimension(HyperRectangleBuilder builder, Array <HyperRectangle> existingHyperRectangles, int dimensionIndex, Array <float> seed)
{
var min = float.NegativeInfinity;
var max = float.PositiveInfinity;
for (int i = 0; i < existingHyperRectangles.Length; i++)
{
var currentRectangle = existingHyperRectangles[i];
var intersects = _intersector.IntersectsInAllButOneDimension(
builder: builder,
rect: currentRectangle,
dimensionToSkip: dimensionIndex);
if (!intersects)
{
continue;
}
var dimension = (ContinuousInterval)currentRectangle.GetDimensionInterval(dimensionIndex);
var otherEnd = dimension.End;
var otherStart = dimension.Start;
var seedValue = seed[dimensionIndex];
if (seedValue >= otherEnd)
{
min = Math.Max(min, otherEnd);
}
else
{
max = Math.Min(max, otherStart);
}
}
builder.UpdateContinuousDimensionIntervalStart(dimensionIndex: dimensionIndex, value: min);
builder.UpdateContinuousDimensionIntervalEnd(dimensionIndex: dimensionIndex, value: max);
}
public bool IntersectsInAllButOneDimension(HyperRectangleBuilder builder, HyperRectangle rect, int dimensionToSkip)
{
var dimensionCount = Dataset.FeatureCount;
for (int i = 0; i < dimensionCount; i++)
{
if (i == dimensionToSkip)
{
continue;
}
var intersects = Intersects(
builder: builder,
rect: rect,
dimensionIndex: i);
if (!intersects)
{
return(false);
}
}
return(true);
}
