1:
2:
3:
4:

19,9999 -> 20
100000,001 -> 100000
0,0000000000001 -> 0
2,49999975 -> 2,5                    

1:
2:
3:
4:

function myRound(zahl,intervall:Real):Real;
begin
  result := intervall * round( 10 * zahl / intervall ) / 10;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:

var
 min, max, idealinterval, fittedinterval_10, fittedinterval_5, fittedinterval_2, x, fittedinterval: Extended;
 idealcount, fittedcount_10, fittedcount_5, fittedcount_2, fittedcount: Integer;
begin
  min:=random*100-50; // bereichsminimum
  max:=min+random*random*100; // bereichsmaximum
  idealcount:=10; // erwünschte anzahl ticks

  idealinterval:=(max-min)/idealcount;
  x := ln(idealinterval)/ln(10);
  // runde so, dass wir am nähesten an die ideale anzahl ticks kommen
  if floor(x) < -ln(2/1.1*idealcount/(max-min))/ln(10) {sic} then
   fittedinterval_10:=power(10,ceil(x)) // aufrunden
  else
   fittedinterval_10:=power(10,floor(x)); // abrunden
  fittedcount_10:=trunc((max-min)/fittedinterval_10);

  // wir haben nun die beste Lösung mit 10er-Abständen
  fittedinterval := fittedinterval_10;
  fittedcount := fittedcount_10;

  // jetzt noch die besten 2-er bzw. 5-er berechnen
  if fittedcount_10<idealcount then
  begin
   fittedinterval_5 := fittedinterval_10/2;
   fittedinterval_2 := fittedinterval_10/5;
  end else
  begin
   fittedinterval_5 := fittedinterval_10*5;
   fittedinterval_2 := fittedinterval_10*2;
  end;
  fittedcount_2 := trunc((max-min)/fittedinterval_2);
  fittedcount_5 := trunc((max-min)/fittedinterval_5);

  // die Beste Lösung aus 10er, 5er und 2er aussuchen
  if abs(fittedcount_2-idealcount)<abs(fittedcount-idealcount) then
  begin
   fittedcount := fittedcount_2;
   fittedinterval := fittedinterval_2;
  end;
  if abs(fittedcount_5-idealcount)<abs(fittedcount-idealcount) then
  begin
   fittedcount := fittedcount_5;
   fittedinterval := fittedinterval_5;
  end;

  // ausgeben
  memo1.lines.add(format('[%s,%s] => ticks:[%s,%s] +%s (%d)',[floattostr(min),floattostr(max),floattostr(ceil(min/fittedinterval)*fittedinterval),floattostr(floor(max/fittedinterval)*fittedinterval),floattostr(fittedinterval),fittedcount]));
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

min,max            ticks von,bis        tick intervall  anzahl tickintervalle
[-50.00,-47.30] => ticks:[-49.8,-47.4]  0.20            13 
[-29.74,-11.41] => ticks:[-28,-12]      2.00             9 
[-18.13,-12.11] => ticks:[-18,-12.5]    0.50            12 
[-7.43,-3.54]   => ticks:[-7,-4]        0.50             7 
[-42.94,-37.92] => ticks:[-42.5,-38]    0.50            10 
[-20.67,13.08]  => ticks:[-20,10]       5.00             6 
[27.47,50.35]   => ticks:[28,50]        2.00            11 
[34.42,56.43]   => ticks:[36,56]        2.00            11 
[-33.74,-18.38] => ticks:[-32,-20]      2.00             7 
[-25.33,-2.30]  => ticks:[-24,-4]       2.00            11 
[-1.82,11.22]   => ticks:[-1,11]        1.00            13 
[-21.27,54.19]  => ticks:[-20,50]       10.00            7 
[-0.75,72.71]   => ticks:[0,70]         10.00            7                    

1:
2:

x=power(10,floor(log(interval)/log(10)))
gerundetezahl = round(zahl/x)*x                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:

Procedure GetAxis(aMin, aMax: Extended; aTics: Integer;
  Var aNewMin, aNewMax, aNewTics: Extended);
Const
  Tics: Array[0..8] Of Extended =
  (0.01, 0.02, 0.025, 0.05, 0.1, 0.2, 0.25, 0.5, 1);
Var
  nMult, nMin, nMax, nDiff, nTics: Extended;
  i, n, j, m: Integer;

Begin
  Assert(aMax > aMin, ' Lower bound > upper bound');
  nMin := aMin;
  nMax := aMax;
  If nMax < 0 Then
    nMult := -1
  Else
    nMult := 1;
  While abs(nMax / nMult) < 1 Do
    nMult := nMult / 10;
  While abs(nMax / nMult) > 1 Do
    nMult := nMult * 10;

  nMin := nMin / nMult;
  nMax := nMax / nMult;
  nDiff := nMax - nMin;

  m := 9999;
  For i := low(Tics) To High(Tics) Do Begin
    n := Trunc(nDiff / tics[i]);
    If abs(n - aTics) < m Then Begin
      m := abs(n - aTics);
      j := i;
    End
  End;
  nTics := Tics[j];
  aNewMin := (Trunc(nMin / nTics) * nTics) * nMult;
  aNewMax := (Trunc(0.9999 + nMax / nTics) * nTics) * nMult;
  aNewTics := nTics * nMult;
End;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

...
  If nMax < 0 Then
    nMult := -1
  Else
    nMult := 1;
  While abs(nMax / nMult) < 1 Do
    nMult := nMult / 10;
  While abs(nMax / nMult) > 1 Do
    nMult := nMult * 10;

  nMin := nMin / nMult;
  nMax := nMax / nMult;
...