Anzahl der Nachkommastellen von Double ermitteln

[AndyDF]

Hallo,

ich würde gerne von einer Double-Zahl ermitteln, wieviele Nachkommastellen diese hat.
Hört sich leichter an als es dann tatsächlich ist - oder ich sitze auf dem Schlauch.

Bisher habe ich hierfür folgenden Code gehabt, der zunächst auch funktioniert hat:

Delphi-Quellcode:

function GetDecimalPlaces(const AValue: Double): Integer;
var
  fFracValue : Double;
begin
  Result := 0;

  fFracValue := Frac(AValue);
  if fFracValue > 0 then
    fFracValue := SimpleRoundTo( fFracValue + 0.00000000001, -10)
  else if fFracValue < 0 then
    fFracValue := SimpleRoundTo( fFracValue - 0.00000000001, -10);
  if fFracValue = 0 then
    exit;
  if fFracValue < 0 then
    Result := Length(FormatFloat('0.#################',fFracValue))-3
  else
    Result := Length(FormatFloat('0.#################',fFracValue))-2;
end;

Rufe ich die Methode nun wie folgt auf:
GetDecimalPlaces(4512985.95);

dann erhalte ich: 17.
Gewünscht wäre: 2

Ich denke, das passiert wegen der Umwandlung zwischen Double und Extended Zahlen.

Meine Frage ist:
Hat einer eine Idee, wie ich zuverlässig von beliebigen Double Werten die Anzahl der Nachkommastellen ermitteln kann?

Danke.

[EWeiss]

Split + Delemiter = '.' bzw. ','
Result = länge des Strings vom höchsten Array Element.

gruss

[Sherlock]

Das Thema ist aufgrund der internen Darstellung von Gleitkommazahlen nicht ganz ungefährlich. Aber https://www.delphipraxis.net/1247997-post11.html hat eine leidlich gute Lösung parat. Beachte aber, daß unter Umständen die Aufgabenstellung nicht optimal ist. Vergleiche Dazu die Diskussion rund um die Lösung https://www.delphipraxis.net/179120-...ter-point.html

Sherlock

[API]

Hier ein paar hilfreiche Routinen (Exact Float to String Routines etc.)
http://rvelthuis.de/articles/article...#investigating

[gammatester]

Willst Du wirkliche die genaue Darstellung von Double/Extended haben? Die können ziemlich viele Nachkommastellen haben. Hier für Deine Zahl 4512985.95:

Berechnet mit meinem MPArith(http://www.wolfgang-ehrhardt.de/misc_de.html#mparith)

Code:

Test of MPArith V1.37.12 (31/32 bit) [mp_rcalc]   (c) W.Ehrhardt 2008-2018
Karatsuba  cutoffs: mul/sqr = 16/32
Toom-3, BZ cutoffs: mul/sqr = 32/64,  div = 32
Type "?<enter>" to get some info about commands, "\q" or "quit" to end.
Current bit precision = 240 (max:120000),  decimal precision = 72.2

[D]:=> x=4512985.95
X = 4512985.95
[D]:=> asx(x)
Result = 4512985.9499999999998181010596454143524169921875
[D]:=> asd(x)
Result = 4512985.950000000186264514923095703125

oder mit John Herbster's ExactFloatToStr_JH0 -- Exact Float to String Routines (https://cc.embarcadero.com/Item/19421):

4.512.985,949.999.999.999.818.101.059.645.414.352. 416.992.187.5

Schau Dir damit mal 'smallest double' an, das hat über 750 signifikante Nachkommastellen!

[AndyDF]

Danke für eure Antworten.

Nicht die exakte Darstellung. Nur die Anzahl der NS meiner gerundeten Double Zahl.
Also bei der Zahl 4512985.95 möchte ich 2 erhalten. => 2NS.
Bei der Zahl 0.00000023 möchte ich 8 erhalten. => 8NS

Dieser Code funktioniert schon mal ganz gut. Danke für den Link!
In meinem Fall werden die Werte max. 8-10 NS haben.

Delphi-Quellcode:

function GetDecimalPlaces(AValue: Double): Integer;
const
  e = 0.0000000001;
var
  r: Extended;
begin
  Result := 0;

  if AValue < 0 then
    AValue := AValue * -1;

  r := Int(AValue);
  while ((Frac(AValue) <> 0) and ((AValue - r) > e)) do
  begin
    Inc(Result);
    AValue := AValue * 10;
    r := Int(AValue+e);
  end;
end;

[EWeiss]

Warum so kompliziert?
Ein einfaches Splitten.

Delphi-Quellcode:

function GetLength(Value: Double): Integer;
var
  so: Integer;
  tResult: string;
begin

  tResult := FloatToStr(ABS(Value));
  so := InStr(1, tResult, ',');
  if (so <> 0) then
  begin
    Result := Length(MidStr(tResult, so + 1, Length(tResult)));
  end;
end;

Delphi-Quellcode:

LenValue := GetLength(4512985.95);

Bei mir sind es 2 nicht mehr nicht weniger.

gruss

[gammatester]

Zitat:

Zitat von AndyDF (Beitrag 1413089)

Nicht die exakte Darstellung. Nur die Anzahl der NS meiner gerundeten Double Zahl.
Also bei der Zahl 4512985.95 möchte ich 2 erhalten. => 2NS.
Bei der Zahl 0.00000023 möchte ich 8 erhalten. => 8NS

Das Problem ist doch, dass die Zahlen nicht exakt dargestellt werden können und die auf die nächste Fließkommazahlen gerundeten Werte so viel Nachkommastellen haben. Damit drehst Du Dich im Kreis: Wenn Du schon vorher die gewünschte Stellenzahl für die Formatierung hast, braucht Du sie nicht zu bestimmen. Wenn Du die Zahl als String hast, kannst Du einfach zählen.

[AndyDF]

Zitat:

Zitat von EWeiss (Beitrag 1413090)

Warum so kompliziert?
Ein einfaches Splitten.

Delphi-Quellcode:

function GetLength(Value: Double): Integer;
var
  so: Integer;
  tResult: string;
begin

  tResult := FloatToStr(ABS(Value));
  so := InStr(1, tResult, ',');
  if (so <> 0) then
  begin
    Result := Length(MidStr(tResult, so + 1, Length(tResult)));
  end;
end;

Delphi-Quellcode:

LenValue := GetLength(4512985.95);

Bei mir sind es 2 nicht mehr nicht weniger.

gruss

Kommt aber leider bei:

GetLength(0.00000023)

schon an seine Grenzen...

[EWeiss]

Zitat:

Zitat von AndyDF (Beitrag 1413097)

Zitat:

Zitat von EWeiss (Beitrag 1413090)

Warum so kompliziert?
Ein einfaches Splitten.

Delphi-Quellcode:

function GetLength(Value: Double): Integer;
var
  so: Integer;
  tResult: string;
begin

  tResult := FloatToStr(ABS(Value));
  so := InStr(1, tResult, ',');
  if (so <> 0) then
  begin
    Result := Length(MidStr(tResult, so + 1, Length(tResult)));
  end;
end;

Delphi-Quellcode:

LenValue := GetLength(4512985.95);

Bei mir sind es 2 nicht mehr nicht weniger.

gruss

Kommt aber leider bei:

GetLength(0.00000023)

schon an seine Grenzen...

Ja nun das ist das Problem was @Sherlock schon angesprochen hat.

Zitat:

Das Thema ist aufgrund der internen Darstellung von Gleitkommazahlen nicht ganz ungefährlich.

Es liegt doch an dir einfach nur den Double wert korrekt zum String zu konvertieren.
Danach ist es so wie @gammatester sagte..

Zitat:

Wenn Du die Zahl als String hast, kannst Du einfach zählen.

gruss

[AndyDF]

Zitat:

Zitat von EWeiss (Beitrag 1413098)

Es liegt doch an dir einfach nur den Double wert korrekt zum String zu konvertieren.

Ja genau, hier habe ich noch keine Lösung. Dann wäre das Zählen natürlich einfach.
Wie konvertiere ich einen Double-Wert in einen String, so das dieser immer passt.

d.h.:
- keine Darstellung wie "2,3E-7"
- keine zusätzlichen Stellen außer die gewünschten NS

Wenn im Double:
- 0.00000023 steht, soll der String: "0.00000023" sein

Für beliebige (gerundete) Double Werte.

Edit:
Die gewünschte String-Repräsentation bekomme ich schon hin:
FloatToStrF(AValue,ffFixed,15,DecimalPlaces);

Aber hierfür fehlt mir genau die Information der Nachkommastellen (DecimalPlaces).

[bcvs]

Ich denke, du musst dir überlegen, wieviele Nachkommastellen dein Wert maximal haben kann. Dann auf diese Anzahl Stellen gerundet in einen String konvertieren und die Nachkommastellen zählen.

[gammatester]

[QUOTE=AndyDF;1413102]

Zitat:

Zitat von EWeiss (Beitrag 1413098)

Wenn im Double:
- 0.00000023 steht, soll der String: "0.00000023" sein

Noch ein letzes Mal: Es gibt kein Double, das 0.00000023 enthält, das nächste darstellbare Double ist:

0.000000229999999999999994886021640293216616868221 535696648061275482177734375

Was willst Du denn zB für 1e-100 sehen? Das wirst Du wahrscheinlich mit Delphi-Bordmitteln nicht im Fix-Format darstellen können.

@bcvs: Die kleinste Doublezahl hat 1074 Nachkommastellen.

[himitsu]

Und nun nur noch ein paar böse Stringmisshandlungen, als schlechte Beispiele für eine einzeilige Lösung.

Delphi-Quellcode:

EinStringMitMöglichstWenigenNachkommastellen := MyDouble.ToString(ffFixed, 15, 18).TrimRight([0]).TrimRight([FormatSettings.DecimalSeparator]);

AnzahlDerNachkommastellen := ReverseString(MyDouble.ToString(ffFixed, 15, 18).TrimRight([0])).IndexOf(FormatSettings.DecimalSeparator);  // Reverse fehlt leider im StringHelper

[AndyDF]

Zitat:

Zitat von himitsu (Beitrag 1413110)

Und nun nur noch ein paar böse Stringmisshandlungen, als schlechte Beispiele für eine einzeilige Lösung.

Delphi-Quellcode:

EinStringMitMöglichstWenigenNachkommastellen := MyDouble.ToString(ffFixed, 15, 18).TrimRight([0]).TrimRight([FormatSettings.DecimalSeparator]);

AnzahlDerNachkommastellen := ReverseString(MyDouble.ToString(ffFixed, 15, 18).TrimRight([0])).IndexOf(FormatSettings.DecimalSeparator);  // Reverse fehlt leider im StringHelper

Danke. So ähnlich habe ich jetzt auch meine Lösung - die für meinen Fall zumindest erstmal reicht.
Allerdings ist dein Ansatz mit TrimRight() deutlich eleganter als meine Schleife. :-)

[bcvs]

Zitat:

Zitat von gammatester (Beitrag 1413106)

@bcvs: Die kleinste Doublezahl hat 1074 Nachkommastellen.

Schon klar, aber um die geht es ja hier nicht. Aber wenn ich den Weg über eine String-Umwandlung gehe, muss ich mir vorher überlegen, wieviele Nachkommastellen mein Wert maximal haben könnte. Bei der Verwendung von .ToString wie in Himitsus Beispiel sind es max 18.

[EWeiss]

Zitat:

Und nun nur noch ein paar böse Stringmisshandlungen

Viele Wege führen nach Köln.
Ob ein oder Mehrzeiler spielt doch keine rolle.
Zudem solltest du mal differenzieren.. welche Delphi Version verwendet wird.
Unter D2010 gibt es kein "MyDouble.ToString" oder "MyDouble.ToString(ffFixed, 15, 18).TrimRight"
Du solltest also nicht pauschal von deinen Begebenheiten auf andere schließen.

Ich hätte meine Variante auch als Einzeiler erstellen können nur wie gesagt D2010 kennt keinen StringHelper in welcher Form auch immer.

Zitat:

Noch ein letzes Mal: Es gibt kein Double, das 0.00000023 enthält, das nächste darstellbare Double ist:

Das Zitat!

Zitat:

Wenn im Double:
- 0.00000023 steht, soll der String: "0.00000023" sein

war nicht von mir..

Zitat:

Die gewünschte String-Repräsentation bekomme ich schon hin:
FloatToStrF(AValue,ffFixed,15,DecimalPlaces);

Daran hatte ich auch gedacht..
Nur wenn ich es so gemacht hätte erübrigt sich die frage nach der Anzahl der Nachkommastellen.
Weil du diese dann MAX selbst festlegst.
Wie in dem Fall

Delphi-Quellcode:

MyDouble.ToString(ffFixed, 15, 18)

18!

Du kennst dann die Maximale Nachkommastellen warum dann noch ermitteln.

gruss

[himitsu]

Für die Funktionen aus den etwas neueren Helpern gibt es auch entsprechende "alte" Pascalfunktionen, die zufällig oftmals gleich/ähnlich heißen.

Die prozeduale Syntax sähe z.B. so aus.

Delphi-Quellcode:

EinStringMitMöglichstWenigenNachkommastellen := TrimRight(TrimRight(FloatToStrF(MyDouble, ffFixed, 15, 18), ['0']), [FormatSettings.DecimalSeparator]);

AnzahlDerNachkommastellen := Pos(FormatSettings.DecimalSeparator, ReverseString(TrimRight(FloatToStrF(MyDouble, ffFixed, 15, 18), [0]))) - 1;

// mir Leerzeichen für das Trim
AnzahlDerNachkommastellen := Pos(FormatSettings.DecimalSeparator, ReverseString(TrimRight(ReplaceStr(FloatToStrF(MyDouble, ffFixed, 15, 18), '0', ' ')))) - 1;

Schade ist nur, dass Trim/TrimRight/TrimLeft der StrUtils nur Leer- und Steuerzeichen kennen, aber für TrimRight wird es bestimmt auch irgendwo eine alternative Funktion geben.


Nja, einige der bekannten String-Funktionen fehlt noch im Helper und dafür gibt es auch ein bissl was Neues, welches die Prozedualen noch nicht kennen.



Vorteil der Helper ist, dass Funktionen in der Reihenfolge ihrer Anwendung im Code stehen, also hintereinander.
Beim Prozedualen stehen sie in umbekehrter Reihenfolge, mit dem Result des Vorgängers als Parameter.

[EWeiss]

Jo so wäre es auch gegangen ;)

PS:

Zitat:

Vorteil der Helper ist,

Finde es gut das diese in Delphi portiert wurden.. kenne es auch nicht anders unter C++.
Hat schon seine Vorteile.

gruss