Replicate ticks in log scale [closed]

Question

I'm trying to understand the idea and (possibly) replicate myself how Mathematica generate ticks. For a linear scale it is simple enough: one can use FindDivisions function, and this will give the same (or very close to) what Mathematica places on axes in Plot. But what to do in case of LogPlot? For a large range Mathematica can produce something like {10,50,100,500,1000}, but for smaller range this may be almost linear range. Is there some analog of FindDivision for log scale?

Up

An example: LogPlot[x, {x, 12, 167}, Frame -> True].

Ticks above 100 and below 20 can confuse: for usual log scale they should be read as 200 and 10 respectively. But not in this case: here they are 150 and 15. Very confusing.

Add

To see clearly what are confusing ticks:

Log10[{12, 167}]
FindDivisions[%,6]
Part[%,{1,-1}]
(* {1, 2.4} *)

LogPlot[x, {x, 12, 167}, Frame -> True, PlotRange -> 10^{1., 2.4}]

There are additional ticks in {10, 20} and {100, 200}.

Answer 1

Not so clear from your code what you aim for. See the excellent answers at The implementation of "SignedLog" Scaling Function of `Plot`.

The bottom line is you can translate either way using

signedLogCoords[{x_, y_}] := {
  If[signedLogX, Sign[x] Log10[Abs[x] + 1], x],
  If[signedLogY, Sign[y] Log10[Abs[y] + 1], y]
  }
signedLogCoordsInv[{x_, y_}] := {
  If[signedLogX, Sign[x] ((10^Abs[x]) - 1), x],
  If[signedLogY, Sign[y] ((10^Abs[y]) - 1), y]

You precede your graphs with signedLogX=True if you want the x coordinate to be transformed, and analogously for the y coordinate.

Ticks take the form of Ticks->{{{xtickvalue,xticklabel},...},{{ytickvalue,yticklabel},...}}. You can add a tick specification or add graphics primitives before the graph (under the graph's output) by using Prolog->{graphics primitives} or after (on top of) it by using Epilog->{...}.

Edit pursuant to explanation:

Since you want to adjust the ticks automatically, you want to play around with the function FindDivisions. A reasonable attempt to produce "pretty" divisions may be:

logFindDivisions1[min_, max_] := Module[{sm, big, zeros, eigh},
  Flatten@{zeros = (Floor@Log10@max) - 1;
    eigh = 8 10^zeros;
    big = eigh Floor[max/eigh];
    If[# > min, If[! IntegerQ@#, N@#, #], 
       Nothing] & /@ (big/(2^Range[0, 8]))}]

It takes the maximum, finds the next largest 8 10^x and gives its half, quarter, etc., provided they are greater than the minimum.

A somewhat more complex version may also start from 16, 32, or 64 10^x:

logFindDivisions2[min_, max_] := 
 Module[{sm, big, zeros, first, foundation},
  Flatten@{
    {first, zeros} = RealDigits[max];
    first = 
     If[first[[2]] != 0, FromDigits[first[[1 ;; 2]]], first[[1]]];
    foundation = Which[
      first >= 80, 80,
      first >= 64, 64,
      first >= 32, 32,
      first >= 16, 16,
      True, 8];
    If[foundation > 8, --zeros];
    big = foundation 10^--zeros;
    If[# > min, If[! IntegerQ@#, N@#, #], 
       Nothing] & /@ (big/(2^Range[0, 8]))}]

The difference is that the latter prevents having the large division be a clumsy multiple of eight, like 72, which is clumsy because after 36 and 18 it enters the territory of clumsy divisions (9, 4.5, ...).

In[196]:= divs = {.12, .75};
logFindDivisions1 @@ divs
logFindDivisions2 @@ divs

(*Out[]= {0.72, 0.36, 0.18}*)
(*Out[]= {0.64, 0.32, 0.16}*)