public void TestSetPosition(int min, int maxExcl, IntervalAnchor anchor, int expectedMin)
{
var interval = GridInterval.FromExclusiveMax(min, maxExcl);
var translated = interval.SetPosition(20, anchor);
Assert.Equal(expectedMin, translated.Min);
}
public void TestMultiplication(int min, int maxExcl, double multiplier, int?expectedMax)
{
var interval = GridInterval.FromExclusiveMax(min, maxExcl);
var result = interval.Multiplication(multiplier);
Assert.Equal(expectedMax, result?.MaxExcl);
}
public override IExplicitShape <int> Transform(IExplicitShape <int> input)
{
var shape = input.Translate(offset);
var storageRect = GridInterval.Translate(input.Bounds, offset);
return(shape.ToExplicit(storageRect));
}
public void TestTouches(int min, int maxExcl, bool expected)
{
var interval = GridInterval.FromExclusiveMax(0, 10);
var other = GridInterval.FromExclusiveMax(min, maxExcl);
Assert.Equal(expected, interval.Touches(other));
}
public void TestTranslate()
{
var interval = GridInterval.FromExclusiveMax(0, 2);
var translated = interval.Translation(5);
Assert.Equal(5, translated.Min);
Assert.Equal(7, translated.MaxExcl);
}
public void TestSetMin()
{
var i1 = GridInterval.FromExclusiveMax(20, 30);
var i2 = GridInterval.FromExclusiveMax(0, 4);
var aligned = i2.SetMin(i1.Min);
Assert.Equal(20, aligned.Min);
Assert.Equal(24, aligned.MaxExcl);
}
public void FindOverlappingIntervalsTest2()
{
var i1 = new GridInterval(1, 3);
var i2 = new GridInterval(3, 5);
var i3 = new GridInterval(1, 4);
var overlappingGroups = GridIntervals.FindOverlappingIntervals(new[] { i1, i2, i3 });
Assert.Single(overlappingGroups);
}
public void TestFindCenterOfMass()
{
var i1 = new GridInterval(-2, -2);
var i2 = new GridInterval(-2, -2);
var i3 = new GridInterval(0, 0);
var i4 = new GridInterval(4, 4);
var center = GridIntervals.FindCenterOfMass(new[] { i1, i2, i3, i4 });
Assert.Equal(0, center);
}
public void TestEquality()
{
var i1 = new GridInterval(0, 2);
var i2 = GridInterval.FromExclusiveMax(0, 3);
var i3 = GridInterval.FromLength(0, 2);
Assert.Equal(i1, i2);
Assert.True(i1 == i2);
Assert.NotEqual(i1, i3);
Assert.True(i1 != i3);
}
public void TestSplitEven()
{
var interval = GridInterval.FromExclusiveMax(0, 2);
var halves = interval.SplitEven();
Assert.Equal(2, halves.Length);
Assert.Equal(1, halves[0].Length);
Assert.Equal(1, halves[1].Length);
Assert.Equal(0, halves[0].Min);
Assert.Equal(1, halves[0].MaxExcl);
Assert.Equal(1, halves[1].Min);
Assert.Equal(2, halves[1].MaxExcl);
}
public override List <IExplicitShape <int> > Execute(IEnumerable <IExplicitShape <int> > input)
{
var inputList = input.ToList();
var shape1 = inputList[0];
var shape2 = inputList[1];
var shape = shape1.Product(shape2, scaleFactor);
var storageRect = new GridInterval(
shape1.Bounds.Point * scaleFactor - shape2.Bounds.Size,
shape1.Bounds.Size * scaleFactor + shape2.Bounds.Size * 2);
return(new List <IExplicitShape <int> >
{
shape.ToExplicit(storageRect)
});
}
public void FindOverlappingIntervalsTest()
{
var i1 = new GridInterval(0, 10);
var i2 = new GridInterval(1, 3);
var i3 = new GridInterval(2, 3);
var i4 = new GridInterval(4, 13);
var i5 = new GridInterval(12, 14);
var i6 = new GridInterval(15, 16);
var overlappingGroups = GridIntervals.FindOverlappingIntervals(new[] { i1, i2, i3, i4, i5, i6 });
Assert.Equal(3, overlappingGroups.Count);
Assert.Equal(3, overlappingGroups[0].Count);
Assert.Equal(2, overlappingGroups[1].Count);
Assert.Equal(2, overlappingGroups[2].Count);
Assert.DoesNotContain(overlappingGroups.SelectMany(g => g), index => index == 5);
}
public void TestRelate()
{
var i1 = GridInterval.FromExclusiveMax(0, 4);
var i2 = GridInterval.FromExclusiveMax(10, 14);
var related = i1.Relate(i2, Relation.StartToStart());
Assert.Equal(10, related.Min);
related = i1.Relate(i2, Relation.StartToCenter());
Assert.Equal(11, related.Min);
related = i1.Relate(i2, Relation.StartToEnd());
Assert.Equal(13, related.Min);
related = i1.Relate(i2, Relation.EndToStart());
Assert.Equal(7, related.Min);
related = i1.Relate(i2, Relation.EndToCenter());
Assert.Equal(8, related.Min);
related = i1.Relate(i2, Relation.EndToEnd());
Assert.Equal(10, related.Min);
}
public void SeparateTest()
{
var i1 = new GridInterval(0, 2);
var i2 = new GridInterval(1, 3);
var i3 = new GridInterval(2, 4);
var i4 = new GridInterval(-1, 0);
var i12 = GridIntervals.Separate(i1, i2);
Assert.Equal(-1, i12[0].Min);
Assert.Equal(2, i12[1].Min);
var i13 = GridIntervals.Separate(i1, i3);
Assert.Equal(-1, i13[0].Min);
Assert.Equal(2, i13[1].Min);
var i14 = GridIntervals.Separate(i1, i4);
Assert.Equal(0, i14[0].Min);
Assert.Equal(-2, i14[1].Min);
}
public void TestDepth(int value, int expected)
{
var interval = new GridInterval(-1, 3);
Assert.Equal(expected, interval.Depth(value));
}
public void TestContainsInterval(int min, int max, bool expected)
{
var interval = new GridInterval(0, 1);
Assert.Equal(expected, interval.Contains(new GridInterval(min, max)));
}
public void TestDistance(int value, int expected)
{
var interval = new GridInterval(-1, 1);
Assert.Equal(expected, interval.Distance(value));
}
public void TestDistanceToOther(int otherMin, int otherMax, int expected)
{
var interval = new GridInterval(-1, 0);
Assert.Equal(expected, interval.Distance(new GridInterval(otherMin, otherMax)));
}
public void TestContains(int value, bool expected)
{
var interval = new GridInterval(0, 1);
Assert.Equal(expected, interval.Contains(value));
}
public void TestLength()
{
var interval = new GridInterval(2, 4);
Assert.Equal(3, interval.Length);
}
public void TestIsEven(int min, int maxExcl, bool expected)
{
var interval = GridInterval.FromExclusiveMax(min, maxExcl);
Assert.Equal(expected, interval.IsEven());
}
public void TestCenter(int min, int max, int expected)
{
var interval = new GridInterval(min, max);
Assert.Equal(expected, interval.Center);
}
public void TestDepthToSeparateOther(int otherMin, int otherMax, int expected)
{
var interval = new GridInterval(-1, 2);
Assert.Equal(expected, interval.Depth(new GridInterval(otherMin, otherMax)));
}
protected override IExplicitShape <int> Generate()
{
var interval = new GridInterval(0, size);
return(ImplicitShape.Segment(interval).ToExplicit(interval));
}
public void TestArgumentException()
{
Assert.Throws <ArgumentException>(() => GridInterval.FromExclusiveMax(2, 2));
}
