public void TestBoundaryNegativeInfinityValue()
{
double?infOk = double.NegativeInfinity;
double?infFail = double.PositiveInfinity;
double?empty = null;
DoesNotThrow(() => new RangeBoundaryFrom <double?>(infOk, RangeBoundaryFromKind.Infinite));
Throws <ArgumentException>(() => new RangeBoundaryFrom <double?>(infOk, RangeBoundaryFromKind.Empty));
Throws <ArgumentException>(() => new RangeBoundaryFrom <double?>(infFail, RangeBoundaryFromKind.Empty));
Throws <ArgumentException>(() => new RangeBoundaryFrom <double?>(infFail, RangeBoundaryFromKind.Infinite));
Throws <ArgumentException>(() => new RangeBoundaryFrom <double?>(infOk, RangeBoundaryFromKind.Inclusive));
Throws <ArgumentException>(() => new RangeBoundaryFrom <double?>(infFail, RangeBoundaryFromKind.Inclusive));
Throws <ArgumentException>(() => new RangeBoundaryFrom <double?>(infOk, RangeBoundaryFromKind.Exclusive));
Throws <ArgumentException>(() => new RangeBoundaryFrom <double?>(infFail, RangeBoundaryFromKind.Exclusive));
AreEqual(
RangeBoundaryFrom <double?> .NegativeInfinity,
Range.BoundaryFrom(infOk));
AreEqual(
RangeBoundaryFrom <double?> .NegativeInfinity,
Range.BoundaryFromExclusive(infOk));
AreEqual(
RangeBoundaryFrom <double> .NegativeInfinity,
Range.BoundaryFrom(infOk.Value));
AreEqual(
RangeBoundaryFrom <double> .NegativeInfinity,
Range.BoundaryFromExclusive(infOk.Value));
AreEqual(
Range.BoundaryFromExclusive(infOk).GetValueOrDefault(),
empty);
}
/// <summary>
/// Replaces exclusive boundaries with inclusive ones with the values from the selector callbacks
/// </summary>
/// <typeparam name="T">The type of the range values.</typeparam>
/// <param name="range">The source range.</param>
/// <param name="fromValueSelector">Callback to obtain a new value for the From boundary. Used if the boundary is exclusive.</param>
/// <param name="toValueSelector">Callback to obtain a new value for the To boundary. Used if the boundary is exclusive.</param>
/// <returns>A range with inclusive boundaries.</returns>
public static Range <T> MakeInclusive <T>(
this Range <T> range,
[NotNull, InstantHandle] Func <T, T> fromValueSelector,
[NotNull, InstantHandle] Func <T, T> toValueSelector)
{
if (range.IsEmpty || (!range.From.IsExclusiveBoundary && !range.To.IsExclusiveBoundary))
{
return(range);
}
var from = range.From;
if (from.IsExclusiveBoundary)
{
from = Range.BoundaryFrom(fromValueSelector(from.GetValueOrDefault()));
}
var to = range.To;
if (to.IsExclusiveBoundary)
{
to = Range.BoundaryTo(toValueSelector(to.GetValueOrDefault()));
}
return(range.TryCreateRange(from, to));
}
public void TestBoundaryFromComplementation()
{
int?value1 = 1;
int?value2 = 2;
var boundary = Range.BoundaryFrom(value1);
var boundaryCompl = boundary.GetComplementation();
IsTrue(boundaryCompl.IsComplementationFor(boundary));
IsFalse(boundaryCompl.IsComplementationFor(Range.BoundaryFrom(value2)));
IsFalse(boundaryCompl.IsComplementationFor(RangeBoundaryFrom <int?> .Empty));
IsFalse(boundaryCompl.IsComplementationFor(RangeBoundaryFrom <int?> .NegativeInfinity));
AreEqual(boundaryCompl.Value, 1);
AreEqual(boundaryCompl.Kind, RangeBoundaryToKind.Exclusive);
AreEqual(boundaryCompl.GetComplementation(), boundary);
boundary = Range.BoundaryFromExclusive(value1);
boundaryCompl = boundary.GetComplementation();
IsTrue(boundaryCompl.IsComplementationFor(boundary));
IsFalse(boundaryCompl.IsComplementationFor(Range.BoundaryFrom(value2)));
IsFalse(boundaryCompl.IsComplementationFor(RangeBoundaryFrom <int?> .Empty));
IsFalse(boundaryCompl.IsComplementationFor(RangeBoundaryFrom <int?> .NegativeInfinity));
AreEqual(boundaryCompl.Value, 1);
AreEqual(boundaryCompl.Kind, RangeBoundaryToKind.Inclusive);
AreEqual(boundaryCompl.GetComplementation(), boundary);
boundary = RangeBoundaryFrom <int?> .Empty;
Throws <InvalidOperationException>(() => boundary.GetComplementation());
boundary = RangeBoundaryFrom <int?> .NegativeInfinity;
Throws <InvalidOperationException>(() => boundary.GetComplementation());
}
public static void TestBoundaryValueComparison()
{
int?value1 = 1;
int?value2 = 2;
var eFrom = RangeBoundaryFrom <int?> .Empty;
var nInf = Range.BoundaryFromInfinity <int?>();
var pInf = Range.BoundaryToInfinity <int?>();
var fromInc1 = Range.BoundaryFrom(value1);
var fromEx1 = Range.BoundaryFromExclusive(value1);
var toInc1 = Range.BoundaryTo(value1);
var toEx1 = Range.BoundaryToExclusive(value1);
var fromInc2 = Range.BoundaryFrom(value2);
var fromEx2 = Range.BoundaryFromExclusive(value2);
var toInc2 = Range.BoundaryTo(value2);
var toEx2 = Range.BoundaryToExclusive(value2);
IsTrue(eFrom < nInf);
IsTrue(nInf < toEx1);
IsTrue(toEx1 < fromInc1);
IsTrue(fromInc1 <= toInc1);
IsTrue(toInc1 < fromEx1);
IsTrue(fromEx1 < toEx2);
IsTrue(toEx2 < fromInc2);
IsTrue(fromInc2 <= toInc2);
IsTrue(toInc2 < fromEx2);
IsTrue(fromEx2 < pInf);
}
public static void TestRangeCreate()
{
int?value1 = 1;
int?value2 = 2;
int?empty = null;
var key = "Hello!";
DoesNotThrow(() => Range.Create(value1, value2));
DoesNotThrow(() => Range.Create(value1, value1));
DoesNotThrow(() => Range.Create(empty, value2));
DoesNotThrow(() => Range.Create(empty, empty));
DoesNotThrow(() => Range.CreateExclusiveFrom(value1, value2));
Throws <ArgumentException>(() => Range.CreateExclusiveFrom(value1, value1));
DoesNotThrow(() => Range.CreateExclusiveFrom(empty, value2));
DoesNotThrow(() => Range.CreateExclusiveFrom(empty, empty));
DoesNotThrow(() => Range.CreateExclusiveTo(value1, value2, key));
Throws <ArgumentException>(() => Range.CreateExclusiveTo(value2, value2, key));
DoesNotThrow(() => Range.CreateExclusiveTo(empty, value2, key));
DoesNotThrow(() => Range.CreateExclusiveTo(empty, empty, key));
DoesNotThrow(() => Range.CreateExclusive(value1, value2, key));
Throws <ArgumentException>(() => Range.CreateExclusive(value2, value2, key));
DoesNotThrow(() => Range.CreateExclusive(empty, value2, key));
DoesNotThrow(() => Range.CreateExclusive(empty, empty, key));
Throws <ArgumentException>(() => Range.Create(value2, value1, key));
Throws <ArgumentException>(() => Range.CreateExclusiveFrom(value2, value1));
Throws <ArgumentException>(() => Range.CreateExclusiveTo(value2, value1, key));
Throws <ArgumentException>(() => Range.CreateExclusive(value2, value1, key));
Throws <ArgumentException>(() => Range.Create(RangeBoundaryFrom <int?> .Empty, Range.BoundaryTo(value2), key));
Throws <ArgumentException>(() => Range.Create(Range.BoundaryFrom(empty), RangeBoundaryTo <int?> .Empty, key));
Throws <ArgumentException>(() => Range.Create(double.NegativeInfinity, double.NegativeInfinity, key));
Throws <ArgumentException>(() => Range.Create(double.PositiveInfinity, double.PositiveInfinity, key));
Throws <ArgumentException>(() => Range.Create(double.PositiveInfinity, double.NegativeInfinity, key));
Throws <ArgumentException>(() => Range.Create(double.PositiveInfinity, 2, key));
Throws <ArgumentException>(() => Range.Create(1, double.NegativeInfinity, key));
AreEqual(
Range <int?> .Empty,
new Range <int?>(RangeBoundaryFrom <int?> .Empty, RangeBoundaryTo <int?> .Empty));
AreEqual(
Range <int?> .Infinite,
Range.Create(empty, empty));
AreEqual(
Range <double> .Infinite,
Range.Create(double.NegativeInfinity, double.PositiveInfinity));
AreNotEqual(
Range <int?> .Infinite,
Range.Create(empty, empty, key));
AreEqual(
Range.TryCreate(value2, value1),
Range <int?> .Empty);
IsTrue(Range.TryCreate(value2, value1, key).IsEmpty);
IsFalse(Range.TryCreate(value1, value2, key).IsEmpty);
IsTrue(Range.TryCreate(double.NegativeInfinity, double.NegativeInfinity, key).IsEmpty);
}
public static void TestBoundaryRawValueComparison()
{
int?value1 = 1;
int?value2 = 2;
int?empty = null;
var eFrom = RangeBoundaryFrom <int?> .Empty;
var nInf = Range.BoundaryFromInfinity <int?>();
var pInf = Range.BoundaryToInfinity <int?>();
var fromInc1 = Range.BoundaryFrom(value1);
var fromEx1 = Range.BoundaryFromExclusive(value1);
var toInc1 = Range.BoundaryTo(value1);
var toEx1 = Range.BoundaryToExclusive(value1);
var fromInc2 = Range.BoundaryFrom(value2);
var fromEx2 = Range.BoundaryFromExclusive(value2);
var toInc2 = Range.BoundaryTo(value2);
var toEx2 = Range.BoundaryToExclusive(value2);
IsTrue(eFrom < empty);
IsTrue(nInf <= empty);
IsTrue(nInf >= empty);
IsTrue(pInf > empty);
IsTrue(toEx1 > empty);
IsTrue(toInc1 > empty);
IsTrue(fromEx2 > empty);
IsTrue(fromInc2 > empty);
IsTrue(empty < toEx2);
IsTrue(empty < toInc2);
IsTrue(empty < fromEx1);
IsTrue(empty < fromInc1);
IsTrue(nInf < value1);
IsTrue(toEx1 < value1);
IsTrue(fromEx1 > value1);
IsTrue(toInc1 <= value1);
IsTrue(fromInc1 >= value1);
IsTrue(toEx1 < value2);
IsTrue(fromEx1 < value2);
IsTrue(toInc1 < value2);
IsTrue(fromInc1 < value2);
IsTrue(value2 < pInf);
IsTrue(value2 > toEx2);
IsTrue(value2 < fromEx2);
IsTrue(value2 >= toInc2);
IsTrue(value2 <= fromInc2);
IsTrue(value1 < toEx2);
IsTrue(value1 < fromEx2);
IsTrue(value1 < toInc2);
IsTrue(value1 < fromInc2);
}
public static void TestRangeContains()
{
double?empty = null;
double?value1 = 1;
double?value2 = 2;
var emptyFrom = RangeBoundaryFrom <double?> .Empty;
var emptyTo = RangeBoundaryTo <double?> .Empty;
var range = Range.Create(value1, value2);
IsFalse(range.Contains(null));
IsFalse(range.Contains(double.NegativeInfinity));
IsFalse(range.Contains(double.PositiveInfinity));
IsFalse(range.Contains(RangeBoundaryFrom <double?> .Empty));
IsFalse(range.Contains(RangeBoundaryTo <double?> .Empty));
IsFalse(range.Contains(0));
IsTrue(range.Contains(1));
IsTrue(range.Contains(1.5));
IsTrue(range.Contains(2));
IsFalse(range.Contains(3));
range = Range.Create(emptyFrom, emptyTo);
IsFalse(range.Contains(null));
IsFalse(range.Contains(double.NegativeInfinity));
IsFalse(range.Contains(double.PositiveInfinity));
IsTrue(range.Contains(RangeBoundaryFrom <double?> .Empty));
IsTrue(range.Contains(RangeBoundaryTo <double?> .Empty));
IsFalse(range.Contains(0));
range = Range.CreateExclusive(empty, empty);
IsTrue(range.Contains(null));
IsTrue(range.Contains(double.NegativeInfinity));
IsTrue(range.Contains(double.PositiveInfinity));
IsFalse(range.Contains(RangeBoundaryFrom <double?> .Empty));
IsFalse(range.Contains(RangeBoundaryTo <double?> .Empty));
IsTrue(range.Contains(0));
range = Range.CreateExclusive(value1, value2);
IsFalse(range.Contains(1));
IsTrue(range.Contains(1.5));
IsFalse(range.Contains(2));
range = Range.CreateExclusive(value1, value2);
IsFalse(range.Contains(Range.BoundaryFrom <double?>(1)));
IsFalse(range.Contains(Range.BoundaryTo <double?>(2)));
IsTrue(range.Contains(Range.BoundaryFromExclusive <double?>(1)));
IsTrue(range.Contains(Range.BoundaryFromExclusive <double?>(1.5)));
IsFalse(range.Contains(Range.BoundaryFromExclusive <double?>(2)));
IsFalse(range.Contains(Range.BoundaryToExclusive <double?>(1)));
IsTrue(range.Contains(Range.BoundaryToExclusive <double?>(1.5)));
IsTrue(range.Contains(Range.BoundaryToExclusive <double?>(2)));
Throws <ArgumentException>(
() => range.Contains(Range.BoundaryFrom <double?>(double.PositiveInfinity)));
Throws <ArgumentException>(
() => range.Contains(Range.BoundaryTo <double?>(double.NegativeInfinity)));
}
public RangeBoundaryFrom <int> Test01NoValidation()
{
var result = RangeBoundaryFrom <int> .Empty;
for (var i = 0; i < Count; i++)
{
result = Range.BoundaryFrom(i);
}
return(result);
}
public void TestBoundaryFromProperties()
{
int?value1 = 1;
int?value2 = 2;
int?empty = null;
var a = new RangeBoundaryFrom <int?>();
AreEqual(a.Kind, RangeBoundaryFromKind.Empty);
AreEqual(a.GetValueOrDefault(), empty);
Throws <InvalidOperationException>(() => a.Value.ToString());
IsTrue(a.IsEmpty);
IsFalse(a.IsNotEmpty);
IsFalse(a.HasValue);
IsFalse(a.IsNegativeInfinity);
IsFalse(a.IsInclusiveBoundary);
IsFalse(a.IsExclusiveBoundary);
a = Range.BoundaryFromInfinity <int?>();
AreEqual(a.Kind, RangeBoundaryFromKind.Infinite);
AreEqual(a.GetValueOrDefault(), empty);
Throws <InvalidOperationException>(() => a.Value.ToString());
IsFalse(a.IsEmpty);
IsTrue(a.IsNotEmpty);
IsFalse(a.HasValue);
IsTrue(a.IsNegativeInfinity);
IsFalse(a.IsInclusiveBoundary);
IsFalse(a.IsExclusiveBoundary);
a = Range.BoundaryFrom(value1);
AreEqual(a.Kind, RangeBoundaryFromKind.Inclusive);
AreEqual(a.Value, value1);
AreNotEqual(a.Value, value2);
IsFalse(a.IsEmpty);
IsTrue(a.IsNotEmpty);
IsTrue(a.HasValue);
IsFalse(a.IsNegativeInfinity);
IsTrue(a.IsInclusiveBoundary);
IsFalse(a.IsExclusiveBoundary);
a = Range.BoundaryFromExclusive(value1);
AreEqual(a.Kind, RangeBoundaryFromKind.Exclusive);
AreEqual(a.Value, value1);
AreNotEqual(a.Value, value2);
IsFalse(a.IsEmpty);
IsTrue(a.IsNotEmpty);
IsTrue(a.HasValue);
IsFalse(a.IsNegativeInfinity);
IsFalse(a.IsInclusiveBoundary);
IsTrue(a.IsExclusiveBoundary);
}
public static void TestBoundaryKindComparison()
{
int?value1 = 1;
var eFrom = RangeBoundaryFrom <int?> .Empty;
var eTo = RangeBoundaryTo <int?> .Empty;
var nInf = Range.BoundaryFromInfinity <int?>();
var pInf = Range.BoundaryToInfinity <int?>();
var fromInc = Range.BoundaryFrom(value1);
var fromEx = Range.BoundaryFromExclusive(value1);
var toInc = Range.BoundaryTo(value1);
var toEx = Range.BoundaryToExclusive(value1);
AreNotEqual(fromInc, fromEx);
AreNotEqual(fromInc, toInc);
AreNotEqual(toInc, toEx);
AreEqual(fromInc.Value, fromEx.Value);
AreEqual(fromInc.Value, toInc.Value);
AreEqual(toInc.Value, toEx.Value);
// priority:
// '∅' < '-∞' < 'a)' < '[a' == 'a]' < '(a' < '+∞'
AreEqual(eFrom.CompareTo(eTo), 0);
AreEqual(eTo.CompareTo(eFrom), 0);
Less(eFrom, nInf);
Less(nInf, toEx);
Less(toEx, fromInc);
AreEqual(fromInc.CompareTo(toInc), 0);
AreEqual(toInc.CompareTo(fromInc), 0);
Less(toInc, fromEx);
Less(fromEx, pInf);
IsTrue(eTo <= eFrom);
IsTrue(eFrom < nInf);
IsTrue(nInf < toEx);
IsTrue(toEx < fromInc);
IsTrue(toInc <= fromInc && toInc >= fromInc);
IsTrue(fromInc < fromEx);
IsTrue(fromEx < pInf);
IsTrue(pInf >= fromEx);
IsTrue(fromEx >= fromInc);
IsTrue(fromInc >= toInc);
IsTrue(fromInc >= toEx);
IsTrue(toEx >= nInf);
IsTrue(nInf >= eFrom);
IsTrue(eFrom >= eTo);
}
/// <summary>
/// Converts sequence of elements to the composite range using only From boundary.
/// The To boundary value is taken from the next item in sequence (+∞ for the last item in sequence)
/// </summary>
/// <typeparam name="TSource">The type of the values in original collection.</typeparam>
/// <typeparam name="T">The type of the range values.</typeparam>
/// <typeparam name="TKey">The type of the range key</typeparam>
/// <param name="source">Original collection.</param>
/// <param name="fromValueSelector">Callback to obtain a value for the From boundary.</param>
/// <param name="keySelector">Callback to obtain a value for the range key.</param>
/// <returns>A new composite range with keys filled from the original collection.</returns>
public static CompositeRange <T, TKey> ToCompositeRangeFrom <TSource, T, TKey>(
[NotNull] this IEnumerable <TSource> source,
[NotNull, InstantHandle] Func <TSource, T> fromValueSelector,
[NotNull, InstantHandle] Func <TSource, TKey> keySelector)
{
var keyAndFromBoundary = source
.Select(s => (From: Range.BoundaryFrom(fromValueSelector(s)), Key: keySelector(s)))
.OrderBy(s => s.From)
.ToArray();
if (keyAndFromBoundary.Length == 0)
{
return(CompositeRange <T, TKey> .Empty);
}
// logic is following:
// foreach item in sequence
// if same boundary as before - add to pending
// else add all (pending to current) ranges. Store current as pending.
var prevBoundary = RangeBoundaryFrom <T> .Empty;
var prevKeys = new List <TKey>();
var ranges = new List <Range <T, TKey> >();
foreach (var fromWithKey in keyAndFromBoundary)
{
if (prevBoundary != fromWithKey.From)
{
foreach (var prevKey in prevKeys)
{
ranges.Add(Range.Create(prevBoundary, fromWithKey.From.GetComplementation(), prevKey));
}
prevKeys.Clear();
prevBoundary = fromWithKey.From;
}
prevKeys.Add(fromWithKey.Key);
}
foreach (var prevKey in prevKeys)
{
ranges.Add(Range.Create(prevBoundary, RangeBoundaryTo <T> .PositiveInfinity, prevKey));
}
return(ranges.ToCompositeRange());
}
public static void TestRangeTrimFrom()
{
double?empty = null;
double?value1 = 1;
double?value2 = 2;
var emptyFrom = RangeBoundaryFrom <double?> .Empty;
var emptyTo = RangeBoundaryTo <double?> .Empty;
var emptyRange = Range.Create(emptyFrom, emptyTo);
var range = Range.Create(value1, value2);
AreEqual(range.TrimFrom(null), range);
AreEqual(range.TrimFrom(double.NegativeInfinity), range);
Throws <ArgumentException>(() => range.TrimFrom(double.PositiveInfinity));
AreEqual(range.TrimFrom(RangeBoundaryFrom <double?> .Empty), emptyRange);
AreEqual(range.TrimFrom(0), range);
AreEqual(range.TrimFrom(1), range);
AreEqual(range.TrimFrom(1.5), Range.Create(1.5, value2));
AreEqual(range.TrimFrom(2), Range.Create(2, value2));
AreEqual(range.TrimFrom(3), emptyRange);
range = Range.Create(emptyFrom, emptyTo);
AreEqual(range.TrimFrom(null), range);
AreEqual(range.TrimFrom(double.NegativeInfinity), range);
Throws <ArgumentException>(() => range.TrimFrom(double.PositiveInfinity));
AreEqual(range.TrimFrom(RangeBoundaryFrom <double?> .Empty), range);
AreEqual(range.TrimFrom(0), range);
range = Range.CreateExclusive(empty, empty);
AreEqual(range.TrimFrom(null), range);
AreEqual(range.TrimFrom(double.NegativeInfinity), range);
Throws <ArgumentException>(() => range.TrimFrom(double.PositiveInfinity));
AreEqual(range.TrimFrom(RangeBoundaryFrom <double?> .Empty), emptyRange);
AreEqual(range.TrimFrom(0), Range.Create(0, empty));
range = Range.CreateExclusive(value1, value2);
AreEqual(range.TrimFrom(1), range);
AreEqual(range.TrimFrom(1.5), Range.CreateExclusiveTo(1.5, value2));
AreEqual(range.TrimFrom(2), emptyRange);
range = Range.CreateExclusive(value1, value2);
AreEqual(range.TrimFrom(Range.BoundaryFrom <double?>(1)), range);
AreEqual(range.TrimFrom(Range.BoundaryFrom <double?>(1.5)), Range.CreateExclusiveTo(1.5, value2));
AreEqual(range.TrimFrom(Range.BoundaryFrom <double?>(2)), emptyRange);
}
public static void TestBoundaryToString()
{
int?value1 = 1;
AreEqual(RangeBoundaryFrom <int?> .Empty.ToString(), "∅");
AreEqual(RangeBoundaryTo <int?> .Empty.ToString(), "∅");
AreEqual(RangeBoundaryFrom <int?> .NegativeInfinity.ToString(), "(-∞");
AreEqual(RangeBoundaryTo <int?> .PositiveInfinity.ToString(), "+∞)");
AreEqual(Range.BoundaryFrom(value1).ToString(), "[1");
AreEqual(Range.BoundaryFromExclusive(value1).ToString(), "(1");
AreEqual(Range.BoundaryTo(value1).ToString(), "1]");
AreEqual(Range.BoundaryToExclusive(value1).ToString(), "1)");
AreEqual(Range.BoundaryToExclusive(value1).ToString("000"), "001)");
AreEqual(RangeBoundaryTo <int?> .Empty.ToString("000"), "∅");
AreEqual(RangeBoundaryFrom <int?> .NegativeInfinity.ToString("000"), "(-∞");
}
public static void TestKeyedRangeExtendFrom()
{
double?empty = null;
double?value1 = 1;
double?value2 = 2;
var emptyFrom = RangeBoundaryFrom <double?> .Empty;
var emptyTo = RangeBoundaryTo <double?> .Empty;
var range = Range.Create(value1, value2, RangeKey);
AreEqual(range.ExtendFrom(null), Range.Create(empty, value2, RangeKey));
AreEqual(range.ExtendFrom(double.NegativeInfinity), Range.Create(empty, value2, RangeKey));
Throws <ArgumentException>(() => range.ExtendFrom(double.PositiveInfinity));
AreEqual(range.ExtendFrom(RangeBoundaryFrom <double?> .Empty), range);
AreEqual(range.ExtendFrom(0), Range.Create(0, value2, RangeKey));
AreEqual(range.ExtendFrom(1), range);
AreEqual(range.ExtendFrom(1.5), range);
AreEqual(range.ExtendFrom(2), range);
AreEqual(range.ExtendFrom(3), range);
range = Range.Create(emptyFrom, emptyTo, RangeKey);
AreEqual(range.ExtendFrom(null), range);
AreEqual(range.ExtendFrom(double.NegativeInfinity), range);
Throws <ArgumentException>(() => range.ExtendFrom(double.PositiveInfinity));
AreEqual(range.ExtendFrom(RangeBoundaryFrom <double?> .Empty), range);
AreEqual(range.ExtendFrom(0), range);
range = Range.CreateExclusive(empty, empty, RangeKey);
AreEqual(range.ExtendFrom(null), range);
AreEqual(range.ExtendFrom(double.NegativeInfinity), range);
Throws <ArgumentException>(() => range.ExtendFrom(double.PositiveInfinity));
AreEqual(range.ExtendFrom(RangeBoundaryFrom <double?> .Empty), range);
AreEqual(range.ExtendFrom(0), range);
range = Range.CreateExclusive(value1, value2, RangeKey);
AreEqual(range.ExtendFrom(1), Range.CreateExclusiveTo(1, value2, RangeKey));
AreEqual(range.ExtendFrom(1.5), range);
AreEqual(range.ExtendFrom(2), range);
range = Range.CreateExclusive(value1, value2, RangeKey);
AreEqual(range.ExtendFrom(Range.BoundaryFrom <double?>(1)), Range.CreateExclusiveTo(1, value2, RangeKey));
AreEqual(range.ExtendFrom(Range.BoundaryFromExclusive <double?>(1)), range);
AreEqual(range.ExtendFrom(Range.BoundaryFromExclusive <double?>(0)), Range.CreateExclusive(0, value2, RangeKey));
}
public void TestBoundaryFromCreation()
{
int?value1 = 1;
int?value2 = 2;
int?empty = null;
DoesNotThrow(() => new RangeBoundaryFrom <int?>(empty, RangeBoundaryFromKind.Empty));
DoesNotThrow(() => new RangeBoundaryFrom <int?>(empty, RangeBoundaryFromKind.Infinite));
DoesNotThrow(() => new RangeBoundaryFrom <int?>(value1, RangeBoundaryFromKind.Exclusive));
DoesNotThrow(() => new RangeBoundaryFrom <int?>(value2, RangeBoundaryFromKind.Inclusive));
DoesNotThrow(() => new RangeBoundaryFrom <double?>(double.NaN, RangeBoundaryFromKind.Empty));
Throws <ArgumentException>(() => new RangeBoundaryFrom <int?>(value1, RangeBoundaryFromKind.Empty));
Throws <ArgumentException>(() => new RangeBoundaryFrom <int?>(value2, RangeBoundaryFromKind.Infinite));
Throws <ArgumentException>(() => new RangeBoundaryFrom <int?>(empty, RangeBoundaryFromKind.Inclusive));
Throws <ArgumentException>(() => new RangeBoundaryFrom <int?>(empty, RangeBoundaryFromKind.Exclusive));
Throws <ArgumentException>(() => new RangeBoundaryFrom <double?>(double.NaN, RangeBoundaryFromKind.Exclusive));
AreEqual(
RangeBoundaryFrom <int?> .NegativeInfinity,
Range.BoundaryFromInfinity <int?>());
AreEqual(
RangeBoundaryFrom <int?> .NegativeInfinity,
Range.BoundaryFrom(empty));
AreEqual(
RangeBoundaryFrom <int?> .NegativeInfinity,
Range.BoundaryFromExclusive(empty));
AreEqual(
new RangeBoundaryFrom <int?>(value1, RangeBoundaryFromKind.Inclusive),
Range.BoundaryFrom(value1));
AreEqual(
new RangeBoundaryFrom <int?>(value1, RangeBoundaryFromKind.Exclusive),
Range.BoundaryFromExclusive(value1));
AreNotEqual(
new RangeBoundaryFrom <int?>(value1, RangeBoundaryFromKind.Exclusive),
Range.BoundaryFromExclusive(value2));
AreNotEqual(
RangeBoundaryFrom <int> .NegativeInfinity,
Range.BoundaryFrom(0));
AreEqual(
new RangeBoundaryFrom <int?>(value1, RangeBoundaryFromKind.Exclusive),
Range.BoundaryFromExclusive(value1));
}
public static void TestBoundaryToEquality()
{
int?value1 = 1;
int?value2 = 2;
int?empty = null;
var e = new RangeBoundaryTo <int?>();
var inf = Range.BoundaryTo(empty);
var a1 = Range.BoundaryTo(value1);
var a12 = Range.BoundaryTo(value1);
var a2 = Range.BoundaryTo(value2);
var b1 = Range.BoundaryFrom(value1);
AreEqual(e, RangeBoundaryTo <int?> .Empty);
IsTrue(e == RangeBoundaryTo <int?> .Empty);
IsFalse(e != RangeBoundaryTo <int?> .Empty);
AreEqual(inf, RangeBoundaryTo <int?> .PositiveInfinity);
IsTrue(inf == RangeBoundaryTo <int?> .PositiveInfinity);
AreNotEqual(a1, empty);
AreNotEqual(a1, inf);
AreEqual(a1, a12);
IsTrue(a1 == a12);
IsFalse(a1 != a12);
AreNotEqual(a1, a2);
IsFalse(a1 == a2);
IsTrue(a1 != a2);
AreEqual(a1.Value, value1);
AreNotEqual(a1.Value, value2);
AreNotEqual(a1, value1);
AreNotEqual(a1, value2);
AreNotEqual(a1, b1);
AreEqual(b1.Value, value1);
}
public void TestBoundaryFromWithValue()
{
int?value1 = 1;
int?value2 = 2;
var boundary = Range.BoundaryFrom(value1);
var boundary2 = boundary.WithValue(i => i + 1);
AreEqual(boundary.Kind, boundary2.Kind);
AreEqual(boundary2.Value, value2);
boundary = Range.BoundaryFromExclusive(value1);
boundary2 = boundary.WithValue(i => i + 1);
AreEqual(boundary.Kind, boundary2.Kind);
AreEqual(boundary2.Value, value2);
boundary = RangeBoundaryFrom <int?> .Empty;
boundary2 = boundary.WithValue(i => i + 1);
AreEqual(boundary, boundary2);
boundary = RangeBoundaryFrom <int?> .NegativeInfinity;
boundary2 = boundary.WithValue(i => i + 1);
AreEqual(boundary, boundary2);
}
public void TestBoundaryFromToInclusive()
{
int?value1 = 1;
int?empty = null;
var boundary = RangeBoundaryFrom <int?> .Empty;
var boundary2 = boundary.ToInclusive();
IsTrue(boundary2.IsEmpty);
boundary = Range.BoundaryFrom(empty);
boundary2 = boundary.ToInclusive();
IsTrue(boundary2.IsNegativeInfinity);
boundary = Range.BoundaryFrom(value1);
boundary2 = boundary.ToInclusive();
AreEqual(boundary2.Value, boundary.Value);
AreEqual(boundary2.Kind, RangeBoundaryFromKind.Inclusive);
boundary = Range.BoundaryFromExclusive(value1);
boundary2 = boundary.ToInclusive();
AreEqual(boundary2.Value, boundary.Value);
AreEqual(boundary2.Kind, RangeBoundaryFromKind.Inclusive);
}
public Range <T, TKey> MakeInclusive(
[NotNull, InstantHandle] Func <T, T> fromValueSelector,
[NotNull, InstantHandle] Func <T, T> toValueSelector)
{
if (IsEmpty || (!From.IsExclusiveBoundary && !To.IsExclusiveBoundary))
{
return(this);
}
var from = From;
if (from.IsExclusiveBoundary)
{
from = Range.BoundaryFrom(fromValueSelector(from.GetValueOrDefault()));
}
var to = To;
if (to.IsExclusiveBoundary)
{
to = Range.BoundaryTo(toValueSelector(to.GetValueOrDefault()));
}
return(TryCreateRange(from, to));
}
public static Range <T> ExtendFrom <T>(this Range <T> range, T from) => ExtendFrom(range, Range.BoundaryFrom(from));
public static Range <T> TrimFrom <T>(this Range <T> range, T from) => TrimFrom(range, Range.BoundaryFrom(from));
public Range <T, TKey> ExtendFrom(T from) => ExtendFrom(Range.BoundaryFrom(from));
public static bool StartsAfter <T>(this Range <T> range, T value) => RangeBoundaryFrom <T> .IsValid(value) && range.From > Range.BoundaryFrom(value);
/// <summary>Creates instance of <seealso cref="Range{T}"/></summary>
/// <param name="from">Boundary From.</param>
/// <param name="to">Boundary To.</param>
public Range(T from, T to) :
this(Range.BoundaryFrom(from), Range.BoundaryTo(to))
{
}
public static bool Contains <T>(this Range <T> range, T value) =>
RangeBoundaryFrom <T> .IsValid(value)
? Contains(range, Range.BoundaryFrom(value))
: Contains(range, Range.BoundaryTo(value));
/// <summary>Creates instance of <seealso cref="Range{T}"/></summary>
/// <param name="from">Boundary From.</param>
/// <param name="to">Boundary To.</param>
/// <param name="key">The value of the range key.</param>
public Range(T from, T to, TKey key) :
this(Range.BoundaryFrom(from), Range.BoundaryTo(to), key)
{
}
public Range <T, TKey> TrimFrom(T from) => TrimFrom(Range.BoundaryFrom(from));
public static void TestKeyedRangeEndsBefore()
{
double?empty = null;
double?value1 = 1;
double?value2 = 2;
var emptyFrom = RangeBoundaryFrom <double?> .Empty;
var emptyTo = RangeBoundaryTo <double?> .Empty;
var range = Range.Create(value1, value2, RangeKey);
IsTrue(range.EndsBefore(null));
IsFalse(range.EndsBefore(double.NegativeInfinity));
IsTrue(range.EndsBefore(double.PositiveInfinity));
IsFalse(range.EndsBefore(RangeBoundaryFrom <double?> .Empty));
IsFalse(range.EndsBefore(RangeBoundaryTo <double?> .Empty));
IsFalse(range.EndsBefore(0));
IsFalse(range.EndsBefore(1));
IsFalse(range.EndsBefore(1.5));
IsFalse(range.EndsBefore(2));
IsTrue(range.EndsBefore(3));
IsFalse(range.EndsBefore(Range.Create(2, empty, RangeKey2)));
IsTrue(range.EndsBefore(Range.CreateExclusiveFrom(2, empty, RangeKey2)));
IsTrue(range.EndsBefore(Range.Create(3, empty, RangeKey2)));
range = Range.Create(emptyFrom, emptyTo, RangeKey);
IsFalse(range.EndsBefore(null));
IsFalse(range.EndsBefore(double.NegativeInfinity));
IsFalse(range.EndsBefore(double.PositiveInfinity));
IsFalse(range.EndsBefore(RangeBoundaryFrom <double?> .Empty));
IsFalse(range.EndsBefore(RangeBoundaryTo <double?> .Empty));
IsFalse(range.EndsBefore(0));
range = Range.CreateExclusive(empty, empty, RangeKey);
IsFalse(range.EndsBefore(null));
IsFalse(range.EndsBefore(double.NegativeInfinity));
IsFalse(range.EndsBefore(double.PositiveInfinity));
IsFalse(range.EndsBefore(RangeBoundaryFrom <double?> .Empty));
IsFalse(range.EndsBefore(RangeBoundaryTo <double?> .Empty));
IsFalse(range.EndsBefore(0));
range = Range.CreateExclusive(value1, value2, RangeKey);
IsFalse(range.EndsBefore(1));
IsFalse(range.EndsBefore(1.5));
IsTrue(range.EndsBefore(2));
range = Range.CreateExclusive(value1, value2, RangeKey);
IsFalse(range.EndsBefore(Range.BoundaryFrom <double?>(1)));
IsTrue(range.EndsBefore(Range.BoundaryTo <double?>(2)));
IsFalse(range.EndsBefore(Range.BoundaryFromExclusive <double?>(1)));
IsFalse(range.EndsBefore(Range.BoundaryFromExclusive <double?>(1.5)));
IsTrue(range.EndsBefore(Range.BoundaryFromExclusive <double?>(2)));
IsFalse(range.EndsBefore(Range.BoundaryToExclusive <double?>(1)));
IsFalse(range.EndsBefore(Range.BoundaryToExclusive <double?>(1.5)));
IsFalse(range.EndsBefore(Range.BoundaryToExclusive <double?>(2)));
Throws <ArgumentException>(
() => range.EndsBefore(Range.BoundaryFrom <double?>(double.PositiveInfinity)));
Throws <ArgumentException>(
() => range.EndsBefore(Range.BoundaryTo <double?>(double.NegativeInfinity)));
}
/// <summary>Trims the range from the left.</summary> /// <typeparam name="T">The type of the range values.</typeparam> /// <param name="compositeRange">The source range.</param> /// <param name="from">A new value From.</param> /// <returns>A range trimmed with a new From boundary.</returns> public static CompositeRange <T> TrimFrom <T>(this CompositeRange <T> compositeRange, T from) => TrimFrom(compositeRange, Range.BoundaryFrom(from));
public static CompositeRange <T, TKey> ExtendFrom <T, TKey>(this CompositeRange <T, TKey> compositeRange, T from) => ExtendFrom(compositeRange, Range.BoundaryFrom(from));
