public IntInterval Intersect(IntInterval interval)
{
if (interval.IsEmpty())
{
return(m_Empty);
}
if (IsEmpty())
{
return(this);
}
// 3
if (interval.Min <= m_Min && interval.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
int min = Math.Max(m_Min, interval.m_Min);
int max = Math.Min(m_Max, interval.m_Max);
return(new IntInterval(min, max));
}
static IntInterval DivideZeroPart1(IntInterval lhs, IntInterval rhs, ref bool b)
{
if (lhs.IsZero())
{
b = false;
return(lhs);
}
int lhsMin = lhs.Min;
int lhsMax = lhs.Max;
int rhsMin = rhs.Min;
int rhsMax = rhs.Max;
if (lhsMax < 0)
{
b = true;
return(new IntInterval(Integer.neg_inf, lhsMax / rhsMax));
}
else if (lhsMin < 0)
{
b = false;
return(Whole);
}
else
{
b = true;
return(new IntInterval(Integer.neg_inf, lhsMin / rhsMin));
}
}
public static IntInterval Divide2(IntInterval lhs, IntInterval rhs, bool b)
{
if (!b)
{
return(m_Empty);
}
return(DivideZeroPart2(lhs, rhs));
}
public IntInterval Subtract(IntInterval interval)
{
if (IsEmpty() || interval.IsEmpty())
{
return(m_Empty);
}
return(new IntInterval(m_Min - interval.Max, m_Max - interval.Min));
}
public IntInterval Add(IntInterval interval)
{
if (IsEmpty() || interval.IsEmpty())
{
return(m_Empty);
}
return(new IntInterval(m_Min + interval.Min, m_Max + interval.Max));
}
public bool Contains(IntInterval interval)
{
if (IsEmpty() || interval.IsEmpty())
{
return(false);
}
return((interval.m_Min >= m_Min) &&
(interval.m_Max <= m_Max));
}
public bool IntersectsWith(IntInterval interval)
{
if (IsEmpty() || interval.IsEmpty())
{
return(false);
}
return((interval.m_Min <= m_Max) &&
(interval.m_Max >= m_Min));
}
static bool InZero(IntInterval interval)
{
if (interval.IsEmpty())
{
return(false);
}
return((!(interval.Min > 0)) &&
(!(interval.Max < 0)));
}
static IntInterval DivideZero(IntInterval lhs)
{
if (lhs.IsZero())
{
return(lhs);
}
else
{
return(IntInterval.Whole);
}
}
static IntInterval DivideZeroPart2(IntInterval lhs, IntInterval rhs)
{
if (lhs.Max < 0)
{
return(new IntInterval(lhs.Max / rhs.Min, Integer.pos_inf));
}
else
{
return(new IntInterval(lhs.Min / rhs.Max, Integer.pos_inf));
}
}
public IntInterval Difference(IntInterval 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.m_Min <= m_Min && interval.m_Max >= m_Max)
{
return(m_Empty);
}
// 2 : left overlap
if (interval.m_Min <= m_Min &&
interval.m_Max < m_Max)
{
int min = interval.m_Max + 1;
int max = m_Max;
return(new IntInterval(min, max));
}
// 5 : right overlap
if (interval.m_Min > m_Min &&
interval.m_Max >= m_Max)
{
int min = m_Min;
int max = interval.m_Min - 1;
return(new IntInterval(min, max));
}
return(m_Empty);
}
public bool Equals(IntInterval interval)
{
if (ReferenceEquals(interval, null))
{
return(false);
}
if (ReferenceEquals(interval, this))
{
return(true);
}
return(m_Min == interval.m_Min &&
m_Max == interval.m_Max);
}
public IntInterval Multiply(IntInterval interval)
{
if (IsEmpty() || interval.IsEmpty())
{
return(m_Empty);
}
int min0 = interval.Min;
int max0 = interval.Max;
int min0min = min0 * m_Min;
int min0max = min0 * m_Max;
int max0min = max0 * m_Min;
int max0max = max0 * m_Max;
int min = Math.Min(Math.Min(min0min, min0max), Math.Min(max0min, max0max));
int max = Math.Max(Math.Max(min0min, min0max), Math.Max(max0min, max0max));
return(new IntInterval(min, max));
}
static IntInterval DivideNonZero(IntInterval lhs, IntInterval rhs)
{
int lhsMin = lhs.Min;
int lhsMax = lhs.Max;
int rhsMin = rhs.Min;
int rhsMax = rhs.Max;
if (lhsMax < 0)
{
if (rhsMax < 0)
{
return(new IntInterval(lhsMax / rhsMin, lhsMin / rhsMax));
}
else
{
return(new IntInterval(lhsMin / rhsMin, lhsMax / rhsMax));
}
}
else if (lhsMin < 0)
{
if (rhsMax < 0)
{
return(new IntInterval(lhsMax / rhsMax, lhsMin / rhsMax));
}
else
{
return(new IntInterval(lhsMin / rhsMin, lhsMax / rhsMin));
}
}
else
{
if (rhsMax < 0)
{
return(new IntInterval(lhsMax / rhsMax, lhsMin / rhsMin));
}
else
{
return(new IntInterval(lhsMin / rhsMax, lhsMax / rhsMin));
}
}
}
public IntInterval Union(IntInterval interval)
{
if (interval.IsEmpty())
{
return(this);
}
if (IsEmpty())
{
return(interval);
}
if (interval.m_Min >= m_Min && interval.m_Max <= m_Max)
{
return(this);
}
int min = Math.Min(m_Min, interval.m_Min);
int max = Math.Max(m_Max, interval.m_Max);
return(new IntInterval(min, max));
}
public static IntInterval Divide1(IntInterval lhs, IntInterval 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 IntInterval DivideNegative(IntInterval lhs, int rhsMin)
{
if (lhs.IsZero())
{
return(lhs);
}
int lhsMin = lhs.Min;
int lhsMax = lhs.Max;
if (lhsMax < 0)
{
return(new IntInterval(lhsMax / rhsMin, Integer.pos_inf));
}
else if (lhsMin < 0)
{
return(new IntInterval(Integer.neg_inf, Integer.pos_inf));
}
else
{
return(new IntInterval(Integer.neg_inf, lhsMin / rhsMin));
}
}
public IntInterval Divide(IntInterval 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 IntInterval(IntInterval interval) :
this(interval.Min, interval.Max)
{
}
public IntInterval Multiply2(IntInterval interval)
{
if (IsEmpty() || interval.IsEmpty())
{
return(m_Empty);
}
int intvMin = interval.Min;
int intvMax = interval.Max;
if (m_Min < 0)
{
if (m_Max > 0)
{
if (intvMin < 0)
{
if (intvMax > 0) // M * M
{
return(new IntInterval(Math.Min(m_Min * intvMax, m_Max * intvMin),
Math.Max(m_Min * intvMin, m_Max * intvMax)));
}
else // M * N
{
return(new IntInterval(m_Max * intvMin, m_Min * intvMin));
}
}
else
{
if (intvMax > 0) // M * P
{
return(new IntInterval(m_Min * intvMax, m_Max * intvMax));
}
else // M * Z
{
return(new IntInterval(0, 0));
}
}
}
else
{
if (intvMin < 0)
{
if (intvMax > 0) // N * M
{
return(new IntInterval(m_Min * intvMax, m_Min * intvMin));
}
else // N * N
{
return(new IntInterval(m_Max * intvMax, m_Min * intvMin));
}
}
else
{
if (intvMax > 0) // N * P
{
return(new IntInterval(m_Min * intvMax, m_Max * intvMin));
}
else // N * Z
{
return(new IntInterval(0, 0));
}
}
}
}
else
{
if (m_Max > 0)
{
if (intvMin < 0)
{
if (intvMax > 0) // P * M
{
return(new IntInterval(m_Max * intvMin, m_Max * intvMax));
}
else // P * N
{
return(new IntInterval(m_Max * intvMin, m_Min * intvMax));
}
}
else
{
if (intvMax > 0) // P * P
{
return(new IntInterval(m_Min * intvMin, m_Max * intvMax));
}
else // P * Z
{
return(new IntInterval(0, 0));
}
}
}
else // Z * ?
{
return(new IntInterval(0, 0));
}
}
}
