# HG changeset patch
# User Markus Mützel <markus.muetzel@gmx.de>
# Date 1510425563 -3600
# Node ID 0da1bdfbfacbb527e476788505d37a149fe7f004
# Parent  dc85329e67782d9f02399021495e475fa2794e85
Calculate minor ticks outside major tick range on logarithmic axes (bug #52376).

* graphics.cc (axes::properties::calc_ticks_and_lims): Calculate minor ticks
outside major tick range also for logarithmic scaling.

diff -r dc85329e6778 -r 0da1bdfbfacb libinterp/corefcn/graphics.cc
--- a/libinterp/corefcn/graphics.cc	Sun Nov 12 22:10:46 2017 +0100
+++ b/libinterp/corefcn/graphics.cc	Sat Nov 11 19:39:23 2017 +0100
@@ -7309,13 +7309,13 @@
                                        bool tickmode_is_auto,
                                        bool is_logscale)
 {
-  // FIXME: add log ticks and lims
-
   if (lims.get ().isempty ())
     return;
 
   double lo = (lims.get ().matrix_value ())(0);
   double hi = (lims.get ().matrix_value ())(1);
+  double lo_lim = lo;
+  double hi_lim = hi;
   bool is_negative = lo < 0 && hi < 0;
 
   // FIXME: should this be checked for somewhere else? (i.e., set{x,y,z}lim)
@@ -7410,43 +7410,37 @@
   if (n_ticks < 2)
     return;
 
+  // minor ticks between, above, and below min and max ticks
   int n = (is_logscale ? 8 : 4);
-  Matrix tmp_mticks (1, n * (n_ticks - 1));
-
+  double mult_below = (is_logscale ? tmp_ticks(1) / tmp_ticks(0) : 1);
+  double mult_above = (is_logscale ? tmp_ticks(n_ticks-1) / tmp_ticks(n_ticks-2)
+                                   : 1);
+
+  double d_below = (tmp_ticks(1) - tmp_ticks(0)) / mult_below / (n+1);
+  int n_below = static_cast<int> (std::floor ((tmp_ticks(0)-lo_lim) / d_below));
+  if (n_below < 0)
+    n_below = 0;
+  int n_between = n * (n_ticks - 1);
+  double d_above = (tmp_ticks(n_ticks-1) - tmp_ticks(n_ticks-2)) * mult_above
+                   / (n+1);
+  int n_above = static_cast<int> (std::floor ((hi_lim-tmp_ticks(n_ticks-1))
+                                              / d_above));
+  if (n_above < 0)
+    n_above = 0;
+
+  Matrix tmp_mticks (1, n_below + n_between + n_above);
+  for (int i = 0; i < n_below; i++)
+    tmp_mticks(i) = tmp_ticks(0) - (n_below-i) * d_below;
   for (int i = 0; i < n_ticks-1; i++)
     {
       double d = (tmp_ticks(i+1) - tmp_ticks(i)) / (n + 1);
       for (int j = 0; j < n; j++)
-        tmp_mticks(n*i+j) = tmp_ticks(i) + d * (j+1);
-    }
-
-  if (is_logscale)
-    mticks = tmp_mticks;
-  else
-    {
-      // add minor ticks above and below min and max ticks
-      double d_below = (tmp_ticks(1) - tmp_ticks(0)) / (n+1);
-      int n_below = static_cast<int> (std::floor ((tmp_ticks(0)-lo)
-                                                  / d_below));
-      if (n_below < 0)
-        n_below = 0;
-      int n_between = tmp_mticks.columns ();
-      double d_above = (tmp_ticks(n_ticks-1) - tmp_ticks(n_ticks-2)) / (n+1);
-      int n_above = static_cast<int> (std::floor ((hi-tmp_ticks(n_ticks-1))
-                                                  / d_above));
-      if (n_above < 0)
-        n_above = 0;
-
-      Matrix tmp_mticks2 (1, n_below + n_between + n_above);
-      for (int i_below = 0; i_below < n_below; i_below++)
-        tmp_mticks2(i_below) = tmp_ticks(0) - (n_below-i_below) * d_below;
-      for (int i_between = 0; i_between < n_between; i_between++)
-        tmp_mticks2(n_below+i_between) = tmp_mticks(i_between);
-      for (int i_above = 0; i_above < n_above; i_above++)
-        tmp_mticks2(n_below+n_between+i_above) = tmp_ticks(n_ticks-1)
-                                                 + (i_above + 1) * d_above;
-      mticks = tmp_mticks2;
-    }
+        tmp_mticks(n_below+n*i+j) = tmp_ticks(i) + d * (j+1);
+    }
+  for (int i = 0; i < n_above; i++)
+    tmp_mticks(n_below+n_between+i) = tmp_ticks(n_ticks-1) + (i + 1) * d_above;
+
+  mticks = tmp_mticks;
 }
 
 /*