public static Interval <V> ClosedStartClosedEnd <V>(V start, V end) where V : IComparable <V>
{
ValidatePointValueNotNull <V>(start);
ValidatePointValueNotNull <V>(end);
ValidateStartBeforeEnd(start, end);
return(new Interval <V>(IntervalPoint <V> .Closed(start), IntervalPoint <V> .Closed(end)));
}
private bool InfinityLessThanComparisons(IntervalPoint <T> other)
{
if (!this.IsInfinity() && !other.IsInfinity())
{
throw new ArgumentOutOfRangeException("At least one value must be infinity");
}
return(!(this.IsPositiveInfinity() || other.IsNegativeInfinity()));
}
protected bool GreaterOrEqualTo(IntervalPoint <T> other)
{
if (this.IsInfinity() || other.IsInfinity())
{
return(InfinityGreaterThanComparisons(other));
}
return(this.Point.CompareTo(other.Point) > 0 || (!this.IsOpen && !other.IsOpen && this.Point.CompareTo(other.Point) == 0));
}
protected bool GreaterThan(IntervalPoint <T> other)
{
if (this.IsInfinity() || other.IsInfinity())
{
return(InfinityGreaterThanComparisons(other));
}
return(this.Point.CompareTo(other.Point) > 0);
}
public bool Contains(T value)
{
if (this.IsEmpty())
{
return(false);
}
var other = IntervalPoint <T> .Closed(value);
return(other >= Start && other <= End);
}
public int CompareClosedValueTo(IntervalPoint <T> other)
{
if (this.IsNegativeInfinity())
{
if (other.IsNegativeInfinity())
{
return(0);
}
else
{
return(-1);
}
}
else if (this.IsPositiveInfinity())
{
if (other.IsPositiveInfinity())
{
return(0);
}
else
{
return(1);
}
}
else if (other.IsNegativeInfinity())
{
if (this.IsNegativeInfinity())
{
return(0);
}
else
{
return(1);
}
}
else if (other.IsPositiveInfinity())
{
if (this.IsPositiveInfinity())
{
return(0);
}
else
{
return(-1);
}
}
return(this.Point.CompareTo(other.Point));
}
public static Interval <V> OpenBetween <V>(Maybe <V> start, Maybe <V> end) where V : IComparable <V>
{
var startIntervalPoint = IntervalPoint <V> .PositiveInfinity <V>();
var endIntervalPoint = IntervalPoint <V> .NegativeInfinity <V>();
if (start.HasValue)
{
ValidatePointValueNotNull <V>(start.Value);
startIntervalPoint = IntervalPoint <V> .Open(start.Value);
}
if (end.HasValue)
{
ValidatePointValueNotNull <V>(end.Value);
endIntervalPoint = IntervalPoint <V> .Open(end.Value);
}
if (start.HasValue && end.HasValue)
{
ValidateStartBeforeEnd(start.Value, end.Value);
}
return(new Interval <V>(startIntervalPoint, endIntervalPoint));
}
private bool Includes(IntervalPoint <T> point)
{
if (this.IsEmpty())
{
return(false);
}
// no infinits
var compStart = this.Start.CompareClosedValueTo((point));
var compEnd = this.End.CompareClosedValueTo((point));
if (compStart == 0)
{
return(!this.Start.IsOpen && !point.IsOpen);
}
if (compEnd == 0)
{
return(!this.End.IsOpen && !point.IsOpen);
}
return(compStart < 0 && compEnd > 0);
}
/// <summary>
/// Creates a degenerated interval. A degenerated interval is an interval of one single value. It is the interval representation of a point.
/// </summary>
/// <typeparam name="V"></typeparam>
/// <param name="value"></param>
/// <returns></returns>
public static Interval <V> Degenerated <V>(V value) where V : IComparable <V>
{
ValidatePointValueNotNull <V>(value);
return(new Interval <V>(IntervalPoint <V> .Closed <V>(value), IntervalPoint <V> .Closed <V>(value)));
}
protected Interval(IntervalPoint <T> start, IntervalPoint <T> end)
{
Start = start;
End = end;
}
public static Interval <V> InfinityStartInfinityEnd <V>() where V : IComparable <V>
{
return(new Interval <V>(IntervalPoint <V> .NegativeInfinity <V>(), IntervalPoint <V> .PositiveInfinity <V>()));
}
public static Interval <V> InfinityStartClosedEnd <V>(V end) where V : IComparable <V>
{
ValidatePointValueNotNull <V>(end);
return(new Interval <V>(IntervalPoint <V> .NegativeInfinity <V>(), IntervalPoint <V> .Closed(end)));
}
public static Interval <V> ClosedStartInfinityEnd <V>(V start) where V : IComparable <V>
{
ValidatePointValueNotNull <V>(start);
return(new Interval <V>(IntervalPoint <V> .Closed(start), IntervalPoint <V> .PositiveInfinity <V>()));
}