public bool Equals(IntDomain2 domain) { if (ReferenceEquals(domain, this)) { return(true); } if (IsSimple() && domain.IsSimple()) { return(m_Interval.Equals(domain.m_Interval)); } if (IsSimple() ^ domain.IsSimple()) { return(false); } bool equal = m_IntervalList.Count == domain.m_IntervalList.Count; if (equal) { for (int idx = 0; idx < m_IntervalList.Count && equal; ++idx) { equal &= m_IntervalList[idx].Equals(domain.m_IntervalList[idx]); } } return(equal); }
public IntDomain2 Square() { if (IsEmpty()) { return(m_Empty); } if ((m_Interval.IsZero()) || (m_Interval.Min == 1 && m_Interval.Max == 1)) { return(this); } IntDomain2 result = new IntDomain2(); result.m_Interval = m_Interval.Square(); if (IsSimple()) { return(result); } result.m_IntervalList = new List <IntInterval>(m_IntervalList.Count); foreach (IntInterval interval in m_IntervalList) { result.m_IntervalList.Add(interval.Square()); } return(result); }
public bool IntersectsWith(IntDomain2 domain) { if (ReferenceEquals(domain, this)) { return(true); } if (domain.IsEmpty()) { return(false); } // 1, 6 if (!m_Interval.IntersectsWith(domain.m_Interval)) { return(false); } if (domain.IsSimple()) { return(IntersectsWith(domain.m_Interval)); } if (IsSimple()) { return(domain.IntersectsWith(m_Interval)); } int index0 = 0; int index1 = 0; bool intersect = false; while (index0 < m_IntervalList.Count && index1 < domain.m_IntervalList.Count && !intersect) { IntInterval ival0 = m_IntervalList[index0]; IntInterval ival1 = domain.m_IntervalList[index1]; if (ival0.Max < ival1.Min) { ++index0; } else if (ival1.Max < ival0.Min) { ++index1; } else { intersect = true; } } return(intersect); }
public IntDomain2 Subtract(IntDomain2 domain) { IntInterval interval = domain.Interval; if (interval.Min == 0 && interval.Max == 0) { return(this); } return(new IntDomain2(m_Interval - interval)); }
public IntDomain2 Multiply(IntDomain2 domain) { IntInterval interval = domain.Interval; if (interval.Min == 1 && interval.Max == 1) { return(this); } return(new IntDomain2(m_Interval * interval)); }
public override bool Equals(object obj) { if (ReferenceEquals(this, obj)) { return(true); } IntDomain2 domain = obj as IntDomain2; if (!ReferenceEquals(domain, null)) { return(Equals(domain)); } return(false); }
public IntDomain2 Sqrt() { if (IsEmpty()) { return(m_Empty); } if (m_Interval.Max < 0) { return(m_Empty); } if ((m_Interval.IsZero()) || (m_Interval.Min == 1 && m_Interval.Max == 1)) { return(this); } IntDomain2 result = new IntDomain2(); result.m_Interval = m_Interval.Sqrt(); if (IsSimple()) { return(result); } result.m_IntervalList = new List <IntInterval>(m_IntervalList.Count); for (int idx = 0; idx < m_IntervalList.Count; ++idx) { IntInterval interval = m_IntervalList[idx]; if (interval.Max >= 0) { result.m_IntervalList.Add(interval.Sqrt()); } } return(result); }
public IntDomain2 Negate() { if (m_Interval.IsBound() && m_Interval.Min == 0) { return(this); } IntDomain2 result = new IntDomain2(); result.m_Interval = -m_Interval; if (IsSimple()) { return(result); } result.m_IntervalList = new List <IntInterval>(m_IntervalList.Count); for (int idx = m_IntervalList.Count; idx > 0; --idx) { result.m_IntervalList.Add(-m_IntervalList[idx - 1]); } return(result); }
public IntDomain2 Divide(IntDomain2 domain) { IntInterval interval = domain.Interval; if (interval.Min == 1 && interval.Max == 1) { return(this); } bool div2 = false; IntInterval intv1 = IntInterval.Divide1(m_Interval, interval, ref div2); if (div2) { IntInterval intv2 = IntInterval.Divide2(m_Interval, interval, div2); return(new IntDomain2(new IntInterval[] { intv1, intv2 })); } else { return(new IntDomain2(intv1)); } }
public IntDomain2 Intersect(IntDomain2 domain) { if (ReferenceEquals(domain, this)) { return(this); } if (domain.IsEmpty()) { return(m_Empty); } if (domain.IsSimple()) { return(Intersect(domain.m_Interval)); } // 1, 6 if (!IntersectsWith(domain)) { return(m_Empty); } // If the target is contained, then the result would be equal to the domain, hence we return the domain. if (IsSimple()) { if (domain.Contains(m_Interval)) { return(this); } if (m_Interval.Contains(domain.m_Interval)) { return(domain); } } // Need to be a bit smart, put our interval in a list, in case it gets chopped up. List <IntInterval> intervalList; if (IsSimple()) { intervalList = new List <IntInterval>(1); intervalList.Add(m_Interval); } else { intervalList = m_IntervalList; } IntDomain2 result = new IntDomain2(); result.m_IntervalList = new List <IntInterval>(intervalList.Count + domain.m_IntervalList.Count); int idx = 0; int domIdx = 0; bool equal = true; while (idx < intervalList.Count || domIdx < domain.m_IntervalList.Count) { // 6 if (idx == intervalList.Count) { domIdx = domain.m_IntervalList.Count; } // 1 else if (domIdx == domain.m_IntervalList.Count) { idx = intervalList.Count; equal = false; } else { IntInterval intv = intervalList[idx]; IntInterval domIntv = domain.m_IntervalList[domIdx]; // 1 : completely before if (domIntv.Max < intv.Min - 1) { ++domIdx; } // 6 : completely after else if (domIntv.Min > intv.Max + 1) { ++idx; equal = false; } // 3 else if (domIntv.Min <= intv.Min && domIntv.Max >= intv.Max) { result.m_IntervalList.Add(intv); ++idx; } // ~4 : divide into two intervals... else if (domIntv.Min > intv.Min && domIntv.Max < intv.Max) { result.m_IntervalList.Add(domIntv); ++domIdx; equal = false; } // 2 else if (domIntv.Min <= intv.Min && domIntv.Max < intv.Max) { result.m_IntervalList.Add(intv.Intersect(domIntv)); ++domIdx; equal = false; } // 5 else if (domIntv.Min > intv.Min && domIntv.Max >= intv.Max) { result.m_IntervalList.Add(intv.Intersect(domIntv)); ++idx; equal = false; } } } if (equal) { return(this); } result.UpdateInterval(); return(result); }
public IntDomain2 Intersect(IntInterval interval) { if (interval.IsEmpty()) { return(m_Empty); } // 1, 6 if (!IntersectsWith(interval)) { return(m_Empty); } // 3 if (m_Interval.Min >= interval.Min && m_Interval.Max <= interval.Max) { return(this); } IntInterval intv = m_Interval.Intersect(interval); IntDomain2 result = new IntDomain2(); result.m_Interval = intv; if (!IsSimple()) { result.m_IntervalList = new List <IntInterval>(m_IntervalList.Count); int idx = 0; // 6 : completely before for ( ; idx < m_IntervalList.Count && m_IntervalList[idx].Max < interval.Min; ++idx) { } ; // 2 if (idx < m_IntervalList.Count && m_IntervalList[idx].Min < interval.Min && m_IntervalList[idx].Max <= interval.Max) { result.m_IntervalList.Add(m_IntervalList[idx].Intersect(interval)); ++idx; } // 4 if (idx < m_IntervalList.Count && m_IntervalList[idx].Min <interval.Min && m_IntervalList[idx].Max> interval.Max) { result.m_IntervalList.Add(m_IntervalList[idx].Intersect(interval)); } // 3 else { for ( ; idx < m_IntervalList.Count && interval.Contains(m_IntervalList[idx]); ++idx) { result.m_IntervalList.Add(m_IntervalList[idx]); } } // 5 if (idx < m_IntervalList.Count && m_IntervalList[idx].Min > interval.Min && m_IntervalList[idx].Max >= interval.Max) { result.m_IntervalList.Add(m_IntervalList[idx].Intersect(interval)); ++idx; } // 1 : complete after can be skipped result.CheckSimple(); } return(result); }
public IntDomain2(IntDomain2 domain) { m_Interval = domain.m_Interval; m_IntervalList = domain.m_IntervalList; }
public IntDomain2 Difference(IntDomain2 domain) { if (ReferenceEquals(domain, this)) { return(m_Empty); } if (domain.IsEmpty()) { return(this); } if (domain.IsSimple()) { return(Difference(domain.m_Interval)); } //1, 6 if (!IntersectsWith(domain.m_Interval)) { return(this); } // Need to be a bit smart, put our interval in a list, in case it gets chopped up. List <IntInterval> intervalList; if (IsSimple()) { intervalList = new List <IntInterval>(1); intervalList.Add(m_Interval); } else { intervalList = m_IntervalList; } IntDomain2 result = new IntDomain2(); result.m_IntervalList = new List <IntInterval>(intervalList.Count + domain.m_IntervalList.Count); int idx = 0; int domIdx = 0; while (idx < intervalList.Count || domIdx < domain.m_IntervalList.Count) { // 6 if (idx == intervalList.Count) { domIdx = domain.m_IntervalList.Count; } // 1 else if (domIdx == domain.m_IntervalList.Count) { idx = intervalList.Count; } else { IntInterval intv = intervalList[idx]; IntInterval domIntv = domain.m_IntervalList[domIdx]; // 1 : completely before if (domIntv.Max < intv.Min - 1) { ++domIdx; } // 6 : completely after else if (domIntv.Min > intv.Max + 1) { result.m_IntervalList.Add(intv); ++idx; } // 3 else if (domIntv.Min < intv.Min && domIntv.Max > intv.Max) { ++idx; } // 4 : divide into two intervals... else if (domIntv.Min > intv.Min && domIntv.Max < intv.Max) { while (domIdx < domain.m_IntervalList.Count && domIntv.Min > intv.Min && domIntv.Max < intv.Max) { result.m_IntervalList.Add(new IntInterval(intv.Min, domIntv.Min - 1)); intv = new IntInterval(domIntv.Max + 1, intv.Max); ++domIdx; if (domIdx < domain.m_IntervalList.Count) { domIntv = domain.m_IntervalList[domIdx]; } } result.m_IntervalList.Add(intv); } // 2 else if (domIntv.Min <= intv.Min && domIntv.Max < intv.Max) { result.m_IntervalList.Add(intv.Difference(domIntv)); ++domIdx; } // 5 else if (domIntv.Min > intv.Min && domIntv.Max >= intv.Max) { result.m_IntervalList.Add(intv.Difference(domIntv)); ++idx; } } } result.UpdateInterval(); return(result); }
public IntDomain2 Difference(IntInterval interval) { if (interval.IsEmpty()) { return(this); } // 1, 6 if (!IntersectsWith(interval)) { return(this); } // 3 : completely remove interval => empty if (interval.Min <= m_Interval.Min && interval.Max >= m_Interval.Max) { return(m_Empty); } // Result domain IntDomain2 result = new IntDomain2(); result.m_Interval = m_Interval.Difference(interval); if (IsSimple()) { // 4 : divide into two intervals... if (interval.Min > m_Interval.Min && interval.Max < m_Interval.Max) { result.m_IntervalList = new List <IntInterval>(2); result.m_IntervalList.Add(new IntInterval(m_Interval.Min, interval.Min - 1)); result.m_IntervalList.Add(new IntInterval(interval.Max + 1, m_Interval.Max)); } } else { result.m_IntervalList = new List <IntInterval>(m_IntervalList.Count + 1); int idx = 0; // 6 for ( ; idx < m_IntervalList.Count && m_IntervalList[idx].Max < interval.Min; ++idx) { result.m_IntervalList.Add(m_IntervalList[idx]); } // 2 if (idx < m_IntervalList.Count && m_IntervalList[idx].Min < interval.Min && m_IntervalList[idx].Max <= interval.Max) { result.m_IntervalList.Add(m_IntervalList[idx].Difference(interval)); ++idx; } // 4 : divide into two intervals... if (idx < m_IntervalList.Count && m_IntervalList[idx].Min <interval.Min && m_IntervalList[idx].Max> interval.Max) { result.m_IntervalList.Add(new IntInterval(m_Interval.Min, interval.Min - 1)); result.m_IntervalList.Add(new IntInterval(interval.Max + 1, m_Interval.Max)); } // 3 else { for ( ; idx < m_IntervalList.Count && interval.Contains(m_IntervalList[idx]); ++idx) { } } // 5 if (idx < m_IntervalList.Count && m_IntervalList[idx].Min >= interval.Min && m_IntervalList[idx].Max > interval.Max) { result.m_IntervalList.Add(m_IntervalList[idx].Difference(interval)); ++idx; } // 1 for ( ; idx < m_IntervalList.Count; ++idx) { result.m_IntervalList.Add(m_IntervalList[idx]); } result.CheckSimple(); } return(result); }
public IntDomain2 Union(IntDomain2 domain) { if (ReferenceEquals(domain, this)) { return(this); } if (domain.IsEmpty()) { return(this); } if (IsEmpty()) { return(domain); } if (domain.IsSimple()) { return(Union(domain.m_Interval)); } if (IsSimple()) { if (m_Interval.Contains(domain.m_Interval)) { return(this); } return(domain.Union(m_Interval)); } else { IntDomain2 result = new IntDomain2(); result.m_Interval = m_Interval.Union(domain.m_Interval); result.m_IntervalList = new List <IntInterval>(m_IntervalList.Count + domain.m_IntervalList.Count); // 1 : completely before if (domain.m_Interval.Max < m_Interval.Min - 1) { result.m_IntervalList.AddRange(domain.m_IntervalList); result.m_IntervalList.AddRange(m_IntervalList); } // 6 : completely after else if (domain.m_Interval.Min > m_Interval.Max + 1) { result.m_IntervalList.AddRange(m_IntervalList); result.m_IntervalList.AddRange(domain.m_IntervalList); } else { int idx = 0; int domIdx = 0; bool equal = true; while (idx < m_IntervalList.Count || domIdx < domain.m_IntervalList.Count) { // 6 : if (idx == m_IntervalList.Count) { equal = false; for ( ; domIdx < domain.m_IntervalList.Count; ++domIdx) { result.m_IntervalList.Add(domain.m_IntervalList[domIdx]); } } // 1 : remaining intervals after else if (domIdx == domain.m_IntervalList.Count) { for ( ; idx < m_IntervalList.Count; ++idx) { result.m_IntervalList.Add(m_IntervalList[idx]); } } else { IntInterval intv = m_IntervalList[idx]; IntInterval domIntv = domain.m_IntervalList[domIdx]; // 1 : completely before if (domIntv.Max < intv.Min - 1) { equal = false; result.m_IntervalList.Add(domIntv); ++domIdx; } // 6 : completely after else if (domIntv.Min > intv.Max + 1) { result.m_IntervalList.Add(intv); ++idx; } // 3 else if (domIntv.Min < intv.Min && domIntv.Max > intv.Max) { equal = false; ++idx; } // 4 else if (domIntv.Min >= intv.Min && domIntv.Max <= intv.Max) { ++domIdx; } // 2, 5 else { equal = false; IntInterval intvTmp = intv.Union(domIntv); ++idx; // contains... for ( ; idx < m_IntervalList.Count && intvTmp.Contains(m_IntervalList[idx]); ++idx) { } ; // adjacent | intersect... while (idx < m_IntervalList.Count && IntersectsWithOrIsAdjacent(m_IntervalList[idx], intvTmp)) { intvTmp = intvTmp.Union(m_IntervalList[idx]); ++idx; } result.m_IntervalList.Add(intvTmp); ++domIdx; } } } if (equal) { return(this); } result.CheckSimple(); } return(result); } }
public IntDomain2 Union(IntInterval interval) { if (interval.IsEmpty()) { return(this); } if (IsEmpty()) { return(new IntDomain2(interval)); } // ~4 if (Contains(interval)) { return(this); } // 3 if (interval.Contains(m_Interval)) { return(new IntDomain2(interval)); } if (IsSimple()) { // 1 if (interval.Max < m_Interval.Min - 1) { return(new IntDomain2(interval, m_Interval)); } // 6 if (interval.Min > m_Interval.Max + 1) { return(new IntDomain2(m_Interval, interval)); } // 2, 5 return(new IntDomain2(m_Interval.Union(interval))); } else { IntDomain2 result = new IntDomain2(); result.m_Interval = m_Interval.Union(interval); result.m_IntervalList = new List <IntInterval>(m_IntervalList.Count + 1); // 1 if (interval.Max < m_Interval.Min - 1) { result.m_IntervalList.Add(interval); result.m_IntervalList.AddRange(m_IntervalList); } // 6 else if (interval.Min > m_Interval.Max + 1) { result.m_IntervalList.AddRange(m_IntervalList); result.m_IntervalList.Add(interval); } else { // 6 int idx = 0; for ( ; idx < m_IntervalList.Count && m_IntervalList[idx].Max < interval.Min - 1; ++idx) { result.m_IntervalList.Add(m_IntervalList[idx]); } if (idx < m_IntervalList.Count) { IntInterval intv = interval; // adjacent | intersect if (idx < m_IntervalList.Count && IntersectsWithOrIsAdjacent(m_IntervalList[idx], intv)) { intv = intv.Union(m_IntervalList[idx]); ++idx; } // 3 for ( ; idx < m_IntervalList.Count && intv.Contains(m_IntervalList[idx]); ++idx) { } // adjacent | intersect if (idx < m_IntervalList.Count && IntersectsWithOrIsAdjacent(m_IntervalList[idx], intv)) { intv = intv.Union(m_IntervalList[idx]); ++idx; } result.m_IntervalList.Add(intv); // 1 for ( ; idx < m_IntervalList.Count; ++idx) { result.m_IntervalList.Add(m_IntervalList[idx]); } } else { // 6 result.m_IntervalList.Add(interval); } } result.CheckSimple(); return(result); } }
public SimpleIntervalEnumerator(IntDomain2 domain) { m_MoveNext = true; m_Domain = domain; }