Changeset 14161 for stable/HeuristicLab.Visualization.ChartControlsExtensions/3.3/ChartUtil.cs

Timestamp:

07/21/16 16:57:58 (8 years ago)

Author:

mkommend

Message:

#2594: Merged r13764, r13765, r13807, r14007, r14008, r14014, r14152, r14155, r14156, r14159 to stable.

Location:

stable

Files:

• . (modified) (1 prop)
• HeuristicLab.Visualization.ChartControlsExtensions/3.3/ChartUtil.cs (copied) (copied from trunk/sources/HeuristicLab.Visualization.ChartControlsExtensions/3.3/ChartUtil.cs) (4 diffs)

stable/HeuristicLab.Visualization.ChartControlsExtensions/3.3/ChartUtil.cs

@@ -27 +27 @@
   public static class ChartUtil {
     public static void CalculateAxisInterval(double min, double max, int ticks, out double axisMin, out double axisMax, out double axisInterval) {
-      var dmin = min.Decimals();
-      axisMin = min.Floor(dmin);
-      var range = max - axisMin;
-      var slice = range / ticks;
-      var dslice = slice.Decimals();
-      var floor = slice.Floor(dslice);
-      var ceil = slice.Ceil(dslice);
-      var axisRange = floor * ticks;
-      axisInterval = floor;
-      if (axisRange < max - axisMin) {
-        axisRange = ceil * ticks;
-        axisInterval = ceil;
+      if (double.IsInfinity(min) || double.IsNaN(min) || double.IsInfinity(max) || double.IsNaN(max) || (min >= max))
+        throw new ArgumentOutOfRangeException("Invalid range provided.");
+
+      var range = max - min;
+      var dRange = (int)Math.Round(Math.Log10(range));
+      int decimalRank = dRange - 1;
+      var aMin = min.RoundDown(decimalRank);
+      var aMax = max.RoundUp(decimalRank);
+
+      // if one of the interval ends is a multiple of 5 or 10, change the other interval end to be a multiple as well
+      if ((aMin.Mod(5).IsAlmost(0) || aMin.Mod(10).IsAlmost(0)) && Math.Abs(aMax) >= 5 && !(aMax.Mod(5).IsAlmost(0) || aMax.Mod(10).IsAlmost(0))) {
+        aMax = Math.Min(aMax + 5 - aMax % 5, aMax + 10 - aMax % 10);
+      } else if ((aMax.Mod(5).IsAlmost(0) || aMax.Mod(10).IsAlmost(0)) && Math.Abs(aMin) >= 5 && !(aMin.Mod(5).IsAlmost(0) || aMin.Mod(10).IsAlmost(0))) {
+        aMin = Math.Max(aMin - aMin.Mod(5), aMin - aMin.Mod(10));
       }
-      axisMax = axisMin + axisRange;
+
+      axisMin = aMin;
+      axisMax = aMax;
+      axisInterval = (aMax - aMin) / ticks;
     }
 
+    /// <summary>
+    /// Tries to find an axis interval with as few fractional digits as possible (because it looks nicer).  we only try between 3 and 5 ticks (inclusive) because it wouldn't make sense to exceed this interval.
+    /// </summary>
+    public static void CalculateOptimalAxisInterval(double min, double max, out double axisMin, out double axisMax, out double axisInterval) {
+      CalculateAxisInterval(min, max, 5, out axisMin, out axisMax, out axisInterval);
+      int bestLsp = int.MaxValue;
+      for (int ticks = 3; ticks <= 5; ++ticks) {
+        double aMin, aMax, aInterval;
+        CalculateAxisInterval(min, max, ticks, out aMin, out aMax, out aInterval);
+        var x = aInterval;
+        int lsp = 0; // position of the least significant fractional digit
+        while (x - Math.Floor(x) > 0) {
+          ++lsp;
+          x *= 10;
+        }
+        if (lsp <= bestLsp) {
+          axisMin = aMin;
+          axisMax = aMax;
+          axisInterval = aInterval;
+          bestLsp = lsp;
+        }
+      }
+    }
+
+    // find the number of decimals needed to represent the value
     private static int Decimals(this double x) {
-      if (double.IsInfinity(x) || double.IsNaN(x))
+      if (x.IsAlmost(0) || double.IsInfinity(x) || double.IsNaN(x))
         return 0;
 
       var v = Math.Abs(x);
-      int d = 0;
+      int d = 1;
       while (v < 1) {
         v *= 10;
@@ -54 +84 @@
       }
       return d;
+    }
+
+    private static double RoundDown(this double value, int decimalRank) {
+      if (decimalRank > 0) {
+        var floor = (int)Math.Floor(value);
+        var pow = (int)Math.Pow(10, decimalRank);
+        var mod = Mod(floor, pow);
+        return floor - mod;
+      }
+      return value.Floor(Math.Abs(decimalRank));
+    }
+
+    private static double RoundUp(this double value, int decimalRank) {
+      if (decimalRank > 0) {
+        var ceil = (int)Math.Ceiling(value);
+        var pow = (int)Math.Pow(10, decimalRank);
+        var mod = Mod(ceil, pow);
+        return ceil - mod + pow;
+      }
+      return value.Ceil(Math.Abs(decimalRank));
+    }
+
+    private static double RoundNearest(this double value, int decimalRank) {
+      var nearestDown = value.RoundDown(decimalRank);
+      var nearestUp = value.RoundUp(decimalRank);
+
+      if (nearestUp - value > value - nearestDown)
+        return nearestDown;
+
+      return nearestUp;
     }
 
@@ -62 +122 @@
     }
 
+    // rounds up to the nearest value according to the given number of decimal precision
     private static double Ceil(this double value, int precision) {
       var n = Math.Pow(10, precision);
@@ -67 +128 @@
     }
 
-    private static double Round(this double value, int precision) {
-      var n = Math.Pow(10, precision);
-      return Math.Round(Math.Round(value * n) / n, precision);
+    private static bool IsAlmost(this double value, double other, double eps = 1e-12) {
+      return Math.Abs(value - other) < eps;
+    }
+
+    private static double Mod(this double a, double b) {
+      return a - b * Math.Floor(a / b);
     }
   }