Delphi/Lazarus: Funktion um Zahl auf beliebige Position vor oder nach Dezimalzeichen zu runden

Die normale Round-Funktion von Delphi oder Lazarus kann dazu verwendet werden, eine Kommazahl (wie zum Beispiel float oder extended) auf einen Integer-Wert zu runden:

var
  e: extended;
  i: integer;
begin
  e := 12.3456;
  i := round(e);  // 12

Was aber können wir machen, wenn wir die Rundungsgenauigkeit angeben wollen oder in die andere Richtung runden möchten? Also zum Beispiel auf eine Zehner- oder eine Tausender-Stelle? Wenn wir zum Beispiel aus einer 12 eine 10 machen möchten, aus einer 123 eine 100 oder aus 21345 die Z. 20000? Oder wenn die die eine oder andere Nachkommastellen behalten möchten?

In diesem Fall können wir die folgende Funktion verwenden:

function RoundEx(const AInput: extended; APlaces: integer): extended;
var
  k: extended;
begin
  if APlaces = 0 then begin
    result := round(AInput);
  end else begin   
    if APlaces > 0 then begin
      k := power(10, APlaces);
      result := round(AInput * k) / k;
    end else begin
      k := power(10, (APlaces*-1));
      result := round(AInput / k) * k;
    end;
  end;
end;

Wie auch beim Runden in PHP, akzeptiert diese RoundEx-Funktion sowohl positive als auch negative Werte, je nachdem in welche Richtung man runden möchte. Hier ist ein Beispiel:

var
  e, r: extended;
begin
  e := 123.456;
  r := RoundEx(e, 0);   // 123
  r := RoundEx(e, 1);   // 123.5
  r := RoundEx(e, 2);   // 123.46
  r := RoundEx(e, -1);  // 120
  r := RoundEx(e, -2);  // 100

Der erste Parameter ist unsere Zahl, die wir runden möchten. Der zweite Parameter gibt die Anzahl von Nachkommastellen beziehungsweise Ziffern an, auf die wir runden möchten.

Wenn wir als zweiten Parameter 0 übergeben, erhalten wir das normale Ergebnis der round-Methode. Nehmen wir eine positive Zahl, schneidet unser Funktion entsprechend viele Nachkommastellen ab. Benutzen wir eine negative Zahl, können wir auf eine Zehnerstelle, eine Tausenderstelle oder jede andere höhere Dezimalstelle runden.