private static void Validate(int minimum, int maximum, RangeInclusivity inclusivity = RangeInclusivity.AllInclusive)
{
if (minimum > maximum)
{
throw new ArgumentException($"The minimum must be less than or equal to the maximum. Minimum was {minimum}. Maximum was {maximum}.");
}
}
public static IRange <T> To <T>(
this T from,
T to,
RangeInclusivity inclusivity = RangeInclusivity.InclusiveMinInclusiveMax
)
where T : IComparable <T>
{
return(new Range <T>(from, to, inclusivity));
}
/// <param name="minimum">Minimum value</param>
/// <param name="maximum">Maximum value</param>
/// <param name="inclusivity">Range inclusivity</param>
public Range(
T minimum,
T maximum,
RangeInclusivity inclusivity = RangeInclusivity.InclusiveMinInclusiveMax)
{
Inclusivity = inclusivity;
var reverse = minimum.CompareTo(maximum) > 0;
_minimum = new Settable <T>(reverse ? maximum : minimum);
_maximum = new Settable <T>(reverse ? minimum : maximum);
}
public void WhenAnyInclusivity_RangeShouldContainItself(RangeInclusivity inclusivity)
{
// Arrange
var range = new Range <int>(1, 4, inclusivity);
// Act
var actual = range.Contains(range);
// Assert
Assert.True(actual);
}
public void WhenSameRange_ExclusiveShouldNotContainInclusive(RangeInclusivity r1Inc, RangeInclusivity r2Inc)
{
// Arrange
var r1 = new Range <int>(1, 4, r1Inc);
var r2 = new Range <int>(1, 4, r2Inc);
// Act
var actual = r1.Contains(r2);
// Assert
Assert.False(actual);
}
public void WhenRangeDoesNotContainsRange_ContainsShouldBeFalse(
int r1Min, int r1Max, RangeInclusivity r1Inc,
int r2Min, int r2Max, RangeInclusivity r2Inc)
{
// Arrange
var r1 = new Range <int>(r1Min, r1Max, r1Inc);
var r2 = new Range <int>(r2Min, r2Max, r2Inc);
// Act
var actual = r1.Contains(r2);
// Assert
Assert.False(actual);
}
public void WhenZeroWidthRange_ShouleBeExpected(RangeInclusivity inclusivitiy, bool expected)
{
// Arrange
var r = new Range <int>()
{
Maximum = 100,
Minimum = 100,
Inclusivity = inclusivitiy
};
// Act
var actual = r.Contains(100);
// Assert
Assert.Equal(expected, actual);
}
public void WhenContainsSpecificInclusivity_ShouldBeExpected2(double value, RangeInclusivity inclusivitiy, bool expected)
{
// Arrange
var r = new Range <double>()
{
Maximum = 10.00,
Minimum = 1.00,
Inclusivity = inclusivitiy
};
// Act
var actual = r.Contains(value);
// Assert
Assert.Equal(expected, actual);
}
public void WhenRangesCombined_ShouldBeIntersect(
int aMin,
int aMax,
int bMin,
int bMax,
RangeInclusivity inclusivity)
{
// Arrange
var aRange = new Range <int>(aMin, aMax, inclusivity);
var bRange = new Range <int>(bMin, bMax, inclusivity);
// Act
var actual = aRange.TryIntersect(bRange, out _);
// Assert
Assert.False(actual);
}
public void WhenIntersects_ShouldBeInsectingRange(
int aMin,
int aMax,
int bMin,
int bMax,
RangeInclusivity inclusivity,
bool expected)
{
// Arrange
var aRange = new Range <int>(aMin, aMax, inclusivity);
var bRange = new Range <int>(bMin, bMax, inclusivity);
// Act
var actual = aRange.Intersects(bRange);
// Assert
Assert.Equal(expected, actual);
}
public static IRange <TProperty> Range <TValue, TProperty>(
this IEnumerable <TValue> enumerable,
Func <TValue, TProperty> propertySelector,
RangeInclusivity inclusivity = RangeInclusivity.InclusiveMinInclusiveMax) where TProperty : IComparable <TProperty>
{
var minmax = enumerable.Aggregate(
new MutablePair <TProperty>(),
(agg, val) => {
var propertyValue = propertySelector(val);
agg.Value1 = propertyValue.CompareTo(agg.Value1) < 0 ? propertyValue : agg.Value1;
agg.Value2 = propertyValue.CompareTo(agg.Value2) > 0 ? propertyValue : agg.Value2;
return(agg);
}
);
return(new Range <TProperty>(
minmax.Value1,
minmax.Value2,
inclusivity
));
}
public Range(int minimum = 0, int maximum = 0, RangeInclusivity inclusivity = RangeInclusivity.AllInclusive)
{
this.SetValues(minimum, maximum);
this.Inclusivity = inclusivity;
}
