Context Navigation

← Previous Changeset
Next Changeset →

Changeset 10200

Timestamp:

12/06/13 20:45:07 (10 years ago)

Author:

ascheibe

Message:

#1886

moved lrs code into analyzer project
added lrs performance test
moved performance tests into an own project
don't use 64 bit number format of lrs as it does not work correctly

Location:

branches/HeuristicLab.Analysis.AlgorithmBehavior

Files:

: 7 added
: 1 deleted
: 7 edited
: 2 copied

AlgorithmBehaviorUnitTests/TestVolumeCalculation.cs (deleted)
HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/ConvexHullMeasures.cs (modified) (1 diff)
HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/FractionClass.cs (copied) (copied from branches/HeuristicLab.Analysis.AlgorithmBehavior/liblrs/Testliblrs/FractionClass.cs) (1 diff)
HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers-3.3.csproj (modified) (2 diffs)
HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/LiblrsWrapper.cs (copied) (copied from branches/HeuristicLab.Analysis.AlgorithmBehavior/liblrs/Testliblrs/LiblrsWrapper.cs) (1 diff)
HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/liblrs.dll (added)
HeuristicLab.Analysis.AlgorithmBehavior.sln (modified) (3 diffs)
PerformanceTests (added)
PerformanceTests/PerformanceTests.csproj (added)
PerformanceTests/Program.cs (added)
PerformanceTests/Properties (added)
PerformanceTests/Properties/AssemblyInfo.cs (added)
PerformanceTests/liblrs.dll (added)
liblrs/ctest_liblrs/ctest_liblrs.vcxproj (modified) (5 diffs)
liblrs/liblrs/extfunc.c (modified) (1 diff)
liblrs/liblrs/liblrs.sln (modified) (1 diff)
liblrs/liblrs/liblrs.vcxproj (modified) (2 diffs)

Legend:

: Unmodified
: Added
: Removed

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/ConvexHullMeasures.cs

-                      r10198
+                      r10200
     //Calculates the volumne of a d-simplex
     private static double CalculateSimplexVolume(List<double[]> simplex) {
+      double[,] diffs = new double[simplex.Count, simplex.Count];
+      int dim = simplex.First().Length;
+      double[,] diffs = new double[dim, dim];
       for (int i = 0; i < simplex.Count; i++) {
         for (int j = 0; j < simplex.Count; j++) {
           diffs[i, j] = simplex[i].EuclideanDistance(simplex[j]);
+      for (int i = 1; i < simplex.Count; i++) {
+        for (int j = 0; j < dim; j++) {
+          diffs[j, i - 1] = simplex[i][j] - simplex[0][j];
+        }
+      }
       double det = alglib.rmatrixdet(diffs);
       double result = det / simplex[0].Count().Fact();
+      double result = det / dim.Fact();
       return result;

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/FractionClass.cs

-                      r10198
+                      r10200
+  /*
+  * Author: Syed Mehroz Alam
+  * Email: smehrozalam@yahoo.com
+  * URL: Programming Home "http://www.geocities.com/smehrozalam/"
+  *
+  */
+  using System;
+  using System.Runtime.InteropServices;
+  using System.Globalization;
+  namespace Mehroz
+  {
+    /// <summary>
+    /// Classes Contained:
+    ///     Fraction
+    ///     FractionException
+    /// </summary>
+    /// Class name: Fraction
+    /// Developed by: Syed Mehroz Alam
+    /// Email: mailto:smehrozalam@yahoo.com
+    /// URL: http://www.geocities.com/smehrozalam/
+    /// Changes: Marc C. Brooks  mailto:IDisposable@gmail.com
+    ///          Jeffery Sax    http://www.extremeoptimization.com
+    /// Version: 2.2
+    ///
+    /// What's new in version 2.0:
+    ///     *   Changed Numerator and Denominator from Int32(integer) to Int64(long) for increased range
+    ///     *   renamed ConvertToString() to (overloaded) ToString()
+    ///     *   added the capability of detecting/raising overflow exceptions
+    ///     *   Fixed the bug that very small numbers e.g. 0.00000001 could not be converted to fraction
+    ///     *   Other minor bugs fixed
+    ///
+    /// What's new in version 2.1
+    ///     *   overloaded user-defined conversions to/from Fractions
+    ///
+    /// What's new in version 2.2 - Marc C. Brooks   mailto:IDisposable@gmail.com
+    ///     *   less overflows by finding the GCD for Add [Jeffery Sax] and Multiply [Marc C. Brooks]
+    ///     *   understands and handles NaN, PositiveInfinity, NegativeInfinity just like double [Marc C. Brooks]
+    ///     *   fixed several uses of int where long was correct [Marc C. Brooks]
+    ///     *   made value-type (struct) [Jeffery Sax]
+    ///     *   added ToInt32(), ToInt64() which throw for invalid (NaN, PositiveInfinity, NegativeInfinity) [Marc C. Brooks]
+    ///     *   removed redundant Value property [Jeffery Sax]
+    ///     *   added explicit conversion to Int32 and Int64 [Marc C. Brooks]
+    ///     *   better handling of exceptions [Marc C. Brooks]
+    ///     *   reorganize code, add XML doc and regions [Marc C. Brooks]
+    ///     *   proper implementations of Equals [Marc C. Brooks, Jeffery Sax]
+    ///     *   uses Math.Log(xx,2) and Math.Pow(xx,2) to get the best accuracy possible when converting doubles [Marc C. Brooks, Jeffery Sax]
+    ///
+    /// What's new in version 2.3 - Marc C. Brooks   mailto:IDisposable@gmail.com   01/10/2005
+    ///     *   fixed double-to-fraction logic to use continued fraction rules to get best possible precistion [bug fix for Syed Mehroz Alam, idea from  Jeffery Sax]
+    ///     * added static readonly values for NaN, PositiveInfinity, NegativeInfinity [idea from Jeffery Sax]
+    ///     * moved comparisons into an implementation of IComparer [idea from Jeffery Sax]
+    ///     * no longer throws for NaN(s) involved in Add, Subtract, Multiply, Divide operations [idea from Jeffery Sax]
+    ///     *   added static readonly values for Zero, MinValue, MaxValue, Epsilon to better mirror double
+    ///     *   added IsInfinity to better mirror double.
+    ///     *   added Modulus and % operators
+    ///
+    /// Properties:
+    ///     Numerator: Set/Get value for Numerator
+    ///     Denominator:  Set/Get value for Numerator
+    ///     [Note: If you Set either Property, the Fraction should be passed to ReduceFraction at some point.]
+    ///
+    /// Constructors:
+    ///     no arguments:   initializes fraction as 0/0 = NaN, so don't do that!
+    ///     (Numerator, Denominator): initializes fraction with the given numerator and denominator
+    ///                               values and reduces
+    ///     (long): initializes fraction with the given long value
+    ///     (double):   initializes fraction with the given double value
+    ///     (string):   initializes fraction with the given string value
+    ///                 the string can be an in the form of and integer, double or fraction.
+    ///                 e.g it can be like "123" or "123.321" or "123/456"
+    ///
+    /// Public Methods (Description is given with respective methods' definitions)
+    ///     Fraction ToFraction(long)
+    ///     Fraction ToFraction(double)
+    ///     Fraction ToFraction(string)
+    ///     Int32 ToInt32()
+    ///     Int64 ToInt64()
+    ///     double ToDouble()
+    ///     (override) string ToString()
+    ///     Fraction Inverse()
+    ///     Fraction Inverted(long)
+    ///     Fraction Inverted(double)
+    ///     ReduceFraction(ref Fraction)
+    ///     CrossReducePair(ref Fraction, ref Fraction)
+    ///     (override) Equals(object)
+    ///     (override) GetHashCode()
+    ///
+    /// Overloaded Operators (overloaded for Fractions, long and double)
+    ///     Unary: -
+    ///     Binary: +,-,*,/
+    ///     Relational and Logical Operators: ==,!=,<,>,<=,>= (only == and != for long and doubles)
+    ///
+    /// Overloaded user-defined conversions
+    ///     Implicit:   From long/double/string to Fraction
+    ///     Explicit:   From Fraction to long/double/string
+    /// </summary>
+    [Serializable, StructLayout(LayoutKind.Sequential)]
+    public struct Fraction : IComparable, IFormattable
+    {
+      #region Constructors
+      /// <summary>
+      /// Construct a Fraction from an integral value
+      /// </summary>
+      /// <param name="wholeNumber">The value (eventual numerator)</param>
+      /// <remarks>The denominator will be 1</remarks>
+      public Fraction(long wholeNumber)
+      {
+        if (wholeNumber == long.MinValue)
+          wholeNumber++;  // prevent serious issues later..
+        m_Numerator = wholeNumber;
+        m_Denominator = 1;
+        // no reducing required, we're a whole number
+      }
+      /// <summary>
+      /// Construct a Fraction from a floating-point value
+      /// </summary>
+      /// <param name="floatingPointNumber">The value</param>
+      public Fraction(double floatingPointNumber)
+      {
+        this = ToFraction(floatingPointNumber);
+      }
+      /// <summary>
+      /// Construct a Fraction from a string in any legal format
+      /// </summary>
+      /// <param name="inValue">A string with a legal fraction input format</param>
+      /// <remarks>Will reduce the fraction to smallest possible denominator</remarks>
+      /// <see>ToFraction(string strValue)</see>
+      public Fraction(string inValue)
+      {
+        this = ToFraction(inValue);
+      }
+      /// <summary>
+      /// Construct a Fraction from a numerator, denominator pair
+      /// </summary>
+      /// <param name="numerator">The numerator (top number)</param>
+      /// <param name="denominator">The denominator (bottom number)</param>
+      /// <remarks>Will reduce the fraction to smallest possible denominator</remarks>
+      public Fraction(long numerator, long denominator)
+      {
+        if (numerator == long.MinValue)
+          numerator++;  // prevent serious issues later..
+        if (denominator == long.MinValue)
+          denominator++;  // prevent serious issues later..
+        m_Numerator = numerator;
+        m_Denominator = denominator;
+        ReduceFraction(ref this);
+      }
+      /// <summary>
+      /// Private constructor to synthesize a Fraction for indeterminates (NaN and infinites)
+      /// </summary>
+      /// <param name="type">Kind of inderterminate</param>
+      private Fraction(Indeterminates type)
+      {
+        m_Numerator = (long)type;
+        m_Denominator = 0;
+        // do NOT reduce, we're clean as can be!
+      }
+      #endregion
+      #region Properties
+      /// <summary>
+      /// The 'top' part of the fraction
+      /// </summary>
+      /// <example>For 3/4ths, this is the 3</example>
+      public long Numerator
+      {
+        get
+        {
+          return m_Numerator;
+        }
+        set
+        {
+          m_Numerator = value;
+        }
+      }
+      /// <summary>
+      /// The 'bottom' part of the fraction
+      /// </summary>
+      /// <example>For 3/4ths, this is the 4</example>
+      public long Denominator
+      {
+        get
+        {
+          return m_Denominator;
+        }
+        set
+        {
+          m_Denominator = value;
+        }
+      }
+      #endregion
+      #region Expose constants
+      public static readonly Fraction NaN = new Fraction(Indeterminates.NaN);
+      public static readonly Fraction PositiveInfinity = new Fraction(Indeterminates.PositiveInfinity);
+      public static readonly Fraction NegativeInfinity = new Fraction(Indeterminates.NegativeInfinity);
+      public static readonly Fraction Zero = new Fraction(0,1);
+      public static readonly Fraction Epsilon = new Fraction(1, Int64.MaxValue);
+      private static readonly double EpsilonDouble = 1.0 / Int64.MaxValue;
+      public static readonly Fraction MaxValue = new Fraction(Int64.MaxValue, 1);
+      public static readonly Fraction MinValue = new Fraction(Int64.MinValue, 1);
+      #endregion
+      #region Explicit conversions
+      #region To primitives
+      /// <summary>
+      /// Get the integral value of the Fraction object as int/Int32
+      /// </summary>
+      /// <returns>The (approximate) integer value</returns>
+      /// <remarks>If the value is not a true integer, the fractional part is discarded
+      /// (truncated toward zero). If the valid exceeds the range of an Int32 and exception is thrown.</remarks>
+      /// <exception cref="FractionException">Will throw a FractionException for NaN, PositiveInfinity
+      /// or NegativeInfinity with the InnerException set to a System.NotFiniteNumberException.</exception>
+      /// <exception cref="OverflowException" Will throw a System.OverflowException if the value is too
+      /// large or small to be represented as an Int32.</exception>
+      public Int32 ToInt32()
+      {
+        if (this.m_Denominator == 0)
+        {
+          throw new FractionException(string.Format("Cannot convert {0} to Int32", IndeterminateTypeName(this.m_Numerator)), new System.NotFiniteNumberException());
+        }
+        long bestGuess = this.m_Numerator / this.m_Denominator;
+        if (bestGuess > Int32.MaxValue || bestGuess < Int32.MinValue)
+        {
+          throw new FractionException("Cannot convert to Int32", new System.OverflowException());
+        }
+        return (Int32)bestGuess;
+      }
+      /// <summary>
+      /// Get the integral value of the Fraction object as long/Int64
+      /// </summary>
+      /// <returns>The (approximate) integer value</returns>
+      /// <remarks>If the value is not a true integer, the fractional part is discarded
+      /// (truncated toward zero). If the valid exceeds the range of an Int32, no special
+      /// handling is guaranteed.</remarks>
+      /// <exception cref="FractionException">Will throw a FractionException for NaN, PositiveInfinity
+      /// or NegativeInfinity with the InnerException set to a System.NotFiniteNumberException.</exception>
+      public Int64 ToInt64()
+      {
+        if (this.m_Denominator == 0)
+        {
+          throw new FractionException(string.Format("Cannot convert {0} to Int64", IndeterminateTypeName(this.m_Numerator)), new System.NotFiniteNumberException());
+        }
+        return this.m_Numerator / this.m_Denominator;
+      }
+      /// <summary>
+      /// Get the value of the Fraction object as double with full support for NaNs and infinities
+      /// </summary>
+      /// <returns>The decimal representation of the Fraction, or double.NaN, double.NegativeInfinity
+      /// or double.PositiveInfinity</returns>
+      public double ToDouble()
+      {
+        if (this.m_Denominator == 1)
+          return this.m_Numerator;
+        else if (this.m_Denominator == 0)
+        {
+          switch (NormalizeIndeterminate(this.m_Numerator))
+          {
+            case Indeterminates.NegativeInfinity:
+              return double.NegativeInfinity;
+            case Indeterminates.PositiveInfinity:
+              return double.PositiveInfinity;
+            case Indeterminates.NaN:
+            default:    // this can't happen
+              return double.NaN;
+          }
+        }
+        else
+        {
+          return (double)this.m_Numerator / (double)this.m_Denominator;
+        }
+      }
+      /// <summary>
+      /// Get the value of the Fraction as a string, with proper representation for NaNs and infinites
+      /// </summary>
+      /// <returns>The string representation of the Fraction, or the culture-specific representations of
+      /// NaN, PositiveInfinity or NegativeInfinity.</returns>
+      /// <remarks>The current culture determines the textual representation the Indeterminates</remarks>
+      public override string ToString()
+      {
+        if (this.m_Denominator == 1)
+        {
+          return this.m_Numerator.ToString();
+        }
+        else if (this.m_Denominator == 0)
+        {
+          return IndeterminateTypeName(this.m_Numerator);
+        }
+        else
+        {
+          return this.m_Numerator.ToString() + "/" + this.m_Denominator.ToString();
+        }
+      }
+      #endregion
+      #region From primitives
+      /// <summary>
+      /// Converts a long value to the exact Fraction
+      /// </summary>
+      /// <param name="inValue">The long to convert</param>
+      /// <returns>An exact representation of the value</returns>
+      public static Fraction ToFraction(long inValue)
+      {
+        return new Fraction(inValue);
+      }
+      /// <summary>
+      /// Converts a double value to the approximate Fraction
+      /// </summary>
+      /// <param name="inValue">The double to convert</param>
+      /// <returns>A best-fit representation of the value</returns>
+      /// <remarks>Supports double.NaN, double.PositiveInfinity and double.NegativeInfinity</remarks>
+      public static Fraction ToFraction(double inValue)
+      {
+        // it's one of the indeterminates... which?
+        if (double.IsNaN(inValue))
+          return NaN;
+        else if (double.IsNegativeInfinity(inValue))
+          return NegativeInfinity;
+        else if (double.IsPositiveInfinity(inValue))
+          return PositiveInfinity;
+        else if (inValue == 0.0d)
+          return Zero;
+        if (inValue > Int64.MaxValue)
+          throw new OverflowException(string.Format("Double {0} too large", inValue));
+        if (inValue < -Int64.MaxValue)
+          throw new OverflowException(string.Format("Double {0} too small", inValue));
+        if (-EpsilonDouble < inValue && inValue < EpsilonDouble)
+          throw new ArithmeticException(string.Format("Double {0} cannot be represented", inValue));
+        int sign = Math.Sign(inValue);
+        inValue = Math.Abs(inValue);
+        return ConvertPositiveDouble(sign, inValue);
+      }
+      /// <summary>
+      /// Converts a string to the corresponding reduced fraction
+      /// </summary>
+      /// <param name="inValue">The string representation of a fractional value</param>
+      /// <returns>The Fraction that represents the string</returns>
+      /// <remarks>Four forms are supported, as a plain integer, as a double, or as Numerator/Denominator
+      /// and the representations for NaN and the infinites</remarks>
+      /// <example>"123" = 123/1 and "1.25" = 5/4 and "10/36" = 5/13 and NaN = 0/0 and
+      /// PositiveInfinity = 1/0 and NegativeInfinity = -1/0</example>
+      public static Fraction ToFraction(string inValue)
+      {
+        if (inValue == null || inValue == string.Empty)
+          throw new ArgumentNullException("inValue");
+        // could also be NumberFormatInfo.InvariantInfo
+        NumberFormatInfo info = NumberFormatInfo.CurrentInfo;
+        // Is it one of the special symbols for NaN and such...
+        string trimmedValue = inValue.Trim();
+        if (trimmedValue == info.NaNSymbol)
+          return NaN;
+        else if (trimmedValue == info.PositiveInfinitySymbol)
+          return PositiveInfinity;
+        else if (trimmedValue == info.NegativeInfinitySymbol)
+          return NegativeInfinity;
+        else
+        {
+          // Not special, is it a Fraction?
+          int slashPos = inValue.IndexOf('/');
+          if (slashPos > -1)
+          {
+            // string is in the form of Numerator/Denominator
+            long numerator = Convert.ToInt64(inValue.Substring(0, slashPos));
+            long denominator = Convert.ToInt64(inValue.Substring(slashPos + 1));
+            return new Fraction(numerator, denominator);
+          }
+          else
+          {
+            // the string is not in the form of a fraction
+            // hopefully it is double or integer, do we see a decimal point?
+            int decimalPos = inValue.IndexOf(info.CurrencyDecimalSeparator);
+            if (decimalPos > -1)
+              return new Fraction(Convert.ToDouble(inValue));
+            else
+              return new Fraction(Convert.ToInt64(inValue));
+          }
+        }
+      }
+      #endregion
+      #endregion
+      #region Indeterminate classifications
+      /// <summary>
+      /// Determines if a Fraction represents a Not-a-Number
+      /// </summary>
+      /// <returns>True if the Fraction is a NaN</returns>
+      public bool IsNaN()
+      {
+        if (this.m_Denominator == 0
+          && NormalizeIndeterminate(this.m_Numerator) == Indeterminates.NaN)
+          return true;
+        else
+          return false;
+      }
+      /// <summary>
+      /// Determines if a Fraction represents Any Infinity
+      /// </summary>
+      /// <returns>True if the Fraction is Positive Infinity or Negative Infinity</returns>
+      public bool IsInfinity()
+      {
+        if (this.m_Denominator == 0
+          && NormalizeIndeterminate(this.m_Numerator) != Indeterminates.NaN)
+          return true;
+        else
+          return false;
+      }
+      /// <summary>
+      /// Determines if a Fraction represents Positive Infinity
+      /// </summary>
+      /// <returns>True if the Fraction is Positive Infinity</returns>
+      public bool IsPositiveInfinity()
+      {
+        if (this.m_Denominator == 0
+          && NormalizeIndeterminate(this.m_Numerator) == Indeterminates.PositiveInfinity)
+          return true;
+        else
+          return false;
+      }
+      /// <summary>
+      /// Determines if a Fraction represents Negative Infinity
+      /// </summary>
+      /// <returns>True if the Fraction is Negative Infinity</returns>
+      public bool IsNegativeInfinity()
+      {
+        if (this.m_Denominator == 0
+          && NormalizeIndeterminate(this.m_Numerator) == Indeterminates.NegativeInfinity)
+          return true;
+        else
+          return false;
+      }
+      #endregion
+      #region Inversion
+      /// <summary>
+      /// Inverts a Fraction
+      /// </summary>
+      /// <returns>The inverted Fraction (with Denominator over Numerator)</returns>
+      /// <remarks>Does NOT throw for zero Numerators as later use of the fraction will catch the error.</remarks>
+      public Fraction Inverse()
+      {
+        // don't use the obvious constructor because we do not want it normalized at this time
+        Fraction frac = new Fraction();
+        frac.m_Numerator = this.m_Denominator;
+        frac.m_Denominator = this.m_Numerator;
+        return frac;
+      }
+      /// <summary>
+      /// Creates an inverted Fraction
+      /// </summary>
+      /// <returns>The inverted Fraction (with Denominator over Numerator)</returns>
+      /// <remarks>Does NOT throw for zero Numerators as later use of the fraction will catch the error.</remarks>
+      public static Fraction Inverted(long value)
+      {
+        Fraction frac = new Fraction(value);
+        return frac.Inverse();
+      }
+      /// <summary>
+      /// Creates an inverted Fraction
+      /// </summary>
+      /// <returns>The inverted Fraction (with Denominator over Numerator)</returns>
+      /// <remarks>Does NOT throw for zero Numerators as later use of the fraction will catch the error.</remarks>
+      public static Fraction Inverted(double value)
+      {
+        Fraction frac = new Fraction(value);
+        return frac.Inverse();
+      }
+      #endregion
+      #region Operators
+      #region Unary Negation operator
+      /// <summary>
+      /// Negates the Fraction
+      /// </summary>
+      /// <param name="left">The Fraction to negate</param>
+      /// <returns>The negative version of the Fraction</returns>
+      public static Fraction operator -(Fraction left)
+      {
+        return Negate(left);
+      }
+      #endregion
+      #region Addition operators
+      public static Fraction operator +(Fraction left, Fraction right)
+      {
+        return Add(left, right);
+      }
+      public static Fraction operator +(long left, Fraction right)
+      {
+        return Add(new Fraction(left), right);
+      }
+      public static Fraction operator +(Fraction left, long right)
+      {
+        return Add(left, new Fraction(right));
+      }
+      public static Fraction operator +(double left, Fraction right)
+      {
+        return Add(ToFraction(left), right);
+      }
+      public static Fraction operator +(Fraction left, double right)
+      {
+        return Add(left, ToFraction(right));
+      }
+      #endregion
+      #region Subtraction operators
+      public static Fraction operator -(Fraction left, Fraction right)
+      {
+        return Add(left, - right);
+      }
+      public static Fraction operator -(long left, Fraction right)
+      {
+        return Add(new Fraction(left), - right);
+      }
+      public static Fraction operator -(Fraction left, long right)
+      {
+        return Add(left, new Fraction(- right));
+      }
+      public static Fraction operator -(double left, Fraction right)
+      {
+        return Add(ToFraction(left), - right);
+      }
+      public static Fraction operator -(Fraction left, double right)
+      {
+        return Add(left, ToFraction(- right));
+      }
+      #endregion
+      #region Multiplication operators
+      public static Fraction operator *(Fraction left, Fraction right)
+      {
+        return Multiply(left, right);
+      }
+      public static Fraction operator *(long left, Fraction right)
+      {
+        return Multiply(new Fraction(left), right);
+      }
+      public static Fraction operator *(Fraction left, long right)
+      {
+        return Multiply(left, new Fraction(right));
+      }
+      public static Fraction operator *(double left, Fraction right)
+      {
+        return Multiply(ToFraction(left), right);
+      }
+      public static Fraction operator *(Fraction left, double right)
+      {
+        return Multiply(left, ToFraction(right));
+      }
+      #endregion
+      #region Division operators
+      public static Fraction operator /(Fraction left, Fraction right)
+      {
+        return Multiply(left, right.Inverse());
+      }
+      public static Fraction operator /(long left, Fraction right)
+      {
+        return Multiply(new Fraction(left), right.Inverse());
+      }
+      public static Fraction operator /(Fraction left, long right)
+      {
+        return Multiply(left, Inverted(right));
+      }
+      public static Fraction operator /(double left, Fraction right)
+      {
+        return Multiply(ToFraction(left), right.Inverse());
+      }
+      public static Fraction operator /(Fraction left, double right)
+      {
+        return Multiply(left, Inverted(right));
+      }
+      #endregion
+      #region Modulus operators
+      public static Fraction operator %(Fraction left, Fraction right)
+      {
+        return Modulus(left, right);
+      }
+      public static Fraction operator %(long left, Fraction right)
+      {
+        return Modulus(new Fraction(left), right);
+      }
+      public static Fraction operator %(Fraction left, long right)
+      {
+        return Modulus(left, right);
+      }
+      public static Fraction operator %(double left, Fraction right)
+      {
+        return Modulus(ToFraction(left), right);
+      }
+      public static Fraction operator %(Fraction left, double right)
+      {
+        return Modulus(left, right);
+      }
+      #endregion
+      #region Equal operators
+      public static bool operator ==(Fraction left, Fraction right)
+      {
+        return left.CompareEquality(right, false);
+      }
+      public static bool operator ==(Fraction left, long right)
+      {
+        return left.CompareEquality(new Fraction(right), false);
+      }
+      public static bool operator ==(Fraction left, double right)
+      {
+        return left.CompareEquality(new Fraction(right), false);
+      }
+      #endregion
+      #region Not-equal operators
+      public static bool operator !=(Fraction left, Fraction right)
+      {
+        return left.CompareEquality(right, true);
+      }
+      public static bool operator !=(Fraction left, long right)
+      {
+        return left.CompareEquality(new Fraction(right), true);
+      }
+      public static bool operator !=(Fraction left, double right)
+      {
+        return left.CompareEquality(new Fraction(right), true);
+      }
+      #endregion
+      #region Inequality operators
+      /// <summary>
+      /// Compares two Fractions to see if left is less than right
+      /// </summary>
+      /// <param name="left">The first Fraction</param>
+      /// <param name="right">The second Fraction</param>
+      /// <returns>True if <paramref name="left">left</paramref> is less
+      /// than <paramref name="right">right</paramref></returns>
+      /// <remarks>Special handling for indeterminates exists. <see>IndeterminateLess</see></remarks>
+      /// <exception cref="FractionException">Throws an error if overflows occur while computing the
+      /// difference with an InnerException of OverflowException</exception>
+      public static bool operator <(Fraction left, Fraction right)
+      {
+        return left.CompareTo(right) < 0;
+      }
+      /// <summary>
+      /// Compares two Fractions to see if left is greater than right
+      /// </summary>
+      /// <param name="left">The first Fraction</param>
+      /// <param name="right">The second Fraction</param>
+      /// <returns>True if <paramref name="left">left</paramref> is greater
+      /// than <paramref name="right">right</paramref></returns>
+      /// <remarks>Special handling for indeterminates exists. <see>IndeterminateLess</see></remarks>
+      /// <exception cref="FractionException">Throws an error if overflows occur while computing the
+      /// difference with an InnerException of OverflowException</exception>
+      public static bool operator >(Fraction left, Fraction right)
+      {
+        return left.CompareTo(right) > 0;
+      }
+      /// <summary>
+      /// Compares two Fractions to see if left is less than or equal to right
+      /// </summary>
+      /// <param name="left">The first Fraction</param>
+      /// <param name="right">The second Fraction</param>
+      /// <returns>True if <paramref name="left">left</paramref> is less than or
+      /// equal to <paramref name="right">right</paramref></returns>
+      /// <remarks>Special handling for indeterminates exists. <see>IndeterminateLessEqual</see></remarks>
+      /// <exception cref="FractionException">Throws an error if overflows occur while computing the
+      /// difference with an InnerException of OverflowException</exception>
+      public static bool operator <=(Fraction left, Fraction right)
+      {
+        return left.CompareTo(right) <= 0;
+      }
+      /// <summary>
+      /// Compares two Fractions to see if left is greater than or equal to right
+      /// </summary>
+      /// <param name="left">The first Fraction</param>
+      /// <param name="right">The second Fraction</param>
+      /// <returns>True if <paramref name="left">left</paramref> is greater than or
+      /// equal to <paramref name="right">right</paramref></returns>
+      /// <remarks>Special handling for indeterminates exists. <see>IndeterminateLessEqual</see></remarks>
+      /// <exception cref="FractionException">Throws an error if overflows occur while computing the
+      /// difference with an InnerException of OverflowException</exception>
+      public static bool operator >=(Fraction left, Fraction right)
+      {
+        return left.CompareTo(right) >= 0;
+      }
+      #endregion
+      #region Implict conversion from primitive operators
+      /// <summary>
+      /// Implicit conversion of a long integral value to a Fraction
+      /// </summary>
+      /// <param name="value">The long integral value to convert</param>
+      /// <returns>A Fraction whose denominator is 1</returns>
+      public static implicit operator Fraction(long value)
+      {
+        return new Fraction(value);
+      }
+      /// <summary>
+      /// Implicit conversion of a double floating point value to a Fraction
+      /// </summary>
+      /// <param name="value">The double value to convert</param>
+      /// <returns>A reduced Fraction</returns>
+      public static implicit operator Fraction(double value)
+      {
+        return new Fraction(value);
+      }
+      /// <summary>
+      /// Implicit conversion of a string to a Fraction
+      /// </summary>
+      /// <param name="value">The string to convert</param>
+      /// <returns>A reduced Fraction</returns>
+      public static implicit operator Fraction(string value)
+      {
+        return new Fraction(value);
+      }
+      #endregion
+      #region Explicit converstion to primitive operators
+      /// <summary>
+      /// Explicit conversion from a Fraction to an integer
+      /// </summary>
+      /// <param name="frac">the Fraction to convert</param>
+      /// <returns>The integral representation of the Fraction</returns>
+      public static explicit operator int(Fraction frac)
+      {
+        return frac.ToInt32();
+      }
+      /// <summary>
+      /// Explicit conversion from a Fraction to an integer
+      /// </summary>
+      /// <param name="frac">The Fraction to convert</param>
+      /// <returns>The integral representation of the Fraction</returns>
+      public static explicit operator long(Fraction frac)
+      {
+        return frac.ToInt64();
+      }
+      /// <summary>
+      /// Explicit conversion from a Fraction to a double floating-point value
+      /// </summary>
+      /// <param name="frac">The Fraction to convert</param>
+      /// <returns>The double representation of the Fraction</returns>
+      public static explicit operator double(Fraction frac)
+      {
+        return frac.ToDouble();
+      }
+      /// <summary>
+      /// Explicit conversion from a Fraction to a string
+      /// </summary>
+      /// <param name="frac">the Fraction to convert</param>
+      /// <returns>The string representation of the Fraction</returns>
+      public static implicit operator string(Fraction frac)
+      {
+        return frac.ToString();
+      }
+      #endregion
+      #endregion
+      #region Equals and GetHashCode overrides
+      /// <summary>
+      /// Compares for equality the current Fraction to the value passed.
+      /// </summary>
+      /// <param name="obj">A  Fraction,</param>
+      /// <returns>True if the value equals the current fraction, false otherwise (including for
+      /// non-Fraction types or null object.</returns>
+      public override bool Equals(object obj)
+      {
+        if (obj == null || ! (obj is Fraction))
+          return false;
+        try
+        {
+          Fraction right = (Fraction)obj;
+          return this.CompareEquality(right, false);
+        }
+        catch
+        {
+          // can't throw in an Equals!
+          return false;
+        }
+      }
+      /// <summary>
+      /// Returns a hash code generated from the current Fraction
+      /// </summary>
+      /// <returns>The hash code</returns>
+      /// <remarks>Reduces (in-place) the Fraction first.</remarks>
+      public override int GetHashCode()
+      {
+        // insure we're as close to normalized as possible first
+        ReduceFraction(ref this);
+        int numeratorHash = this.m_Numerator.GetHashCode();
+        int denominatorHash = this.m_Denominator.GetHashCode();
+        return (numeratorHash ^ denominatorHash);
+      }
+      #endregion
+      #region IComparable member and type-specific version
+      /// <summary>
+      /// Compares an object to this Fraction
+      /// </summary>
+      /// <param name="obj">The object to compare against (null is less than everything)</param>
+      /// <returns>-1 if this is less than <paramref name="obj"></paramref>,
+      ///  0 if they are equal,
+      ///  1 if this is greater than <paramref name="obj"></paramref></returns>
+      /// <remarks>Will convert an object from longs, doubles, and strings as this is a value-type.</remarks>
+      public int CompareTo(object obj)
+      {
+        if (obj == null)
+          return 1; // null is less than anything
+        Fraction right;
+        if (obj is Fraction)
+          right = (Fraction)obj;
+        else if (obj is long)
+          right = (long)obj;
+        else if (obj is double)
+          right = (double)obj;
+        else if (obj is string)
+          right = (string)obj;
+        else
+          throw new ArgumentException("Must be convertible to Fraction", "obj");
+        return this.CompareTo(right);
+      }
+      /// <summary>
+      /// Compares this Fraction to another Fraction
+      /// </summary>
+      /// <param name="right">The Fraction to compare against</param>
+      /// <returns>-1 if this is less than <paramref name="right"></paramref>,
+      ///  0 if they are equal,
+      ///  1 if this is greater than <paramref name="right"></paramref></returns>
+      public int CompareTo(Fraction right)
+      {
+        // if left is an indeterminate, punt to the helper...
+        if (this.m_Denominator == 0)
+        {
+          return IndeterminantCompare(NormalizeIndeterminate(this.m_Numerator), right);
+        }
+        // if right is an indeterminate, punt to the helper...
+        if (right.m_Denominator == 0)
+        {
+          // note sign-flip...
+          return - IndeterminantCompare(NormalizeIndeterminate(right.m_Numerator), this);
+        }
+        // they're both normal Fractions
+        CrossReducePair(ref this, ref right);
+        try
+        {
+          checked
+          {
+            long leftScale = this.m_Numerator * right.m_Denominator;
+            long rightScale = this.m_Denominator * right.m_Numerator;
+            if (leftScale < rightScale)
+              return -1;
+            else if (leftScale > rightScale)
+              return 1;
+            else
+              return 0;
+          }
+        }
+        catch (Exception e)
+        {
+          throw new FractionException(string.Format("CompareTo({0}, {1}) error", this, right), e);
+        }
+      }
+      #endregion
+      #region IFormattable Members
+      string System.IFormattable.ToString(string format, IFormatProvider formatProvider)
+      {
+        return this.m_Numerator.ToString(format, formatProvider) + "/" + this.m_Denominator.ToString(format, formatProvider);
+      }
+      #endregion
+      #region Reduction
+      /// <summary>
+      /// Reduces (simplifies) a Fraction by dividing down to lowest possible denominator (via GCD)
+      /// </summary>
+      /// <param name="frac">The Fraction to be reduced [WILL BE MODIFIED IN PLACE]</param>
+      /// <remarks>Modifies the input arguments in-place! Will normalize the NaN and infinites
+      /// representation. Will set Denominator to 1 for any zero numerator. Moves sign to the
+      /// Numerator.</remarks>
+      /// <example>2/4 will be reduced to 1/2</example>
+      public static void ReduceFraction(ref Fraction frac)
+      {
+        // clean up the NaNs and infinites
+        if (frac.m_Denominator == 0)
+        {
+          frac.m_Numerator = (long)NormalizeIndeterminate(frac.m_Numerator);
+          return;
+        }
+        // all forms of zero are alike.
+        if (frac.m_Numerator == 0)
+        {
+          frac.m_Denominator = 1;
+          return;
+        }
+        long iGCD = GCD(frac.m_Numerator, frac.m_Denominator);
+        frac.m_Numerator /= iGCD;
+        frac.m_Denominator /= iGCD;
+        // if negative sign in denominator
+        if ( frac.m_Denominator < 0 )
+        {
+          //move negative sign to numerator
+          frac.m_Numerator = - frac.m_Numerator;
+          frac.m_Denominator = - frac.m_Denominator;
+        }
+      }
+      /// <summary>
+      /// Cross-reduces a pair of Fractions so that we have the best GCD-reduced values for multiplication
+      /// </summary>
+      /// <param name="frac1">The first Fraction [WILL BE MODIFIED IN PLACE]</param>
+      /// <param name="frac2">The second Fraction [WILL BE MODIFIED IN PLACE]</param>
+      /// <remarks>Modifies the input arguments in-place!</remarks>
+      /// <example>(3/4, 5/9) = (1/4, 5/3)</example>
+      public static void CrossReducePair(ref Fraction frac1, ref Fraction frac2)
+      {
+        // leave the indeterminates alone!
+        if (frac1.m_Denominator == 0 || frac2.m_Denominator == 0)
+          return;
+        long gcdTop = GCD(frac1.m_Numerator, frac2.m_Denominator);
+        frac1.m_Numerator = frac1.m_Numerator / gcdTop;
+        frac2.m_Denominator = frac2.m_Denominator / gcdTop;
+        long gcdBottom = GCD(frac1.m_Denominator, frac2.m_Numerator);
+        frac2.m_Numerator = frac2.m_Numerator / gcdBottom;
+        frac1.m_Denominator = frac1.m_Denominator / gcdBottom;
+      }
+      #endregion
+      #region Implementation
+      #region Convert a double to a fraction
+      private static Fraction ConvertPositiveDouble(int sign, double inValue)
+      {
+        // Shamelessly stolen from http://homepage.smc.edu/kennedy_john/CONFRAC.PDF
+        // with AccuracyFactor == double.Episilon
+        long fractionNumerator = (long)inValue;
+        double fractionDenominator = 1;
+        double previousDenominator = 0;
+        double remainingDigits = inValue;
+        int maxIterations = 594;  // found at http://www.ozgrid.com/forum/archive/index.php/t-22530.html
+        while (remainingDigits != Math.Floor(remainingDigits)
+          && Math.Abs(inValue - (fractionNumerator / fractionDenominator)) > double.Epsilon)
+        {
+          remainingDigits = 1.0 / (remainingDigits - Math.Floor(remainingDigits));
+          double scratch = fractionDenominator;
+          fractionDenominator =(Math.Floor(remainingDigits) * fractionDenominator) + previousDenominator;
+          fractionNumerator = (long)(inValue * fractionDenominator + 0.5);
+          previousDenominator = scratch;
+          if (maxIterations-- < 0)
+            break;
+        }
+        return new Fraction(fractionNumerator * sign, (long)fractionDenominator);
+      }
+      #endregion
+      #region Equality helper
+      /// <summary>
+      /// Compares for equality the current Fraction to the value passed.
+      /// </summary>
+      /// <param name="right">A Fraction to compare against</param>
+      /// <param name="notEqualCheck">If true, we're looking for not-equal</param>
+      /// <returns>True if the <paramref name="right"></paramref> equals the current
+      /// fraction, false otherwise. If comparing two NaNs, they are always equal AND
+      /// not-equal.</returns>
+      private bool CompareEquality(Fraction right, bool notEqualCheck)
+      {
+        // insure we're normalized first
+        ReduceFraction(ref this);
+        // now normalize the comperand
+        ReduceFraction(ref right);
+        if (this.m_Numerator == right.m_Numerator && this.m_Denominator == right.m_Denominator)
+        {
+          // special-case rule, two NaNs are always both equal
+          if (notEqualCheck && this.IsNaN())
+            return true;
+          else
+            return ! notEqualCheck;
+        }
+        else
+        {
+          return notEqualCheck;
+        }
+      }
+      #endregion
+      #region Comparison helper
+      /// <summary>
+      /// Determines how this Fraction, of an indeterminate type, compares to another Fraction
+      /// </summary>
+      /// <param name="leftType">What kind of indeterminate</param>
+      /// <param name="right">The other Fraction to compare against</param>
+      /// <returns>-1 if this is less than <paramref name="right"></paramref>,
+      ///  0 if they are equal,
+      ///  1 if this is greater than <paramref name="right"></paramref></returns>
+      /// <remarks>NaN is less than anything except NaN and Negative Infinity. Negative Infinity is less
+      /// than anything except Negative Infinity. Positive Infinity is greater than anything except
+      /// Positive Infinity.</remarks>
+      private static int IndeterminantCompare(Indeterminates leftType, Fraction right)
+      {
+        switch (leftType)
+        {
+          case Indeterminates.NaN:
+            // A NaN is...
+            if (right.IsNaN())
+              return 0; // equal to a NaN
+            else if (right.IsNegativeInfinity())
+              return 1; // great than Negative Infinity
+            else
+              return -1;  // less than anything else
+          case Indeterminates.NegativeInfinity:
+            // Negative Infinity is...
+            if (right.IsNegativeInfinity())
+              return 0; // equal to Negative Infinity
+            else
+              return -1;  // less than anything else
+          case Indeterminates.PositiveInfinity:
+            if (right.IsPositiveInfinity())
+              return 0; // equal to Positive Infinity
+            else
+              return 1; // greater than anything else
+          default:
+            // this CAN'T happen, something VERY wrong is going on...
+            return 0;
+        }
+      }
+      #endregion
+      #region Math helpers
+      /// <summary>
+      /// Negates the Fraction
+      /// </summary>
+      /// <param name="frac">Value to negate</param>
+      /// <returns>A new Fraction that is sign-flipped from the input</returns>
+      private static Fraction Negate(Fraction frac)
+      {
+        // for a NaN, it's still a NaN
+        return new Fraction( - frac.m_Numerator, frac.m_Denominator);
+      }
+      /// <summary>
+      /// Adds two Fractions
+      /// </summary>
+      /// <param name="left">A Fraction</param>
+      /// <param name="right">Another Fraction</param>
+      /// <returns>Sum of the Fractions. Returns NaN if either Fraction is a NaN.</returns>
+      /// <exception cref="FractionException">Will throw if an overflow occurs when computing the
+      /// GCD-normalized values.</exception>
+      private static Fraction Add(Fraction left, Fraction right)
+      {
+        if (left.IsNaN() || right.IsNaN())
+          return NaN;
+        long gcd = GCD(left.m_Denominator, right.m_Denominator); // cannot return less than 1
+        long leftDenominator = left.m_Denominator / gcd;
+        long rightDenominator = right.m_Denominator / gcd;
+        try
+        {
+          checked
+          {
+            long numerator = left.m_Numerator * rightDenominator + right.m_Numerator * leftDenominator;
+            long denominator = leftDenominator * rightDenominator * gcd;
+            return new Fraction(numerator, denominator);
+          }
+        }
+        catch (Exception e)
+        {
+          throw new FractionException("Add error", e);
+        }
+      }
+      /// <summary>
+      /// Multiplies two Fractions
+      /// </summary>
+      /// <param name="left">A Fraction</param>
+      /// <param name="right">Another Fraction</param>
+      /// <returns>Product of the Fractions. Returns NaN if either Fraction is a NaN.</returns>
+      /// <exception cref="FractionException">Will throw if an overflow occurs. Does a cross-reduce to
+      /// insure only the unavoidable overflows occur.</exception>
+      private static Fraction Multiply(Fraction left, Fraction right)
+      {
+        if (left.IsNaN() || right.IsNaN())
+          return NaN;
+        // this would be unsafe if we were not a ValueType, because we would be changing the
+        // caller's values.  If we change back to a class, must use temporaries
+        CrossReducePair(ref left, ref right);
+        try
+        {
+          checked
+          {
+            long numerator = left.m_Numerator * right.m_Numerator;
+            long denominator = left.m_Denominator * right.m_Denominator;
+            return new Fraction(numerator, denominator);
+          }
+        }
+        catch (Exception e)
+        {
+          throw new FractionException("Multiply error", e);
+        }
+      }
+      /// <summary>
+      /// Returns the modulus (remainder after dividing) two Fractions
+      /// </summary>
+      /// <param name="left">A Fraction</param>
+      /// <param name="right">Another Fraction</param>
+      /// <returns>Modulus of the Fractions. Returns NaN if either Fraction is a NaN.</returns>
+      /// <exception cref="FractionException">Will throw if an overflow occurs. Does a cross-reduce to
+      /// insure only the unavoidable overflows occur.</exception>
+      private static Fraction Modulus(Fraction left, Fraction right)
+      {
+        if (left.IsNaN() || right.IsNaN())
+          return NaN;
+        try
+        {
+          checked
+          {
+            // this will discard any fractional places...
+            Int64 quotient = (Int64)(left / right);
+            Fraction whole = new Fraction(quotient * right.m_Numerator, right.m_Denominator);
+            return left - whole;
+          }
+        }
+        catch (Exception e)
+        {
+          throw new FractionException("Modulus error", e);
+        }
+      }
+      /// <summary>
+      /// Computes the greatest common divisor for two values
+      /// </summary>
+      /// <param name="left">One value</param>
+      /// <param name="right">Another value</param>
+      /// <returns>The greatest common divisor of the two values</returns>
+      /// <example>(6, 9) returns 3 and (11, 4) returns 1</example>
+      private static long GCD(long left, long right)
+      {
+        // take absolute values
+        if (left < 0)
+          left = - left;
+        if (right < 0)
+          right = - right;
+        // if we're dealing with any zero or one, the GCD is 1
+        if (left < 2 || right < 2)
+          return 1;
+        do
+        {
+          if (left < right)
+          {
+            long temp = left;  // swap the two operands
+            left = right;
+            right = temp;
+          }
+          left %= right;
+        } while (left != 0);
+        return right;
+      }
+      #endregion
+      #region Indeterminate helpers
+      /// <summary>
+      /// Gives the culture-related representation of the indeterminate types NaN, PositiveInfinity
+      /// and NegativeInfinity
+      /// </summary>
+      /// <param name="numerator">The value in the numerator</param>
+      /// <returns>The culture-specific string representation of the implied value</returns>
+      /// <remarks>Only the sign and zero/non-zero information is relevant.</remarks>
+      private static string IndeterminateTypeName(long numerator)
+      {
+        // could also be NumberFormatInfo.InvariantInfo
+        System.Globalization.NumberFormatInfo info = NumberFormatInfo.CurrentInfo;
+        switch (NormalizeIndeterminate(numerator))
+        {
+          case Indeterminates.PositiveInfinity:
+            return info.PositiveInfinitySymbol;
+          case Indeterminates.NegativeInfinity:
+            return info.NegativeInfinitySymbol;
+          default:    // if this happens, something VERY wrong is going on...
+          case Indeterminates.NaN:
+            return info.NaNSymbol;
+        }
+      }
+      /// <summary>
+      /// Gives the normalize representation of the indeterminate types NaN, PositiveInfinity
+      /// and NegativeInfinity
+      /// </summary>
+      /// <param name="numerator">The value in the numerator</param>
+      /// <returns>The normalized version of the indeterminate type</returns>
+      /// <remarks>Only the sign and zero/non-zero information is relevant.</remarks>
+      private static Indeterminates NormalizeIndeterminate(long numerator)
+      {
+        switch (Math.Sign(numerator))
+        {
+          case 1:
+            return Indeterminates.PositiveInfinity;
+          case -1:
+            return Indeterminates.NegativeInfinity;
+          default:    // if this happens, your Math.Sign function is BROKEN!
+          case 0:
+            return Indeterminates.NaN;
+        }
+      }
+      // These are used to represent the indeterminate with a Denominator of zero
+      private enum Indeterminates
+      {
+        NaN = 0
+        , PositiveInfinity = 1
+        , NegativeInfinity = -1
+      }
+      #endregion
+      #region Member variables
+      private long m_Numerator;
+      private long m_Denominator;
+      #endregion
+      #endregion
+    }   //end class Fraction
+    /// <summary>
+    /// Exception class for Fraction, derived from System.Exception
+    /// </summary>
+    public class FractionException : Exception
+    {
+      /// <summary>
+      /// Constructs a FractionException
+      /// </summary>
+      /// <param name="Message">String associated with the error message</param>
+      /// <param name="InnerException">Actual inner exception caught</param>
+      public FractionException(string Message, Exception InnerException) : base(Message, InnerException)
+      {
+      }
+    }   //end class FractionException
+  }   //end namespace Mehroz
+/*
+* Author: Syed Mehroz Alam
+* Email: smehrozalam@yahoo.com
+* URL: Programming Home "http://www.geocities.com/smehrozalam/"
+*
+*/
+using System;
+using System.Globalization;
+using System.Runtime.InteropServices;
+namespace HeuristicLab.Analysis.AlgorithmBehavior.Analyzers {
+  /// <summary>
+  /// Classes Contained:
+  ///     Fraction
+  ///     FractionException
+  /// </summary>
+  /// Class name: Fraction
+  /// Developed by: Syed Mehroz Alam
+  /// Email: mailto:smehrozalam@yahoo.com
+  /// URL: http://www.geocities.com/smehrozalam/
+  /// Changes: Marc C. Brooks  mailto:IDisposable@gmail.com
+  ///          Jeffery Sax    http://www.extremeoptimization.com
+  /// Version: 2.2
+  ///
+  /// What's new in version 2.0:
+  ///     *   Changed Numerator and Denominator from Int32(integer) to Int64(long) for increased range
+  ///     *   renamed ConvertToString() to (overloaded) ToString()
+  ///     *   added the capability of detecting/raising overflow exceptions
+  ///     *   Fixed the bug that very small numbers e.g. 0.00000001 could not be converted to fraction
+  ///     *   Other minor bugs fixed
+  ///
+  /// What's new in version 2.1
+  ///     *   overloaded user-defined conversions to/from Fractions
+  ///
+  /// What's new in version 2.2 - Marc C. Brooks   mailto:IDisposable@gmail.com
+  ///     *   less overflows by finding the GCD for Add [Jeffery Sax] and Multiply [Marc C. Brooks]
+  ///     *   understands and handles NaN, PositiveInfinity, NegativeInfinity just like double [Marc C. Brooks]
+  ///     *   fixed several uses of int where long was correct [Marc C. Brooks]
+  ///     *   made value-type (struct) [Jeffery Sax]
+  ///     *   added ToInt32(), ToInt64() which throw for invalid (NaN, PositiveInfinity, NegativeInfinity) [Marc C. Brooks]
+  ///     *   removed redundant Value property [Jeffery Sax]
+  ///     *   added explicit conversion to Int32 and Int64 [Marc C. Brooks]
+  ///     *   better handling of exceptions [Marc C. Brooks]
+  ///     *   reorganize code, add XML doc and regions [Marc C. Brooks]
+  ///     *   proper implementations of Equals [Marc C. Brooks, Jeffery Sax]
+  ///     *   uses Math.Log(xx,2) and Math.Pow(xx,2) to get the best accuracy possible when converting doubles [Marc C. Brooks, Jeffery Sax]
+  ///
+  /// What's new in version 2.3 - Marc C. Brooks   mailto:IDisposable@gmail.com   01/10/2005
+  ///     *   fixed double-to-fraction logic to use continued fraction rules to get best possible precistion [bug fix for Syed Mehroz Alam, idea from  Jeffery Sax]
+  ///     * added static readonly values for NaN, PositiveInfinity, NegativeInfinity [idea from Jeffery Sax]
+  ///     * moved comparisons into an implementation of IComparer [idea from Jeffery Sax]
+  ///     * no longer throws for NaN(s) involved in Add, Subtract, Multiply, Divide operations [idea from Jeffery Sax]
+  ///     *   added static readonly values for Zero, MinValue, MaxValue, Epsilon to better mirror double
+  ///     *   added IsInfinity to better mirror double.
+  ///     *   added Modulus and % operators
+  ///
+  /// Properties:
+  ///     Numerator: Set/Get value for Numerator
+  ///     Denominator:  Set/Get value for Numerator
+  ///     [Note: If you Set either Property, the Fraction should be passed to ReduceFraction at some point.]
+  ///
+  /// Constructors:
+  ///     no arguments:   initializes fraction as 0/0 = NaN, so don't do that!
+  ///     (Numerator, Denominator): initializes fraction with the given numerator and denominator
+  ///                               values and reduces
+  ///     (long): initializes fraction with the given long value
+  ///     (double):   initializes fraction with the given double value
+  ///     (string):   initializes fraction with the given string value
+  ///                 the string can be an in the form of and integer, double or fraction.
+  ///                 e.g it can be like "123" or "123.321" or "123/456"
+  ///
+  /// Public Methods (Description is given with respective methods' definitions)
+  ///     Fraction ToFraction(long)
+  ///     Fraction ToFraction(double)
+  ///     Fraction ToFraction(string)
+  ///     Int32 ToInt32()
+  ///     Int64 ToInt64()
+  ///     double ToDouble()
+  ///     (override) string ToString()
+  ///     Fraction Inverse()
+  ///     Fraction Inverted(long)
+  ///     Fraction Inverted(double)
+  ///     ReduceFraction(ref Fraction)
+  ///     CrossReducePair(ref Fraction, ref Fraction)
+  ///     (override) Equals(object)
+  ///     (override) GetHashCode()
+  ///
+  /// Overloaded Operators (overloaded for Fractions, long and double)
+  ///     Unary: -
+  ///     Binary: +,-,*,/
+  ///     Relational and Logical Operators: ==,!=,<,>,<=,>= (only == and != for long and doubles)
+  ///
+  /// Overloaded user-defined conversions
+  ///     Implicit:   From long/double/string to Fraction
+  ///     Explicit:   From Fraction to long/double/string
+  /// </summary>
+  [Serializable, StructLayout(LayoutKind.Sequential)]
+  public struct Fraction : IComparable, IFormattable {
+    #region Constructors
+    /// <summary>
+    /// Construct a Fraction from an integral value
+    /// </summary>
+    /// <param name="wholeNumber">The value (eventual numerator)</param>
+    /// <remarks>The denominator will be 1</remarks>
+    public Fraction(long wholeNumber) {
+      if (wholeNumber == long.MinValue)
+        wholeNumber++;  // prevent serious issues later..
+      m_Numerator = wholeNumber;
+      m_Denominator = 1;
+      // no reducing required, we're a whole number
+    }
+    /// <summary>
+    /// Construct a Fraction from a floating-point value
+    /// </summary>
+    /// <param name="floatingPointNumber">The value</param>
+    public Fraction(double floatingPointNumber) {
+      this = ToFraction(floatingPointNumber);
+    }
+    /// <summary>
+    /// Construct a Fraction from a string in any legal format
+    /// </summary>
+    /// <param name="inValue">A string with a legal fraction input format</param>
+    /// <remarks>Will reduce the fraction to smallest possible denominator</remarks>
+    /// <see>ToFraction(string strValue)</see>
+    public Fraction(string inValue) {
+      this = ToFraction(inValue);
+    }
+    /// <summary>
+    /// Construct a Fraction from a numerator, denominator pair
+    /// </summary>
+    /// <param name="numerator">The numerator (top number)</param>
+    /// <param name="denominator">The denominator (bottom number)</param>
+    /// <remarks>Will reduce the fraction to smallest possible denominator</remarks>
+    public Fraction(long numerator, long denominator) {
+      if (numerator == long.MinValue)
+        numerator++;  // prevent serious issues later..
+      if (denominator == long.MinValue)
+        denominator++;  // prevent serious issues later..
+      m_Numerator = numerator;
+      m_Denominator = denominator;
+      ReduceFraction(ref this);
+    }
+    /// <summary>
+    /// Private constructor to synthesize a Fraction for indeterminates (NaN and infinites)
+    /// </summary>
+    /// <param name="type">Kind of inderterminate</param>
+    private Fraction(Indeterminates type) {
+      m_Numerator = (long)type;
+      m_Denominator = 0;
+      // do NOT reduce, we're clean as can be!
+    }
+    #endregion
+    #region Properties
+    /// <summary>
+    /// The 'top' part of the fraction
+    /// </summary>
+    /// <example>For 3/4ths, this is the 3</example>
+    public long Numerator {
+      get {
+        return m_Numerator;
+      }
+      set {
+        m_Numerator = value;
+      }
+    }
+    /// <summary>
+    /// The 'bottom' part of the fraction
+    /// </summary>
+    /// <example>For 3/4ths, this is the 4</example>
+    public long Denominator {
+      get {
+        return m_Denominator;
+      }
+      set {
+        m_Denominator = value;
+      }
+    }
+    #endregion
+    #region Expose constants
+    public static readonly Fraction NaN = new Fraction(Indeterminates.NaN);
+    public static readonly Fraction PositiveInfinity = new Fraction(Indeterminates.PositiveInfinity);
+    public static readonly Fraction NegativeInfinity = new Fraction(Indeterminates.NegativeInfinity);
+    public static readonly Fraction Zero = new Fraction(0, 1);
+    public static readonly Fraction Epsilon = new Fraction(1, Int64.MaxValue);
+    private static readonly double EpsilonDouble = 1.0 / Int64.MaxValue;
+    public static readonly Fraction MaxValue = new Fraction(Int64.MaxValue, 1);
+    public static readonly Fraction MinValue = new Fraction(Int64.MinValue, 1);
+    #endregion
+    #region Explicit conversions
+    #region To primitives
+    /// <summary>
+    /// Get the integral value of the Fraction object as int/Int32
+    /// </summary>
+    /// <returns>The (approximate) integer value</returns>
+    /// <remarks>If the value is not a true integer, the fractional part is discarded
+    /// (truncated toward zero). If the valid exceeds the range of an Int32 and exception is thrown.</remarks>
+    /// <exception cref="FractionException">Will throw a FractionException for NaN, PositiveInfinity
+    /// or NegativeInfinity with the InnerException set to a System.NotFiniteNumberException.</exception>
+    /// <exception cref="OverflowException" Will throw a System.OverflowException if the value is too
+    /// large or small to be represented as an Int32.</exception>
+    public Int32 ToInt32() {
+      if (this.m_Denominator == 0) {
+        throw new FractionException(string.Format("Cannot convert {0} to Int32", IndeterminateTypeName(this.m_Numerator)), new System.NotFiniteNumberException());
+      }
+      long bestGuess = this.m_Numerator / this.m_Denominator;
+      if (bestGuess > Int32.MaxValue || bestGuess < Int32.MinValue) {
+        throw new FractionException("Cannot convert to Int32", new System.OverflowException());
+      }
+      return (Int32)bestGuess;
+    }
+    /// <summary>
+    /// Get the integral value of the Fraction object as long/Int64
+    /// </summary>
+    /// <returns>The (approximate) integer value</returns>
+    /// <remarks>If the value is not a true integer, the fractional part is discarded
+    /// (truncated toward zero). If the valid exceeds the range of an Int32, no special
+    /// handling is guaranteed.</remarks>
+    /// <exception cref="FractionException">Will throw a FractionException for NaN, PositiveInfinity
+    /// or NegativeInfinity with the InnerException set to a System.NotFiniteNumberException.</exception>
+    public Int64 ToInt64() {
+      if (this.m_Denominator == 0) {
+        throw new FractionException(string.Format("Cannot convert {0} to Int64", IndeterminateTypeName(this.m_Numerator)), new System.NotFiniteNumberException());
+      }
+      return this.m_Numerator / this.m_Denominator;
+    }
+    /// <summary>
+    /// Get the value of the Fraction object as double with full support for NaNs and infinities
+    /// </summary>
+    /// <returns>The decimal representation of the Fraction, or double.NaN, double.NegativeInfinity
+    /// or double.PositiveInfinity</returns>
+    public double ToDouble() {
+      if (this.m_Denominator == 1)
+        return this.m_Numerator;
+      else if (this.m_Denominator == 0) {
+        switch (NormalizeIndeterminate(this.m_Numerator)) {
+          case Indeterminates.NegativeInfinity:
+            return double.NegativeInfinity;
+          case Indeterminates.PositiveInfinity:
+            return double.PositiveInfinity;
+          case Indeterminates.NaN:
+          default:    // this can't happen
+            return double.NaN;
+        }
+      } else {
+        return (double)this.m_Numerator / (double)this.m_Denominator;
+      }
+    }
+    /// <summary>
+    /// Get the value of the Fraction as a string, with proper representation for NaNs and infinites
+    /// </summary>
+    /// <returns>The string representation of the Fraction, or the culture-specific representations of
+    /// NaN, PositiveInfinity or NegativeInfinity.</returns>
+    /// <remarks>The current culture determines the textual representation the Indeterminates</remarks>
+    public override string ToString() {
+      if (this.m_Denominator == 1) {
+        return this.m_Numerator.ToString();
+      } else if (this.m_Denominator == 0) {
+        return IndeterminateTypeName(this.m_Numerator);
+      } else {
+        return this.m_Numerator.ToString() + "/" + this.m_Denominator.ToString();
+      }
+    }
+    #endregion
+    #region From primitives
+    /// <summary>
+    /// Converts a long value to the exact Fraction
+    /// </summary>
+    /// <param name="inValue">The long to convert</param>
+    /// <returns>An exact representation of the value</returns>
+    public static Fraction ToFraction(long inValue) {
+      return new Fraction(inValue);
+    }
+    /// <summary>
+    /// Converts a double value to the approximate Fraction
+    /// </summary>
+    /// <param name="inValue">The double to convert</param>
+    /// <returns>A best-fit representation of the value</returns>
+    /// <remarks>Supports double.NaN, double.PositiveInfinity and double.NegativeInfinity</remarks>
+    public static Fraction ToFraction(double inValue) {
+      // it's one of the indeterminates... which?
+      if (double.IsNaN(inValue))
+        return NaN;
+      else if (double.IsNegativeInfinity(inValue))
+        return NegativeInfinity;
+      else if (double.IsPositiveInfinity(inValue))
+        return PositiveInfinity;
+      else if (inValue == 0.0d)
+        return Zero;
+      if (inValue > Int64.MaxValue)
+        throw new OverflowException(string.Format("Double {0} too large", inValue));
+      if (inValue < -Int64.MaxValue)
+        throw new OverflowException(string.Format("Double {0} too small", inValue));
+      if (-EpsilonDouble < inValue && inValue < EpsilonDouble)
+        throw new ArithmeticException(string.Format("Double {0} cannot be represented", inValue));
+      int sign = Math.Sign(inValue);
+      inValue = Math.Abs(inValue);
+      return ConvertPositiveDouble(sign, inValue);
+    }
+    /// <summary>
+    /// Converts a string to the corresponding reduced fraction
+    /// </summary>
+    /// <param name="inValue">The string representation of a fractional value</param>
+    /// <returns>The Fraction that represents the string</returns>
+    /// <remarks>Four forms are supported, as a plain integer, as a double, or as Numerator/Denominator
+    /// and the representations for NaN and the infinites</remarks>
+    /// <example>"123" = 123/1 and "1.25" = 5/4 and "10/36" = 5/13 and NaN = 0/0 and
+    /// PositiveInfinity = 1/0 and NegativeInfinity = -1/0</example>
+    public static Fraction ToFraction(string inValue) {
+      if (inValue == null || inValue == string.Empty)
+        throw new ArgumentNullException("inValue");
+      // could also be NumberFormatInfo.InvariantInfo
+      NumberFormatInfo info = NumberFormatInfo.CurrentInfo;
+      // Is it one of the special symbols for NaN and such...
+      string trimmedValue = inValue.Trim();
+      if (trimmedValue == info.NaNSymbol)
+        return NaN;
+      else if (trimmedValue == info.PositiveInfinitySymbol)
+        return PositiveInfinity;
+      else if (trimmedValue == info.NegativeInfinitySymbol)
+        return NegativeInfinity;
+      else {
+        // Not special, is it a Fraction?
+        int slashPos = inValue.IndexOf('/');
+        if (slashPos > -1) {
+          // string is in the form of Numerator/Denominator
+          long numerator = Convert.ToInt64(inValue.Substring(0, slashPos));
+          long denominator = Convert.ToInt64(inValue.Substring(slashPos + 1));
+          return new Fraction(numerator, denominator);
+        } else {
+          // the string is not in the form of a fraction
+          // hopefully it is double or integer, do we see a decimal point?
+          int decimalPos = inValue.IndexOf(info.CurrencyDecimalSeparator);
+          if (decimalPos > -1)
+            return new Fraction(Convert.ToDouble(inValue));
+          else
+            return new Fraction(Convert.ToInt64(inValue));
+        }
+      }
+    }
+    #endregion
+    #endregion
+    #region Indeterminate classifications
+    /// <summary>
+    /// Determines if a Fraction represents a Not-a-Number
+    /// </summary>
+    /// <returns>True if the Fraction is a NaN</returns>
+    public bool IsNaN() {
+      if (this.m_Denominator == 0
+        && NormalizeIndeterminate(this.m_Numerator) == Indeterminates.NaN)
+        return true;
+      else
+        return false;
+    }
+    /// <summary>
+    /// Determines if a Fraction represents Any Infinity
+    /// </summary>
+    /// <returns>True if the Fraction is Positive Infinity or Negative Infinity</returns>
+    public bool IsInfinity() {
+      if (this.m_Denominator == 0
+        && NormalizeIndeterminate(this.m_Numerator) != Indeterminates.NaN)
+        return true;
+      else
+        return false;
+    }
+    /// <summary>
+    /// Determines if a Fraction represents Positive Infinity
+    /// </summary>
+    /// <returns>True if the Fraction is Positive Infinity</returns>
+    public bool IsPositiveInfinity() {
+      if (this.m_Denominator == 0
+        && NormalizeIndeterminate(this.m_Numerator) == Indeterminates.PositiveInfinity)
+        return true;
+      else
+        return false;
+    }
+    /// <summary>
+    /// Determines if a Fraction represents Negative Infinity
+    /// </summary>
+    /// <returns>True if the Fraction is Negative Infinity</returns>
+    public bool IsNegativeInfinity() {
+      if (this.m_Denominator == 0
+        && NormalizeIndeterminate(this.m_Numerator) == Indeterminates.NegativeInfinity)
+        return true;
+      else
+        return false;
+    }
+    #endregion
+    #region Inversion
+    /// <summary>
+    /// Inverts a Fraction
+    /// </summary>
+    /// <returns>The inverted Fraction (with Denominator over Numerator)</returns>
+    /// <remarks>Does NOT throw for zero Numerators as later use of the fraction will catch the error.</remarks>
+    public Fraction Inverse() {
+      // don't use the obvious constructor because we do not want it normalized at this time
+      Fraction frac = new Fraction();
+      frac.m_Numerator = this.m_Denominator;
+      frac.m_Denominator = this.m_Numerator;
+      return frac;
+    }
+    /// <summary>
+    /// Creates an inverted Fraction
+    /// </summary>
+    /// <returns>The inverted Fraction (with Denominator over Numerator)</returns>
+    /// <remarks>Does NOT throw for zero Numerators as later use of the fraction will catch the error.</remarks>
+    public static Fraction Inverted(long value) {
+      Fraction frac = new Fraction(value);
+      return frac.Inverse();
+    }
+    /// <summary>
+    /// Creates an inverted Fraction
+    /// </summary>
+    /// <returns>The inverted Fraction (with Denominator over Numerator)</returns>
+    /// <remarks>Does NOT throw for zero Numerators as later use of the fraction will catch the error.</remarks>
+    public static Fraction Inverted(double value) {
+      Fraction frac = new Fraction(value);
+      return frac.Inverse();
+    }
+    #endregion
+    #region Operators
+    #region Unary Negation operator
+    /// <summary>
+    /// Negates the Fraction
+    /// </summary>
+    /// <param name="left">The Fraction to negate</param>
+    /// <returns>The negative version of the Fraction</returns>
+    public static Fraction operator -(Fraction left) {
+      return Negate(left);
+    }
+    #endregion
+    #region Addition operators
+    public static Fraction operator +(Fraction left, Fraction right) {
+      return Add(left, right);
+    }
+    public static Fraction operator +(long left, Fraction right) {
+      return Add(new Fraction(left), right);
+    }
+    public static Fraction operator +(Fraction left, long right) {
+      return Add(left, new Fraction(right));
+    }
+    public static Fraction operator +(double left, Fraction right) {
+      return Add(ToFraction(left), right);
+    }
+    public static Fraction operator +(Fraction left, double right) {
+      return Add(left, ToFraction(right));
+    }
+    #endregion
+    #region Subtraction operators
+    public static Fraction operator -(Fraction left, Fraction right) {
+      return Add(left, -right);
+    }
+    public static Fraction operator -(long left, Fraction right) {
+      return Add(new Fraction(left), -right);
+    }
+    public static Fraction operator -(Fraction left, long right) {
+      return Add(left, new Fraction(-right));
+    }
+    public static Fraction operator -(double left, Fraction right) {
+      return Add(ToFraction(left), -right);
+    }
+    public static Fraction operator -(Fraction left, double right) {
+      return Add(left, ToFraction(-right));
+    }
+    #endregion
+    #region Multiplication operators
+    public static Fraction operator *(Fraction left, Fraction right) {
+      return Multiply(left, right);
+    }
+    public static Fraction operator *(long left, Fraction right) {
+      return Multiply(new Fraction(left), right);
+    }
+    public static Fraction operator *(Fraction left, long right) {
+      return Multiply(left, new Fraction(right));
+    }
+    public static Fraction operator *(double left, Fraction right) {
+      return Multiply(ToFraction(left), right);
+    }
+    public static Fraction operator *(Fraction left, double right) {
+      return Multiply(left, ToFraction(right));
+    }
+    #endregion
+    #region Division operators
+    public static Fraction operator /(Fraction left, Fraction right) {
+      return Multiply(left, right.Inverse());
+    }
+    public static Fraction operator /(long left, Fraction right) {
+      return Multiply(new Fraction(left), right.Inverse());
+    }
+    public static Fraction operator /(Fraction left, long right) {
+      return Multiply(left, Inverted(right));
+    }
+    public static Fraction operator /(double left, Fraction right) {
+      return Multiply(ToFraction(left), right.Inverse());
+    }
+    public static Fraction operator /(Fraction left, double right) {
+      return Multiply(left, Inverted(right));
+    }
+    #endregion
+    #region Modulus operators
+    public static Fraction operator %(Fraction left, Fraction right) {
+      return Modulus(left, right);
+    }
+    public static Fraction operator %(long left, Fraction right) {
+      return Modulus(new Fraction(left), right);
+    }
+    public static Fraction operator %(Fraction left, long right) {
+      return Modulus(left, right);
+    }
+    public static Fraction operator %(double left, Fraction right) {
+      return Modulus(ToFraction(left), right);
+    }
+    public static Fraction operator %(Fraction left, double right) {
+      return Modulus(left, right);
+    }
+    #endregion
+    #region Equal operators
+    public static bool operator ==(Fraction left, Fraction right) {
+      return left.CompareEquality(right, false);
+    }
+    public static bool operator ==(Fraction left, long right) {
+      return left.CompareEquality(new Fraction(right), false);
+    }
+    public static bool operator ==(Fraction left, double right) {
+      return left.CompareEquality(new Fraction(right), false);
+    }
+    #endregion
+    #region Not-equal operators
+    public static bool operator !=(Fraction left, Fraction right) {
+      return left.CompareEquality(right, true);
+    }
+    public static bool operator !=(Fraction left, long right) {
+      return left.CompareEquality(new Fraction(right), true);
+    }
+    public static bool operator !=(Fraction left, double right) {
+      return left.CompareEquality(new Fraction(right), true);
+    }
+    #endregion
+    #region Inequality operators
+    /// <summary>
+    /// Compares two Fractions to see if left is less than right
+    /// </summary>
+    /// <param name="left">The first Fraction</param>
+    /// <param name="right">The second Fraction</param>
+    /// <returns>True if <paramref name="left">left</paramref> is less
+    /// than <paramref name="right">right</paramref></returns>
+    /// <remarks>Special handling for indeterminates exists. <see>IndeterminateLess</see></remarks>
+    /// <exception cref="FractionException">Throws an error if overflows occur while computing the
+    /// difference with an InnerException of OverflowException</exception>
+    public static bool operator <(Fraction left, Fraction right) {
+      return left.CompareTo(right) < 0;
+    }
+    /// <summary>
+    /// Compares two Fractions to see if left is greater than right
+    /// </summary>
+    /// <param name="left">The first Fraction</param>
+    /// <param name="right">The second Fraction</param>
+    /// <returns>True if <paramref name="left">left</paramref> is greater
+    /// than <paramref name="right">right</paramref></returns>
+    /// <remarks>Special handling for indeterminates exists. <see>IndeterminateLess</see></remarks>
+    /// <exception cref="FractionException">Throws an error if overflows occur while computing the
+    /// difference with an InnerException of OverflowException</exception>
+    public static bool operator >(Fraction left, Fraction right) {
+      return left.CompareTo(right) > 0;
+    }
+    /// <summary>
+    /// Compares two Fractions to see if left is less than or equal to right
+    /// </summary>
+    /// <param name="left">The first Fraction</param>
+    /// <param name="right">The second Fraction</param>
+    /// <returns>True if <paramref name="left">left</paramref> is less than or
+    /// equal to <paramref name="right">right</paramref></returns>
+    /// <remarks>Special handling for indeterminates exists. <see>IndeterminateLessEqual</see></remarks>
+    /// <exception cref="FractionException">Throws an error if overflows occur while computing the
+    /// difference with an InnerException of OverflowException</exception>
+    public static bool operator <=(Fraction left, Fraction right) {
+      return left.CompareTo(right) <= 0;
+    }
+    /// <summary>
+    /// Compares two Fractions to see if left is greater than or equal to right
+    /// </summary>
+    /// <param name="left">The first Fraction</param>
+    /// <param name="right">The second Fraction</param>
+    /// <returns>True if <paramref name="left">left</paramref> is greater than or
+    /// equal to <paramref name="right">right</paramref></returns>
+    /// <remarks>Special handling for indeterminates exists. <see>IndeterminateLessEqual</see></remarks>
+    /// <exception cref="FractionException">Throws an error if overflows occur while computing the
+    /// difference with an InnerException of OverflowException</exception>
+    public static bool operator >=(Fraction left, Fraction right) {
+      return left.CompareTo(right) >= 0;
+    }
+    #endregion
+    #region Implict conversion from primitive operators
+    /// <summary>
+    /// Implicit conversion of a long integral value to a Fraction
+    /// </summary>
+    /// <param name="value">The long integral value to convert</param>
+    /// <returns>A Fraction whose denominator is 1</returns>
+    public static implicit operator Fraction(long value) {
+      return new Fraction(value);
+    }
+    /// <summary>
+    /// Implicit conversion of a double floating point value to a Fraction
+    /// </summary>
+    /// <param name="value">The double value to convert</param>
+    /// <returns>A reduced Fraction</returns>
+    public static implicit operator Fraction(double value) {
+      return new Fraction(value);
+    }
+    /// <summary>
+    /// Implicit conversion of a string to a Fraction
+    /// </summary>
+    /// <param name="value">The string to convert</param>
+    /// <returns>A reduced Fraction</returns>
+    public static implicit operator Fraction(string value) {
+      return new Fraction(value);
+    }
+    #endregion
+    #region Explicit converstion to primitive operators
+    /// <summary>
+    /// Explicit conversion from a Fraction to an integer
+    /// </summary>
+    /// <param name="frac">the Fraction to convert</param>
+    /// <returns>The integral representation of the Fraction</returns>
+    public static explicit operator int(Fraction frac) {
+      return frac.ToInt32();
+    }
+    /// <summary>
+    /// Explicit conversion from a Fraction to an integer
+    /// </summary>
+    /// <param name="frac">The Fraction to convert</param>
+    /// <returns>The integral representation of the Fraction</returns>
+    public static explicit operator long(Fraction frac) {
+      return frac.ToInt64();
+    }
+    /// <summary>
+    /// Explicit conversion from a Fraction to a double floating-point value
+    /// </summary>
+    /// <param name="frac">The Fraction to convert</param>
+    /// <returns>The double representation of the Fraction</returns>
+    public static explicit operator double(Fraction frac) {
+      return frac.ToDouble();
+    }
+    /// <summary>
+    /// Explicit conversion from a Fraction to a string
+    /// </summary>
+    /// <param name="frac">the Fraction to convert</param>
+    /// <returns>The string representation of the Fraction</returns>
+    public static implicit operator string(Fraction frac) {
+      return frac.ToString();
+    }
+    #endregion
+    #endregion
+    #region Equals and GetHashCode overrides
+    /// <summary>
+    /// Compares for equality the current Fraction to the value passed.
+    /// </summary>
+    /// <param name="obj">A  Fraction,</param>
+    /// <returns>True if the value equals the current fraction, false otherwise (including for
+    /// non-Fraction types or null object.</returns>
+    public override bool Equals(object obj) {
+      if (obj == null || !(obj is Fraction))
+        return false;
+      try {
+        Fraction right = (Fraction)obj;
+        return this.CompareEquality(right, false);
+      }
+      catch {
+        // can't throw in an Equals!
+        return false;
+      }
+    }
+    /// <summary>
+    /// Returns a hash code generated from the current Fraction
+    /// </summary>
+    /// <returns>The hash code</returns>
+    /// <remarks>Reduces (in-place) the Fraction first.</remarks>
+    public override int GetHashCode() {
+      // insure we're as close to normalized as possible first
+      ReduceFraction(ref this);
+      int numeratorHash = this.m_Numerator.GetHashCode();
+      int denominatorHash = this.m_Denominator.GetHashCode();
+      return (numeratorHash ^ denominatorHash);
+    }
+    #endregion
+    #region IComparable member and type-specific version
+    /// <summary>
+    /// Compares an object to this Fraction
+    /// </summary>
+    /// <param name="obj">The object to compare against (null is less than everything)</param>
+    /// <returns>-1 if this is less than <paramref name="obj"></paramref>,
+    ///  0 if they are equal,
+    ///  1 if this is greater than <paramref name="obj"></paramref></returns>
+    /// <remarks>Will convert an object from longs, doubles, and strings as this is a value-type.</remarks>
+    public int CompareTo(object obj) {
+      if (obj == null)
+        return 1; // null is less than anything
+      Fraction right;
+      if (obj is Fraction)
+        right = (Fraction)obj;
+      else if (obj is long)
+        right = (long)obj;
+      else if (obj is double)
+        right = (double)obj;
+      else if (obj is string)
+        right = (string)obj;
+      else
+        throw new ArgumentException("Must be convertible to Fraction", "obj");
+      return this.CompareTo(right);
+    }
+    /// <summary>
+    /// Compares this Fraction to another Fraction
+    /// </summary>
+    /// <param name="right">The Fraction to compare against</param>
+    /// <returns>-1 if this is less than <paramref name="right"></paramref>,
+    ///  0 if they are equal,
+    ///  1 if this is greater than <paramref name="right"></paramref></returns>
+    public int CompareTo(Fraction right) {
+      // if left is an indeterminate, punt to the helper...
+      if (this.m_Denominator == 0) {
+        return IndeterminantCompare(NormalizeIndeterminate(this.m_Numerator), right);
+      }
+      // if right is an indeterminate, punt to the helper...
+      if (right.m_Denominator == 0) {
+        // note sign-flip...
+        return -IndeterminantCompare(NormalizeIndeterminate(right.m_Numerator), this);
+      }
+      // they're both normal Fractions
+      CrossReducePair(ref this, ref right);
+      try {
+        checked {
+          long leftScale = this.m_Numerator * right.m_Denominator;
+          long rightScale = this.m_Denominator * right.m_Numerator;
+          if (leftScale < rightScale)
+            return -1;
+          else if (leftScale > rightScale)
+            return 1;
+          else
+            return 0;
+        }
+      }
+      catch (Exception e) {
+        throw new FractionException(string.Format("CompareTo({0}, {1}) error", this, right), e);
+      }
+    }
+    #endregion
+    #region IFormattable Members
+    string System.IFormattable.ToString(string format, IFormatProvider formatProvider) {
+      return this.m_Numerator.ToString(format, formatProvider) + "/" + this.m_Denominator.ToString(format, formatProvider);
+    }
+    #endregion
+    #region Reduction
+    /// <summary>
+    /// Reduces (simplifies) a Fraction by dividing down to lowest possible denominator (via GCD)
+    /// </summary>
+    /// <param name="frac">The Fraction to be reduced [WILL BE MODIFIED IN PLACE]</param>
+    /// <remarks>Modifies the input arguments in-place! Will normalize the NaN and infinites
+    /// representation. Will set Denominator to 1 for any zero numerator. Moves sign to the
+    /// Numerator.</remarks>
+    /// <example>2/4 will be reduced to 1/2</example>
+    public static void ReduceFraction(ref Fraction frac) {
+      // clean up the NaNs and infinites
+      if (frac.m_Denominator == 0) {
+        frac.m_Numerator = (long)NormalizeIndeterminate(frac.m_Numerator);
+        return;
+      }
+      // all forms of zero are alike.
+      if (frac.m_Numerator == 0) {
+        frac.m_Denominator = 1;
+        return;
+      }
+      long iGCD = GCD(frac.m_Numerator, frac.m_Denominator);
+      frac.m_Numerator /= iGCD;
+      frac.m_Denominator /= iGCD;
+      // if negative sign in denominator
+      if (frac.m_Denominator < 0) {
+        //move negative sign to numerator
+        frac.m_Numerator = -frac.m_Numerator;
+        frac.m_Denominator = -frac.m_Denominator;
+      }
+    }
+    /// <summary>
+    /// Cross-reduces a pair of Fractions so that we have the best GCD-reduced values for multiplication
+    /// </summary>
+    /// <param name="frac1">The first Fraction [WILL BE MODIFIED IN PLACE]</param>
+    /// <param name="frac2">The second Fraction [WILL BE MODIFIED IN PLACE]</param>
+    /// <remarks>Modifies the input arguments in-place!</remarks>
+    /// <example>(3/4, 5/9) = (1/4, 5/3)</example>
+    public static void CrossReducePair(ref Fraction frac1, ref Fraction frac2) {
+      // leave the indeterminates alone!
+      if (frac1.m_Denominator == 0 || frac2.m_Denominator == 0)
+        return;
+      long gcdTop = GCD(frac1.m_Numerator, frac2.m_Denominator);
+      frac1.m_Numerator = frac1.m_Numerator / gcdTop;
+      frac2.m_Denominator = frac2.m_Denominator / gcdTop;
+      long gcdBottom = GCD(frac1.m_Denominator, frac2.m_Numerator);
+      frac2.m_Numerator = frac2.m_Numerator / gcdBottom;
+      frac1.m_Denominator = frac1.m_Denominator / gcdBottom;
+    }
+    #endregion
+    #region Implementation
+    #region Convert a double to a fraction
+    private static Fraction ConvertPositiveDouble(int sign, double inValue) {
+      // Shamelessly stolen from http://homepage.smc.edu/kennedy_john/CONFRAC.PDF
+      // with AccuracyFactor == double.Episilon
+      long fractionNumerator = (long)inValue;
+      double fractionDenominator = 1;
+      double previousDenominator = 0;
+      double remainingDigits = inValue;
+      int maxIterations = 594;  // found at http://www.ozgrid.com/forum/archive/index.php/t-22530.html
+      while (remainingDigits != Math.Floor(remainingDigits)
+        && Math.Abs(inValue - (fractionNumerator / fractionDenominator)) > double.Epsilon) {
+        remainingDigits = 1.0 / (remainingDigits - Math.Floor(remainingDigits));
+        double scratch = fractionDenominator;
+        fractionDenominator = (Math.Floor(remainingDigits) * fractionDenominator) + previousDenominator;
+        fractionNumerator = (long)(inValue * fractionDenominator + 0.5);
+        previousDenominator = scratch;
+        if (maxIterations-- < 0)
+          break;
+      }
+      return new Fraction(fractionNumerator * sign, (long)fractionDenominator);
+    }
+    #endregion
+    #region Equality helper
+    /// <summary>
+    /// Compares for equality the current Fraction to the value passed.
+    /// </summary>
+    /// <param name="right">A Fraction to compare against</param>
+    /// <param name="notEqualCheck">If true, we're looking for not-equal</param>
+    /// <returns>True if the <paramref name="right"></paramref> equals the current
+    /// fraction, false otherwise. If comparing two NaNs, they are always equal AND
+    /// not-equal.</returns>
+    private bool CompareEquality(Fraction right, bool notEqualCheck) {
+      // insure we're normalized first
+      ReduceFraction(ref this);
+      // now normalize the comperand
+      ReduceFraction(ref right);
+      if (this.m_Numerator == right.m_Numerator && this.m_Denominator == right.m_Denominator) {
+        // special-case rule, two NaNs are always both equal
+        if (notEqualCheck && this.IsNaN())
+          return true;
+        else
+          return !notEqualCheck;
+      } else {
+        return notEqualCheck;
+      }
+    }
+    #endregion
+    #region Comparison helper
+    /// <summary>
+    /// Determines how this Fraction, of an indeterminate type, compares to another Fraction
+    /// </summary>
+    /// <param name="leftType">What kind of indeterminate</param>
+    /// <param name="right">The other Fraction to compare against</param>
+    /// <returns>-1 if this is less than <paramref name="right"></paramref>,
+    ///  0 if they are equal,
+    ///  1 if this is greater than <paramref name="right"></paramref></returns>
+    /// <remarks>NaN is less than anything except NaN and Negative Infinity. Negative Infinity is less
+    /// than anything except Negative Infinity. Positive Infinity is greater than anything except
+    /// Positive Infinity.</remarks>
+    private static int IndeterminantCompare(Indeterminates leftType, Fraction right) {
+      switch (leftType) {
+        case Indeterminates.NaN:
+          // A NaN is...
+          if (right.IsNaN())
+            return 0; // equal to a NaN
+          else if (right.IsNegativeInfinity())
+            return 1; // great than Negative Infinity
+          else
+            return -1;  // less than anything else
+        case Indeterminates.NegativeInfinity:
+          // Negative Infinity is...
+          if (right.IsNegativeInfinity())
+            return 0; // equal to Negative Infinity
+          else
+            return -1;  // less than anything else
+        case Indeterminates.PositiveInfinity:
+          if (right.IsPositiveInfinity())
+            return 0; // equal to Positive Infinity
+          else
+            return 1; // greater than anything else
+        default:
+          // this CAN'T happen, something VERY wrong is going on...
+          return 0;
+      }
+    }
+    #endregion
+    #region Math helpers
+    /// <summary>
+    /// Negates the Fraction
+    /// </summary>
+    /// <param name="frac">Value to negate</param>
+    /// <returns>A new Fraction that is sign-flipped from the input</returns>
+    private static Fraction Negate(Fraction frac) {
+      // for a NaN, it's still a NaN
+      return new Fraction(-frac.m_Numerator, frac.m_Denominator);
+    }
+    /// <summary>
+    /// Adds two Fractions
+    /// </summary>
+    /// <param name="left">A Fraction</param>
+    /// <param name="right">Another Fraction</param>
+    /// <returns>Sum of the Fractions. Returns NaN if either Fraction is a NaN.</returns>
+    /// <exception cref="FractionException">Will throw if an overflow occurs when computing the
+    /// GCD-normalized values.</exception>
+    private static Fraction Add(Fraction left, Fraction right) {
+      if (left.IsNaN() || right.IsNaN())
+        return NaN;
+      long gcd = GCD(left.m_Denominator, right.m_Denominator); // cannot return less than 1
+      long leftDenominator = left.m_Denominator / gcd;
+      long rightDenominator = right.m_Denominator / gcd;
+      try {
+        checked {
+          long numerator = left.m_Numerator * rightDenominator + right.m_Numerator * leftDenominator;
+          long denominator = leftDenominator * rightDenominator * gcd;
+          return new Fraction(numerator, denominator);
+        }
+      }
+      catch (Exception e) {
+        throw new FractionException("Add error", e);
+      }
+    }
+    /// <summary>
+    /// Multiplies two Fractions
+    /// </summary>
+    /// <param name="left">A Fraction</param>
+    /// <param name="right">Another Fraction</param>
+    /// <returns>Product of the Fractions. Returns NaN if either Fraction is a NaN.</returns>
+    /// <exception cref="FractionException">Will throw if an overflow occurs. Does a cross-reduce to
+    /// insure only the unavoidable overflows occur.</exception>
+    private static Fraction Multiply(Fraction left, Fraction right) {
+      if (left.IsNaN() || right.IsNaN())
+        return NaN;
+      // this would be unsafe if we were not a ValueType, because we would be changing the
+      // caller's values.  If we change back to a class, must use temporaries
+      CrossReducePair(ref left, ref right);
+      try {
+        checked {
+          long numerator = left.m_Numerator * right.m_Numerator;
+          long denominator = left.m_Denominator * right.m_Denominator;
+          return new Fraction(numerator, denominator);
+        }
+      }
+      catch (Exception e) {
+        throw new FractionException("Multiply error", e);
+      }
+    }
+    /// <summary>
+    /// Returns the modulus (remainder after dividing) two Fractions
+    /// </summary>
+    /// <param name="left">A Fraction</param>
+    /// <param name="right">Another Fraction</param>
+    /// <returns>Modulus of the Fractions. Returns NaN if either Fraction is a NaN.</returns>
+    /// <exception cref="FractionException">Will throw if an overflow occurs. Does a cross-reduce to
+    /// insure only the unavoidable overflows occur.</exception>
+    private static Fraction Modulus(Fraction left, Fraction right) {
+      if (left.IsNaN() || right.IsNaN())
+        return NaN;
+      try {
+        checked {
+          // this will discard any fractional places...
+          Int64 quotient = (Int64)(left / right);
+          Fraction whole = new Fraction(quotient * right.m_Numerator, right.m_Denominator);
+          return left - whole;
+        }
+      }
+      catch (Exception e) {
+        throw new FractionException("Modulus error", e);
+      }
+    }
+    /// <summary>
+    /// Computes the greatest common divisor for two values
+    /// </summary>
+    /// <param name="left">One value</param>
+    /// <param name="right">Another value</param>
+    /// <returns>The greatest common divisor of the two values</returns>
+    /// <example>(6, 9) returns 3 and (11, 4) returns 1</example>
+    private static long GCD(long left, long right) {
+      // take absolute values
+      if (left < 0)
+        left = -left;
+      if (right < 0)
+        right = -right;
+      // if we're dealing with any zero or one, the GCD is 1
+      if (left < 2 || right < 2)
+        return 1;
+      do {
+        if (left < right) {
+          long temp = left;  // swap the two operands
+          left = right;
+          right = temp;
+        }
+        left %= right;
+      } while (left != 0);
+      return right;
+    }
+    #endregion
+    #region Indeterminate helpers
+    /// <summary>
+    /// Gives the culture-related representation of the indeterminate types NaN, PositiveInfinity
+    /// and NegativeInfinity
+    /// </summary>
+    /// <param name="numerator">The value in the numerator</param>
+    /// <returns>The culture-specific string representation of the implied value</returns>
+    /// <remarks>Only the sign and zero/non-zero information is relevant.</remarks>
+    private static string IndeterminateTypeName(long numerator) {
+      // could also be NumberFormatInfo.InvariantInfo
+      System.Globalization.NumberFormatInfo info = NumberFormatInfo.CurrentInfo;
+      switch (NormalizeIndeterminate(numerator)) {
+        case Indeterminates.PositiveInfinity:
+          return info.PositiveInfinitySymbol;
+        case Indeterminates.NegativeInfinity:
+          return info.NegativeInfinitySymbol;
+        default:    // if this happens, something VERY wrong is going on...
+        case Indeterminates.NaN:
+          return info.NaNSymbol;
+      }
+    }
+    /// <summary>
+    /// Gives the normalize representation of the indeterminate types NaN, PositiveInfinity
+    /// and NegativeInfinity
+    /// </summary>
+    /// <param name="numerator">The value in the numerator</param>
+    /// <returns>The normalized version of the indeterminate type</returns>
+    /// <remarks>Only the sign and zero/non-zero information is relevant.</remarks>
+    private static Indeterminates NormalizeIndeterminate(long numerator) {
+      switch (Math.Sign(numerator)) {
+        case 1:
+          return Indeterminates.PositiveInfinity;
+        case -1:
+          return Indeterminates.NegativeInfinity;
+        default:    // if this happens, your Math.Sign function is BROKEN!
+        case 0:
+          return Indeterminates.NaN;
+      }
+    }
+    // These are used to represent the indeterminate with a Denominator of zero
+    private enum Indeterminates {
+      NaN = 0
+      ,
+      PositiveInfinity = 1
+        , NegativeInfinity = -1
+    }
+    #endregion
+    #region Member variables
+    private long m_Numerator;
+    private long m_Denominator;
+    #endregion
+    #endregion
+  }   //end class Fraction
+  /// <summary>
+  /// Exception class for Fraction, derived from System.Exception
+  /// </summary>
+  public class FractionException : Exception {
+    /// <summary>
+    /// Constructs a FractionException
+    /// </summary>
+    /// <param name="Message">String associated with the error message</param>
+    /// <param name="InnerException">Actual inner exception caught</param>
+    public FractionException(string Message, Exception InnerException)
+      : base(Message, InnerException) {
+    }
+  }   //end class FractionException
+}   //end namespace Mehroz

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers-3.3.csproj

-                      r10198
+                      r10200
   <ItemGroup>
     <Compile Include="DoubleArrayExtensions.cs" />
+    <Compile Include="FractionClass.cs" />
+    <Compile Include="LiblrsWrapper.cs" />
     <Compile Include="RealVectorConvexHullSolutionCacheAnalyzer.cs" />
     <Compile Include="DistanceMatrixToPoints.cs" />
 …
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="liblrs.dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.Analyzers/3.3/LiblrsWrapper.cs

-                      r10198
+                      r10200
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.InteropServices;
 namespace Testliblrs {
+namespace HeuristicLab.Analysis.AlgorithmBehavior.Analyzers {
   public static class LiblrsWrapper {
+    public static double CalculateVolume(List<double[]> points) {
+      double result = 0.0;
+      int dimension = points.First().Length;
+      int numPoints = points.Count();
+      Int32[] num = new Int32[dimension * numPoints];
+      Int32[] den = new Int32[dimension * numPoints];
+      for (int i = 0; i < numPoints; i++) {
+        for (int j = 0; j < dimension; j++) {
+          var fraction = new Fraction(points[i][j]);
+          //TODO: fix possible overflow
+          num[i * dimension + j] = (int)fraction.Numerator;
+          den[i * dimension + j] = (int)fraction.Denominator;
+        }
+      }
+      result = calculate_volume(numPoints, dimension, num, den);
+      return result;
+    }
     [System.Runtime.InteropServices.DllImportAttribute("liblrs.dll", EntryPoint = "calculate_volume")]
     public static extern double calculate_volume(int numPoints, int dimension, [In] Int32[] num, [In] Int32[] den);

branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.AlgorithmBehavior.sln

-                      r10024
+                      r10200
   ProjectSection(SolutionItems) = preProject
     Build.cmd = Build.cmd
+    Performance1.psess = Performance1.psess
     PreBuildEvent.cmd = PreBuildEvent.cmd
   EndProjectSection
 …
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Analysis.SolutionCaching.Views-3.3", "HeuristicLab.Analysis.SolutionCaching.Views\3.3\HeuristicLab.Analysis.SolutionCaching.Views-3.3.csproj", "{3977F98A-3D59-4D02-A6D3-51021BCEB488}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PerformanceTests", "PerformanceTests\PerformanceTests.csproj", "{8044B249-01E1-4C7E-8A21-E3C5C1DE0714}"
 EndProject
 Global
 …
     {3977F98A-3D59-4D02-A6D3-51021BCEB488}.Release|x64.ActiveCfg = Release|Any CPU
     {3977F98A-3D59-4D02-A6D3-51021BCEB488}.Release|x86.ActiveCfg = Release|Any CPU
+    {8044B249-01E1-4C7E-8A21-E3C5C1DE0714}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+    {8044B249-01E1-4C7E-8A21-E3C5C1DE0714}.Debug|Any CPU.Build.0 = Debug|Any CPU
+    {8044B249-01E1-4C7E-8A21-E3C5C1DE0714}.Debug|x64.ActiveCfg = Debug|Any CPU
+    {8044B249-01E1-4C7E-8A21-E3C5C1DE0714}.Debug|x86.ActiveCfg = Debug|Any CPU
+    {8044B249-01E1-4C7E-8A21-E3C5C1DE0714}.Release|Any CPU.ActiveCfg = Release|Any CPU
+    {8044B249-01E1-4C7E-8A21-E3C5C1DE0714}.Release|Any CPU.Build.0 = Release|Any CPU
+    {8044B249-01E1-4C7E-8A21-E3C5C1DE0714}.Release|x64.ActiveCfg = Release|Any CPU
+    {8044B249-01E1-4C7E-8A21-E3C5C1DE0714}.Release|x86.ActiveCfg = Release|Any CPU
   EndGlobalSection
   GlobalSection(SolutionProperties) = preSolution
     HideSolutionNode = FALSE
   EndGlobalSection
+  GlobalSection(Performance) = preSolution
+    HasPerformanceSessions = true
+  EndGlobalSection
 EndGlobal

branches/HeuristicLab.Analysis.AlgorithmBehavior/liblrs/ctest_liblrs/ctest_liblrs.vcxproj

-                      r10198
+                      r10200
       <Platform>Win32</Platform>
     </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
     <ProjectConfiguration Include="Release|Win32">
       <Configuration>Release</Configuration>
       <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
     </ProjectConfiguration>
   </ItemGroup>
 …
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v110</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v110</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
 …
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
 …
     <ReferencePath>$(SolutionDir)Debug;$(ReferencePath)</ReferencePath>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <IncludePath>$(SolutionDir);$(IncludePath)</IncludePath>
+    <LibraryPath>$(SolutionDir)x64\Debug;$(LibraryPath)</LibraryPath>
+    <ReferencePath>$(SolutionDir)Debug;$(ReferencePath)</ReferencePath>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <IncludePath>$(SolutionDir);$(IncludePath)</IncludePath>
     <LibraryPath>$(SolutionDir)\Release;$(LibraryPath)</LibraryPath>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <IncludePath>$(SolutionDir);$(IncludePath)</IncludePath>
+    <LibraryPath>$(SolutionDir)\Release;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>liblrs.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
 …
     </Link>
   </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>$(SolutionDir)Release\liblrs.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="main.cpp" />

branches/HeuristicLab.Analysis.AlgorithmBehavior/liblrs/liblrs/extfunc.c

r10198	r10200
56	56	/* now flags in lrs_dat can be set */
57	57	Q->m=numPoints; /* number of input rows = number of vertices */
58		Q->n=dimension;~~/TODO: +1?/ /* number of input columns (dimension + 1 )~~ */
	58	Q->n=dimension; /* number of input columns */
59	59	Q->hull = TRUE; /* convex hull problem: facet enumeration */
60	60	Q->polytope= TRUE; /* input is a polytope */

branches/HeuristicLab.Analysis.AlgorithmBehavior/liblrs/liblrs/liblrs.sln

-                      r10198
+                      r10200
     {B6D2A50A-D977-4F8F-8BCA-08591D6BB52D}.Debug|Win32.ActiveCfg = Debug|Win32
     {B6D2A50A-D977-4F8F-8BCA-08591D6BB52D}.Debug|Win32.Build.0 = Debug|Win32
     {B6D2A50A-D977-4F8F-8BCA-08591D6BB52D}.Debug|x64.ActiveCfg = Debug|Win32
     {B6D2A50A-D977-4F8F-8BCA-08591D6BB52D}.Debug|x64.Build.0 = Debug|Win32
+    {B6D2A50A-D977-4F8F-8BCA-08591D6BB52D}.Debug|x64.ActiveCfg = Debug|x64
+    {B6D2A50A-D977-4F8F-8BCA-08591D6BB52D}.Debug|x64.Build.0 = Debug|x64
     {B6D2A50A-D977-4F8F-8BCA-08591D6BB52D}.Release|Any CPU.ActiveCfg = Release|Win32
     {B6D2A50A-D977-4F8F-8BCA-08591D6BB52D}.Release|Mixed Platforms.ActiveCfg = Release|Win32

branches/HeuristicLab.Analysis.AlgorithmBehavior/liblrs/liblrs/liblrs.vcxproj

-                      r10198
+                      r10200
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v110</PlatformToolset>
 …
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
       <PreprocessorDefinitions>_WINDLL;%(PreprocessorDefinitions);B64</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>
       <PreprocessorDefinitions>_WINDLL;%(PreprocessorDefinitions);B64</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 10200

Legend:

Download in other formats: