public FltInterval Intersect(FltInterval interval)
{
if (interval.IsEmpty())
{
return(m_Empty);
}
if (IsEmpty())
{
return(this);
}
// 3
if (interval.m_Min <= m_Min && interval.m_Max >= m_Max)
{
return(this);
}
// 1, 6 : completely before or after
if ((interval.m_Max < m_Min) || (interval.m_Min > m_Max))
{
return(m_Empty);
}
// 2, 4, 5
double min = Math.Max(m_Min, interval.m_Min);
double max = Math.Min(m_Max, interval.m_Max);
return(new FltInterval(min, max));
}
public FltInterval Union(FltInterval interval)
{
if (interval.IsEmpty())
{
return(this);
}
if (IsEmpty())
{
return(interval);
}
if (interval.Contains(this))
{
return(interval);
}
if (Contains(interval))
{
return(this);
}
double min = Math.Min(m_Min, interval.m_Min);
double max = Math.Max(m_Max, interval.m_Max);
return(new FltInterval(min, max));
}
static FltInterval DivideZeroPart1(FltInterval lhs, FltInterval rhs, ref bool b)
{
if (lhs.IsZero())
{
b = false;
return(lhs);
}
double lhsMin = lhs.Min;
double lhsMax = lhs.Max;
double rhsMin = rhs.Min;
double rhsMax = rhs.Max;
if (lhsMax < 0)
{
b = true;
return(new FltInterval(double.NegativeInfinity, lhsMax / rhsMax));
}
else if (lhsMin < 0)
{
b = false;
return(Whole);
}
else
{
b = true;
return(new FltInterval(double.NegativeInfinity, lhsMin / rhsMin));
}
}
public FltInterval Subtract(FltInterval interval)
{
if (IsEmpty() || interval.IsEmpty())
{
return(m_Empty);
}
return(new FltInterval(m_Min - interval.Max, m_Max - interval.Min));
}
public FltInterval Add(FltInterval interval)
{
if (IsEmpty() || interval.IsEmpty())
{
return(m_Empty);
}
return(new FltInterval(m_Min + interval.Min, m_Max + interval.Max));
}
public static FltInterval Divide2(FltInterval lhs, FltInterval rhs, bool b)
{
if (!b)
{
return(m_Empty);
}
return(DivideZeroPart2(lhs, rhs));
}
public bool IntersectsWith(FltInterval interval)
{
if (IsEmpty() || interval.IsEmpty())
{
return(false);
}
return((interval.m_Min <= m_Max) &&
(interval.m_Max >= m_Min));
}
public bool Contains(FltInterval interval)
{
if (IsEmpty() || interval.IsEmpty())
{
return(false);
}
return((interval.m_Min >= m_Min) &&
(interval.m_Max <= m_Max));
}
static bool InZero(FltInterval interval)
{
if (interval.IsEmpty())
{
return(false);
}
return((!(interval.Min > 0)) &&
(!(interval.Max < 0)));
}
static FltInterval DivideZeroPart2(FltInterval lhs, FltInterval rhs)
{
if (lhs.Max < 0)
{
return(new FltInterval(lhs.Max / rhs.Min, double.PositiveInfinity));
}
else
{
return(new FltInterval(lhs.Min / rhs.Max, double.PositiveInfinity));
}
}
static FltInterval DivideZero(FltInterval lhs)
{
if (lhs.IsZero())
{
return(lhs);
}
else
{
return(FltInterval.Whole);
}
}
public FltInterval Difference(FltInterval interval)
{
if (interval.IsEmpty())
{
return(this);
}
if (IsEmpty())
{
return(this);
}
// 4 : cannot divide into two intervals...
if ((interval.m_Min > m_Min) && (interval.m_Max < m_Max))
{
return(this);
}
// 1, 6 : completely before or after
if ((interval.m_Max < m_Min) || (interval.m_Min > m_Max))
{
return(this);
}
// 3 : completely remove interval => empty
if (interval.Contains(this))
{
return(m_Empty);
}
// 2 : left overlap
if (IntersectsWith(interval) &&
(interval.m_Max < m_Max))
{
double min = Epsilon.Next(interval.m_Max);
double max = m_Max;
return(new FltInterval(min, max));
}
// 5 : right overlap
if (IntersectsWith(interval) &&
(interval.m_Min > m_Min))
{
double min = m_Min;
double max = Epsilon.Prev(interval.m_Min);
return(new FltInterval(min, max));
}
return(m_Empty);
}
public bool Equals(FltInterval interval)
{
if (ReferenceEquals(interval, null))
{
return(false);
}
if (ReferenceEquals(interval, this))
{
return(true);
}
return((m_Min == interval.m_Min) &&
(m_Max == interval.m_Max));
}
static FltInterval DivideNonZero(FltInterval lhs, FltInterval rhs)
{
double lhsMin = lhs.Min;
double lhsMax = lhs.Max;
double rhsMin = rhs.Min;
double rhsMax = rhs.Max;
if (lhsMax < 0)
{
if (rhsMax < 0)
{
return(new FltInterval(lhsMax / rhsMin, lhsMin / rhsMax));
}
else
{
return(new FltInterval(lhsMin / rhsMin, lhsMax / rhsMax));
}
}
else if (lhsMin < 0)
{
if (rhsMax < 0)
{
return(new FltInterval(lhsMax / rhsMax, lhsMin / rhsMax));
}
else
{
return(new FltInterval(lhsMin / rhsMin, lhsMax / rhsMin));
}
}
else
{
if (rhsMax < 0)
{
return(new FltInterval(lhsMax / rhsMax, lhsMin / rhsMin));
}
else
{
return(new FltInterval(lhsMin / rhsMax, lhsMax / rhsMin));
}
}
}
public static FltInterval Divide1(FltInterval lhs, FltInterval rhs, ref bool b)
{
b = false;
if (lhs.IsEmpty() || rhs.IsEmpty())
{
return(m_Empty);
}
if (InZero(rhs))
{
if (rhs.Min != 0)
{
if (rhs.Max != 0)
{
return(DivideZeroPart1(lhs, rhs, ref b));
}
else
{
return(DivideNegative(lhs, rhs.Min));
}
}
else
{
if (rhs.Max != 0)
{
return(DividePositive(lhs, rhs.Max));
}
else
{
return(m_Empty);
}
}
}
else
{
return(DivideNonZero(lhs, rhs));
}
}
static FltInterval DivideNegative(FltInterval lhs, double rhsMin)
{
if (lhs.IsZero())
{
return(lhs);
}
double lhsMin = lhs.Min;
double lhsMax = lhs.Max;
if (lhsMax < 0)
{
return(new FltInterval(lhsMax / rhsMin, double.PositiveInfinity));
}
else if (lhsMin < 0)
{
return(new FltInterval(double.NegativeInfinity, double.PositiveInfinity));
}
else
{
return(new FltInterval(double.NegativeInfinity, lhsMin / rhsMin));
}
}
public FltInterval Divide(FltInterval interval)
{
if (IsEmpty() || interval.IsEmpty())
{
return(m_Empty);
}
if (InZero(interval))
{
if (interval.Min != 0)
{
if (interval.Max != 0)
{
return(DivideZero(this));
}
else
{
return(DivideNegative(this, interval.Min));
}
}
else
{
if (interval.Max != 0)
{
return(DividePositive(this, interval.Max));
}
else
{
return(m_Empty);
}
}
}
else
{
return(DivideNonZero(this, interval));
}
}
public FltInterval Multiply(FltInterval interval)
{
if (IsEmpty() || interval.IsEmpty())
{
return(m_Empty);
}
double intvMin = interval.Min;
double intvMax = interval.Max;
if (m_Min < 0)
{
if (m_Max > 0)
{
if (intvMin < 0)
{
if (intvMax > 0) // M * M
{
return(new FltInterval(Math.Min(m_Min * intvMax, m_Max * intvMin),
Math.Max(m_Min * intvMin, m_Max * intvMax)));
}
else // M * N
{
return(new FltInterval(m_Max * intvMin, m_Min * intvMin));
}
}
else
{
if (intvMax > 0) // M * P
{
return(new FltInterval(m_Min * intvMax, m_Max * intvMax));
}
else // M * Z
{
return(m_Zero);
}
}
}
else
{
if (intvMin < 0)
{
if (intvMax > 0) // N * M
{
return(new FltInterval(m_Min * intvMax, m_Min * intvMin));
}
else // N * N
{
return(new FltInterval(m_Max * intvMax, m_Min * intvMin));
}
}
else
{
if (intvMax > 0) // N * P
{
return(new FltInterval(m_Min * intvMax, m_Max * intvMin));
}
else // N * Z
{
return(m_Zero);
}
}
}
}
else
{
if (m_Max > 0)
{
if (intvMin < 0)
{
if (intvMax > 0) // P * M
{
return(new FltInterval(m_Max * intvMin, m_Max * intvMax));
}
else // P * N
{
return(new FltInterval(m_Max * intvMin, m_Min * intvMax));
}
}
else
{
if (intvMax > 0) // P * P
{
return(new FltInterval(m_Min * intvMin, m_Max * intvMax));
}
else // P * Z
{
return(m_Zero);
}
}
}
else // Z * ?
{
return(m_Zero);
}
}
}
public FltInterval(FltInterval interval) :
this(interval.Min, interval.Max)
{
}
