source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/Common/Range.cs @ 12503

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Research.DynamicDataDisplay.Common.Auxiliary;
using System.Diagnostics;
using System.ComponentModel;
using Microsoft.Research.DynamicDataDisplay.Common;

namespace Microsoft.Research.DynamicDataDisplay.Charts
{
  /// <summary>
  /// An ordered pair of values, representing a segment.
  /// </summary>
  /// <typeparam name="T">Type of each of two values of range.</typeparam>
  [Serializable]
  [DebuggerDisplay(@"{Min} — {Max}")]
  [TypeConverter(typeof(RangeConverter))]
  public struct Range<T> : IEquatable<Range<T>>
  {
    /// <summary>
    /// Initializes a new instance of the <see cref="Range&lt;T&gt;"/> struct.
    /// </summary>
    /// <param name="min">The minimal value of segment.</param>
    /// <param name="max">The maximal value of segment.</param>
    public Range(T min, T max)
    {
      this.min = min;
      this.max = max;

#if DEBUG
      if (min is IComparable)
      {
        IComparable c1 = (IComparable)min;
        IComparable c2 = (IComparable)max;

        DebugVerify.Is(c1.CompareTo(c2) <= 0);
      }
#endif
    }

    private readonly T min;
    /// <summary>
    /// Gets the minimal value of segment.
    /// </summary>
    /// <value>The min.</value>
    public T Min
    {
      get { return min; }
    }

    private readonly T max;
    /// <summary>
    /// Gets the maximal value of segment.
    /// </summary>
    /// <value>The max.</value>
    public T Max
    {
      get { return max; }
    }

    static float floatEps = (float)1e-10;
    static double doubleEps = 1e-10;


    public static bool operator ==(Range<T> first, Range<T> second)
    {
      return (first.min.Equals(second.min) && first.max.Equals(second.max) ||
        first.IsEmpty && second.IsEmpty);
    }

    public static bool operator !=(Range<T> first, Range<T> second)
    {
      return !(first == second);
    }

    public static bool operator <(Range<T> first, Range<T> second)
    {
      IComparable<T> firstMin = first.min as IComparable<T>;

      if (firstMin == null)
        throw new InvalidOperationException("Cannot compare ranges which are not IComparable.");

      IComparable<T> firstMax = first.max as IComparable<T>;

      return firstMin.CompareTo(second.Min) > 0 && firstMax.CompareTo(second.Max) < 0;
    }

    public static bool operator >(Range<T> first, Range<T> second)
    {
      IComparable<T> firstMin = first.min as IComparable<T>;

      if (firstMin == null)
        throw new InvalidOperationException("Cannot compare ranges which are not IComparable.");

      IComparable<T> firstMax = first.max as IComparable<T>;

      return firstMin.CompareTo(second.min) < 0 && firstMax.CompareTo(second.max) > 0;
    }

    public static bool EqualEps(Range<double> first, Range<double> second, double eps)
    {
      double delta = Math.Min(first.GetLength(), second.GetLength());
      return Math.Abs(first.Min - second.Min) < eps * delta &&
        Math.Abs(first.Max - second.Max) < eps * delta;
    }

    /// <summary>
    /// Indicates whether this instance and a specified object are equal.
    /// </summary>
    /// <param name="obj">Another object to compare to.</param>
    /// <returns>
    /// true if <paramref name="obj"/> and this instance are the same type and represent the same value; otherwise, false.
    /// </returns>
    public override bool Equals(object obj)
    {
      if (obj is Range<T>)
      {
        Range<T> other = (Range<T>)obj;
        return (min.Equals(other.min) && max.Equals(other.max) || IsEmpty && other.IsEmpty);
      }
      else
        return false;
    }

    /// <summary>
    /// Returns the hash code for this instance.
    /// </summary>
    /// <returns>
    /// A 32-bit signed integer that is the hash code for this instance.
    /// </returns>
    public override int GetHashCode()
    {
      return min.GetHashCode() ^ max.GetHashCode();
    }

    /// <summary>
    /// Returns the fully qualified type name of this instance.
    /// </summary>
    /// <returns>
    /// A <see cref="T:System.String"/> containing a fully qualified type name.
    /// </returns>
    public override string ToString()
    {
      return String.Format("{0} — {1}", min, max);
    }

    /// <summary>
    /// Gets a value indicating whether this range is empty.
    /// </summary>
    /// <value><c>true</c> if this instance is empty; otherwise, <c>false</c>.</value>
    public bool IsEmpty
    {
      get
      {
        if (typeof(T) is IComparable)
          return ((IComparable)min).CompareTo(max) >= 0;
        else
          return min.Equals(max);
      }
    }

    /// <summary>
    /// Indicates whether the current object is equal to another object of the same type.
    /// </summary>
    /// <param name="other">An object to compare with this object.</param>
    /// <returns>
    /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
    /// </returns>
    public bool Equals(Range<T> other)
    {
      return this == other;
    }
  }
}