Delphi-PRAXiS
Seite 1 von 2  1 2   

Delphi-PRAXiS (https://www.delphipraxis.net/forum.php)
-   Object-Pascal / Delphi-Language (https://www.delphipraxis.net/32-object-pascal-delphi-language/)
-   -   Delphi Ganze Zahl immer auf nächste 50 runden? (https://www.delphipraxis.net/191869-ganze-zahl-immer-auf-naechste-50-runden.html)

BBoy 26. Feb 2017 19:57

Delphi-Version: 10 Seattle

Ganze Zahl immer auf nächste 50 runden?
 
Wie kann ich eine ganze Zahl auf die nächsten 50 auf oder abrunden?
zb:
1732 = 1700
1776 = 1800

Also so lange die 10er <50 wird abgerundet und wenn 10er >=50 dann aufrunden.

Ich sag schon mal Danke für eure Hilfe :thumb:

Darlo 26. Feb 2017 20:05

AW: Ganze Zahl immer auf nächste 50 runden?
 
ungetestet und ggf. zu kompliziert ��

Delphi-Quellcode:
if (x +49 mod 50) mod 2 = 0 then
   erg := (x +49 mod 50)*50
else
   erg := (x +49 mod 50)*50-50.

DeddyH 26. Feb 2017 20:10

AW: Ganze Zahl immer auf nächste 50 runden?
 
Ich verstehe das Beispiel nicht. Willst Du wirklich auf 50 runden oder doch eher auf 100?

[edit] Falls Letzteres, aus dem Hut und ungetestet:
Delphi-Quellcode:
if Zahl mod 100 < 50 then
  Zahl := Zahl div 100 * 100
else
  Zahl := Succ(Zahl div 100) * 100;
[/edit]

t.roller 26. Feb 2017 20:30

AW: Ganze Zahl immer auf nächste 50 runden?
 
SetRoundMode(rmNearest);
http://docwiki.embarcadero.com/CodeE...ndMode_(Delphi)
Zwischenschritte: Div 100, Multi 100

Delphi-Quellcode:
uses ...System.Math,...

procedure TForm1.ButtonClick(Sender: TObject);
var
  OldRM: TRoundingMode;
  TestValue: Real;

  procedure RecordRound(const TextStr: String; Value: Real);
  { Calls Round() and shows its value in the Memo control.
    Affected by the value passed to SetRoundMode(). }
  var RetVal: Real;
  begin
    RetVal := Round(Value);
    Memo1.Lines.Add(Format('%-15s  RetVal=%f', [TextStr, RetVal]));
  end;

begin
  OldRM := GetRoundMode; { Save the original setting for the Round Mode }

  TestValue := 5.7; { First test value }
  Memo1.Lines.Add(Format('Value=%f', [TestValue]));

  SetRoundMode(rmDown);
  RecordRound('rmDown #1', TestValue);

  SetRoundMode(rmUp);
  RecordRound('rmUp #2', TestValue);

  SetRoundMode(rmNearest);
  RecordRound('rmNearest #3', TestValue);

  SetRoundMode(rmTruncate);
  RecordRound('rmTruncate #4', TestValue);

  Memo1.Lines.Add(''); { Adds a blank line to the memo }

  TestValue := -1.3;  { Second test value }
  Memo1.Lines.Add(Format('Value=%f', [TestValue]));

  SetRoundMode(rmDown);
  RecordRound('rmDown #5', TestValue);

  SetRoundMode(rmUp);
  RecordRound('rmUp #6', TestValue);

  SetRoundMode(rmNearest);
  RecordRound('rmNearest #7', TestValue);

  SetRoundMode(rmTruncate);
  RecordRound('rmTruncate #8', TestValue);

  SetRoundMode(OldRM); { Restore the original Rounding Mode }
end;

juergen 26. Feb 2017 20:41

AW: Ganze Zahl immer auf nächste 50 runden?
 
Hallo,

in der Umsetzung aufwändig, aber das Ergebnis scheint zu stimmen : :shock:
Delphi-Quellcode:
function auf50kaufmaennisch_runden(Const Value: Integer): Integer;
Var
  i, temp: Integer;
begin
  temp := Value;
  if temp > 49 then begin
    if (StrToInt(copy(IntToStr(temp), Length(IntToStr(temp)) - 1, Length(IntToStr(temp)))) > 49) then begin
      for i := 0 to 50 do begin
        if temp mod 50 = 0 then begin
          Result := temp;
          Exit;
        end
        else Inc(temp);
      end;
    end else begin
      for i := 50 downto 0 do begin
        if temp mod 50 = 0 then begin
          Result := temp;
          Exit;
        end
        else Dec(temp);
      end;
    end;
  end
  else Result := 0;
end;

procedure TForm11.Button1Click(Sender: TObject);
begin
  showmessage(IntToStr(auf50kaufmaennisch_runden(SpinEdit1.Value)));
end;

Benedikt Magnus 26. Feb 2017 21:24

AW: Ganze Zahl immer auf nächste 50 runden?
 
Deine Beschreibung sagt Rundung auf hundert, das wäre dann so:

Delphi-Quellcode:
function RundenAufHundert(const Wert: Integer): Integer;
begin
  Result := Round(Wert / 100) * 100;
end;
Immer auf die vollen Fünfziger zu runden würde ich so machen:

Delphi-Quellcode:
function RundenAufFünfzig(const Wert: Integer): Integer;
begin
  Result := Round(Wert / 50) * 50;
end;
Oder allgemein:

Delphi-Quellcode:
function RundenAufZahl(const Wert, Zahl: Integer): Integer;
begin
  Result := Round(Wert / Zahl) * Zahl;
end;

Darlo 26. Feb 2017 22:09

AW: Ganze Zahl immer auf nächste 50 runden?
 
Zitat:

Zitat von Benedikt Magnus (Beitrag 1362734)
Deine Beschreibung sagt Rundung auf hundert, das wäre dann so:

Delphi-Quellcode:
function RundenAufHundert(const Wert: Integer): Integer;
begin
  Result := Round(Wert / 100) * 100;
end;
Immer auf die vollen Fünfziger zu runden würde ich so machen:

Delphi-Quellcode:
function RundenAufFünfzig(const Wert: Integer): Integer;
begin
  Result := Round(Wert / 50) * 50;
end;
Oder allgemein:

Delphi-Quellcode:
function RundenAufZahl(const Wert, Zahl: Integer): Integer;
begin
  Result := Round(Wert / Zahl) * Zahl;
end;

:thumb: So isses.

Uwe Raabe 26. Feb 2017 22:21

AW: Ganze Zahl immer auf nächste 50 runden?
 
In System.Math gibt es auch eine Funktion
Delphi-Quellcode:
RoundTo
, mit der das ebenfalls recht einfach realisiert werden kann. Runden auf ganze 100er ginge dann so:

Delphi-Quellcode:
function RundenAufHundert(const Wert: Integer): Integer;
begin
  Result := RoundTo(Wert, 2);
end;

t.roller 26. Feb 2017 23:55

AW: Ganze Zahl immer auf nächste 50 runden?
 
Nö: E2010 Inkompatible Typen: 'Integer' und 'Extended'

Delphi-Quellcode:
function RundenAufHundert(const Wert: Extended): Extended;
begin
  Result := RoundTo(Wert, 2);
end;

Uwe Raabe 27. Feb 2017 08:35

AW: Ganze Zahl immer auf nächste 50 runden?
 
Zitat:

Zitat von t.roller (Beitrag 1362737)
Nö: E2010 Inkompatible Typen: 'Integer' und 'Extended'

OK, dann eben so:

Delphi-Quellcode:
function RundenAufHundert(const Wert: Integer): Integer;
begin
  Result := Round(RoundTo(Wert, 2));
end;


Alle Zeitangaben in WEZ +1. Es ist jetzt 00:21 Uhr.
Seite 1 von 2  1 2   

Powered by vBulletin® Copyright ©2000 - 2019, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2019 by Daniel R. Wolf