Maßeinheiten als Typen

[Schokohase]

Zitat:

Zitat von KodeZwerg (Beitrag 1415762)

Zitat:

Zitat von Schokohase (Beitrag 1415761)

In diesem Record kann man jetzt problemlos die Rechenoperationen und Umrechnungen implementieren und man hat einen Typen für das Gewicht.

roter text, du hast mir meinen gedanken geklaut, wollte fast das gleich schreiben da der komplette thread letztendlich auf sowas hinaus läuft, bin ich jedenfalls auch der meinung.

Also von dir habe ich das ganz bestimmt nicht, sondern von hier (und den Link zu dem Projekt hatte ich auch schon gepostet)

[KodeZwerg]

Du hast mich missverstanden, macht ja nichts, ich wollte nicht sagen das Du etwas von mir hast, ich wollte fast das selbe schreiben, sagte ich ja.
Gute Hilfe, weiter so.

[dummzeuch]

Zitat:

Zitat von Schokohase (Beitrag 1415761)

Zitat:

Zitat von TigerLilly (Beitrag 1415759)

Denn ich habe ja immer eine Kombination aus Wert+Einheit

Genau, es ist eine Kombination, die man z.B. auch so abbilden kann

Delphi-Quellcode:

TMassUnit = (Undefined, Gram, Kilogram, Milligram, Tonne);

TMass = record
private
  FValue: Extended; // Wert
  FUnit: TMassUnit; // Einheit
public
  constructor Create(AValue: Extended; AUnit: TMassUnit);
  property Value: Extended read FValue;
  property &Unit: TMassUnit read FUnit;
private
  function AsBaseUnit(): Extended;
  function AsBaseNumericType(AUnit: TMassUnit);
public
  property Grams: Extended index TMassUnit.Gram read AsBaseNumericType;
  property Kilograms: Extended index TMassUnit.Kilogram read AsBaseNumericType;
  property Milligrams: Extended index TMassUnit.Milligram read AsBaseNumericType;
  property Tonnes: Extended index TMassUnit.Tonne read AsBaseNumericType;
end;

In diesem Record kann man jetzt problemlos die Rechenoperationen und Umrechnungen implementieren und man hat einen Typen für das Gewicht.

Aber es ist immernoch zu kompliziert. Wieso nicht den Wert immer in der Basiseinheit speichern und beim Zuweisen bzw. Auslesen aus diesem umrechnen? Die von Dir gewählte Implementation hat höchstens den Vorteil, dass, wenn man in derselben Einheit schreibt und dann ausliest, keine Umrechnungstattfindet, also auch keine Rechenungenauigkeiten auftreten.

Letzteres ist ein nicht zu unterschätzendes Problem, wenn es auf Genauigkeit ankommt. Da wäre es evtl. sinnvoll, zum Speichern des Wertes statt eines Fließkommatyps einen Integer in einer Einheit zu verwenden, die klein genug ist, um alles notwendige abzubilden, z.B. 1 mg oder auch 1 ug (vorausgesetzt kleinere Massen interessieren nicht). Oder man kombiniert einen Integer mit einem dezimalen Exponenten. d.h. Bei Zuweisung von 1 mg speichert man 1 als Wert und -1000000 als Exponent. Liest man dann den Wert in g aus, erhält man 0.001.

twm

[freimatz]

Zitat:

Zitat von dummzeuch (Beitrag 1415774)

Letzteres ist ein nicht zu unterschätzendes Problem, wenn es auf Genauigkeit ankommt. Da wäre es evtl. sinnvoll, zum Speichern des Wertes statt eines Fließkommatyps einen Integer in einer Einheit zu verwenden, die klein genug ist, um alles notwendige abzubilden, z.B. 1 mg oder auch 1 ug (vorausgesetzt kleinere Massen interessieren nicht).

Versteh ich nicht. Ein Fließkommatyp ist doch genauer als ein Integer? (Zumindest wenn man Double nimmt.)

[Schokohase]

@dummzeuch

Es ist zu kompliziert, dass der Typ exakt das speichert was man dem zugewiesen hat? Das ist nicht höchtens sondern genau der Vorteil dieser Implementierung. So gut wie keine Veränderung der zugewiesenen Daten (bis auf die allgemeine Problem mit den Fließkommazahlen).

Es geht hier auch nicht darum ein höchst exakt rechnendes System vorzustellen, sondern nur einen Typen, der so genau ist wie Delphi selber rechnet aber mit Dimensionen/Einheiten umgehen kann.

Aber man kann es ja auch wie folgt deklarieren:

Delphi-Quellcode:

TValueType = Extended;

TMassUnit = (Undefined, Gram, Kilogram, Milligram, Tonne);

TMass = record
private
  FValue: TValueType; // Wert
  FUnit: TMassUnit; // Einheit
public
  constructor Create(AValue: TValueType; AUnit: TMassUnit);
  property Value: TValueType read FValue;
  property &Unit: TMassUnit read FUnit;
private
  function AsBaseUnit(): TValueType;
  function AsBaseNumericType(AUnit: TMassUnit);
public
  property Grams: TValueType index TMassUnit.Gram read AsBaseNumericType;
  property Kilograms: TValueType index TMassUnit.Kilogram read AsBaseNumericType;
  property Milligrams: TValueType index TMassUnit.Milligram read AsBaseNumericType;
  property Tonnes: TValueType index TMassUnit.Tonne read AsBaseNumericType;
end;

dann implementierst du einen gaaaaaanz genauen Float-Type und tauscht den dort gegen Extended aus.

PS

Achja, ich vergaß noch einen (in meinen Augen) Vorteil:

Wenn man sich beim debuggen die lokalen Variablen anschaut, dann erscheint dort z.B.:

Code:

(15,Gram)

Finde ich persönlich eingängiger, als wenn dort lediglich

Code:

(0.015)

steht (die basiseinheit ist ja Kilogramm)

Und wenn man dann noch

Delphi-Quellcode:

ToString()

implementiert, dann ist es doch auch schön wenn dort 15g ausgegeben wird und eben nicht 0,015kg, eben immer so wie man es der Variablen auch zugewiesen hat.

[p80286]

Zitat:

Zitat von freimatz (Beitrag 1415775)

Zitat:

Zitat von dummzeuch (Beitrag 1415774)

Letzteres ist ein nicht zu unterschätzendes Problem, wenn es auf Genauigkeit ankommt. Da wäre es evtl. sinnvoll, zum Speichern des Wertes statt eines Fließkommatyps einen Integer in einer Einheit zu verwenden, die klein genug ist, um alles notwendige abzubilden, z.B. 1 mg oder auch 1 ug (vorausgesetzt kleinere Massen interessieren nicht).

Versteh ich nicht. Ein Fließkommatyp ist doch genauer als ein Integer? (Zumindest wenn man Double nimmt.)

Nö, ein Fießkommatyp ist immer eine Näherung, meist eine sehr genaue, aber eben eine Näherung.
vgl hierzu Currency!

Gruß
K-H

[freimatz]

Sorry versteh ich immer noch nicht. Nach http://docwiki.embarcadero.com/RADSt...e_Typenhttp:// hat ein Integer 32-Bit. Ein Double benötigt 64-Bit, davon hat die Mantisse 52 Bit. Das ist immer noch weit mehr als die 32 bei Integer. Ich kann jeden beliebigen Wert eines Integers in einem Double speichern und wieder herausholen ohne Verlust. Anders sieht es bei einem Int64 aus, der hat dann mehr als der Double.

Wir verwenden fast grundsätzlich Double, welche als Länge in Millimeter oder als Bogenmass definiert sind. Umgerechnet werden die nur bei der Ein- und Ausgabe.

[Ghostwalker]

Zitat:

Zitat von freimatz (Beitrag 1415802)

Sorry versteh ich immer noch nicht. Nach http://docwiki.embarcadero.com/RADSt...e_Typenhttp:// hat ein Integer 32-Bit. Ein Double benötigt 64-Bit, davon hat die Mantisse 52 Bit. Das ist immer noch weit mehr als die 32 bei Integer. Ich kann jeden beliebigen Wert eines Integers in einem Double speichern und wieder herausholen ohne Verlust. Anders sieht es bei einem Int64 aus, der hat dann mehr als der Double.

Wir verwenden fast grundsätzlich Double, welche als Länge in Millimeter oder als Bogenmass definiert sind. Umgerechnet werden die nur bei der Ein- und Ausgabe.

Jain.

Int64 hat, wie double auch, 64-Bit. Sein Ganzzahliger Wertebereich ist aber größer als der von Double. Dafür kann ich den kleineren Wertebereich von Double genauer auflösen. Alternativ kann man auch Extended verwenden, der dann 80 Bit(32-Bit win) hat und noch genauer auflöst.

Ob man nun Fließkomma oder Ganzzahlige Werte benutzt, kommt auf den Context an. u.U. ist auch eine Festkomma Aritmethik eine Option.

[Ghostwalker]

Ich hab den Vorschlag von Uwe Raabe mal aufgegriffen und das ganze testhalber mal wie folgt
aufgebaut:

Delphi-Quellcode:

TYPE
  TGramm = -9223372036854775807..9223372036854775807;
  TKilo  = -9223372036854775..9223372036854775;
  TTonne = -9223372036854..9223372036854;
  TMegat = -9223372036..9223372036;

  TGewicht = Record
    private
      fvalue : int64;

    strict private
      Class constructor Create; //<-- Hier werden die Classvars entsprechend belegt

    private class var
        GrammPerKilo : int64;
        GrammPerTonne: int64;
        GrammPerMegat: int64;

    public

       Class Operator Implicit(const value:int64):TGewicht;
       Class Operator Implicit(const value:TGewicht):int64;

       Class Operator Implicit(const value:TGramm):TGewicht;
       Class Operator Implicit(const value:TKilo):TGewicht;
       Class Operator Implicit(const value:TTonne):TGewicht;
       Class Operator Implicit(const value:TMegat):TGewicht;

       Class Operator Add(const left,right:TGewicht):TGewicht;
       Class Operator Subtract(const left,right:TGewicht):TGewicht;
  End;

Damit hätte ich die meisten Anforderungen eigentlich abgedeckt. Was meint ihr ?

[freimatz]

Welche Anforderungen? Die des Ausgangspostings? Dann meine ich Ja.
Bei den Anforderungen die ich an sowas hätte Nein. Wenn ich 1437 Gramm hätte und das als Kilogramm wollte, dann würde ich schon 1.437 Kilogramm wollen.

Die private class var verstehe ich nicht so recht. Reichen da nicht Konstanten?