Maßeinheiten als Typen

[Ghostwalker]

@Schokohase

Mein Post bezog sich insbesondere auf diese Aussage:

Zitat von TiGü:

Du musst nur verstehen das Kilogramm, Gramm, Mikrogramm, Nanogramm K E I N E verschiedenen Maßeinheiten sind.

und die ist schlicht [Zensiert].

Klar sind 1000g = 1Kg [B]ABER] 1000g <> 1000Kg <> 1000m <> 1000V

[TiGü]

Zitat von Ghostwalker:

@Schokohase

Mein Post bezog sich insbesondere auf diese Aussage:

Zitat von TiGü:

Du musst nur verstehen das Kilogramm, Gramm, Mikrogramm, Nanogramm K E I N E verschiedenen Maßeinheiten sind.

und die ist schlicht [Zensiert].

Klar sind 1000g = 1Kg [B]ABER] 1000g <> 1000Kg <> 1000m <> 1000V

Man könnte auch sagen [zensiert] = richtig!

Sowas wie 1000g <> 1000kg zog niemand in Zweifel, da 1000 g ungleich zu 1000000 g ist (bzw. 1 kg ungleich 1000 kg).
Du denkst - oder es kommt uns allen nur so vor - das die MaßEINHEIT Gramm und Kilogramm zwei verschiedene Paar Schuhe sind.
Das ist aber nicht so. Das eine Schuh-Paar ist nur "größer", aber sonst das selbe (!) Modell.

Einen gängigen Weg, wie man das mit Operatoren im Record erschlagen kann, hast du im Laufe der letzten Seiten vielfach aufgezeigt bekommen.

[Ghostwalker]

Zitat von TiGü:

Du denkst - oder es kommt uns allen nur so vor - das die MaßEINHEIT Gramm und Kilogramm zwei verschiedene Paar Schuhe sind.

Jain. Ich denke ich hab mich da ein wenig zu Umgangssprachlich ausgedrückt.

Die Maßeinheiten Gramm und Kilogramm bezeichnen letztlich ein Gewicht. Der Unterschied besteht hier nur in der Granulierung oder dem Faktor mit Bezug zu den anderen Einheiten bei Gewichten.

Und richtig, es wurde ein Beispiel für die Impelentierung mit einem Typen genannt.

Leider konnte mir bisher keiner Erläutern, wo der Vorteil liegt, wenn man das als ein Typ implementiert (gegenüber der Implementierung durch einzelne Typen; den seh ich nämlich irgendwie nicht wirklich).

[TiGü]

Zitat von Ghostwalker:

Leider konnte mir bisher keiner Erläutern, wo der Vorteil liegt, wenn man das als ein Typ implementiert (gegenüber der Implementierung durch einzelne Typen; den seh ich nämlich irgendwie nicht wirklich).

Wahrscheinlich weil du nur dein reales Problem siehst (was nichts mit Gewicht zu tun hat?) und eine schlechte Analogie verwendest und uns hier mit dem Gewicht-Beispiel mental verhungern lässt?!

[Schokohase]

Zitat von Ghostwalker:

Leider konnte mir bisher keiner Erläutern, wo der Vorteil liegt, wenn man das als ein Typ implementiert (gegenüber der Implementierung durch einzelne Typen; den seh ich nämlich irgendwie nicht wirklich).

Na dann erstelle doch einfach deine 21 Typen (Centigram, Decagram, Decigram, Gram, Hectogram, Kilogram, Kilopound, Kilotonne, LongHundredweight, LongTon, Megapound, Megatonne, Microgram, Milligram, Nanogram, Ounce, Pound, ShortHundredweight, ShortTon, Stone, Tonne) oder sogar mehr, wenn da noch Bedarf besteht.

Ich nehme da nur einen und bin schon fertig. Warum wohl? Eben, weil es schneller geht und ich keinen Vorteil bei der Aufsplitung sehe.

[JasonDX]

Zitat von Ghostwalker:

Leider konnte mir bisher keiner Erläutern, wo der Vorteil liegt, wenn man das als ein Typ implementiert (gegenüber der Implementierung durch einzelne Typen; den seh ich nämlich irgendwie nicht wirklich).

Weil durch einzelne Typen jede Methode, die bspw. einen Gewichtsparameter hat, für jeden Typen für Gewicht überladen werden muss.
Einfaches Beispiel:

Delphi-Quellcode:

procedure doSomething(weight: TTon);
procedure doSomething(weight: TTonne);
procedure doSomething(weight: TKilogram);
procedure doSomething(weight: TGram);
procedure doSomething(weight: TMilligram);
procedure doSomething(weight: TMicrogram);
procedure doSomething(weight: TPound);
procedure doSomething(weight: TStone);
procedure doSomething(weight: TSlug);

// Aufruf:
doSomething(100 as TStone);

Im Gegensatz zu

Delphi-Quellcode:

procedure doSomething(weight: TWeight);

// Aufruf:
doSomething(TWeight.getStones(100));

Und das ganze wird schlimmer, wenn du Parameter kombinieren willst:

Delphi-Quellcode:

function computeSpeed(distance: TYards; time: TSeconds): TMeterPerSecond
function computeSpeed(distance: TMeters; time: TSeconds): TMeterPerSecond
function computeSpeed(distance: TMillimeters; time: TSeconds): TMeterPerSecond
function computeSpeed(distance: TKilometers; time: TSeconds): TMeterPerSecond
function computeSpeed(distance: TInches; time: TSeconds): TMeterPerSecond
function computeSpeed(distance: TMiles; time: TSeconds): TMeterPerSecond

function computeSpeed(distance: TYards; time: TMinutes): TMeterPerSecond
function computeSpeed(distance: TMeters; time: TMinutes): TMeterPerSecond
function computeSpeed(distance: TMillimeters; time: TMinutes): TMeterPerSecond
function computeSpeed(distance: TKilometers; time: TMinutes): TMeterPerSecond
function computeSpeed(distance: TInches; time: TMinutes): TMeterPerSecond
function computeSpeed(distance: TMiles; time: TMinutes): TMeterPerSecond

function computeSpeed(distance: TYards; time: THours): TMeterPerSecond
function computeSpeed(distance: TMeters; time: THours): TMeterPerSecond
function computeSpeed(distance: TMillimeters; time: THours): TMeterPerSecond
function computeSpeed(distance: TKilometers; time: THours): TMeterPerSecond
function computeSpeed(distance: TInches; time: THours): TMeterPerSecond
function computeSpeed(distance: TMiles; time: THours): TMeterPerSecond

[Mikkey]

Eine Anregung von jenseits des Delphi-Tellerrands:
Es gibt für C++ eine Bibliothek, die Deine Aufgabenstellung (m.E. perfekt) aufgreift:

https://www.boost.org/doc/libs/1_37_...ost_units.html

Ich habe die selbst schon verwendet und finde den Ansatz sehr gut.

Vielleicht kannst Du daraus ein paar Anregungen mitnehmen und Dir etwas erstellen, was (natürlich) nicht so komplett ist, aber den Bedarf erfüllt.

[TigerLilly]

Hmm. Zurück auf den Boden. Ich kenn das, was der TE will, zB aus dem Bereich von Rezepturen. Da hast du Zutaten, mache in GRAMM, manche in KILOGRAMM, vielleicht sogar manche in LITER.
Wenn man das Gesamtgewicht der Rezeptur wissen will, muss man addieren + da wäre es natürlich ganz cool wenn schon der Compiler dafür sorgt, dass GRAMM und KILOGRAMM von der richtigen Methode addiert würden.

Aber wie ich auch schon gesagt habe, scheint mir das zu umständlich und auch knapp daneben gezielt. Denn ich habe ja immer eine Kombination aus Wert+Einheit + so würde ich das auch meinen Methoden übergeben:
Addiere(120, 'KG', 12, 'GRAMM');
AddiereKGzuGRAMM(120,12); // da kann ich sogar Typsicherheit haben! type TKG = type Float;
ToGramm(TKG):TGRAMM; // wieder: Typsicher
ToGramm(TMG):TGRAMM; // wieder: Typsicher + overloaded

[Schokohase]

Zitat von TigerLilly:

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;

function TMass.AsBaseUnit(): Extended;
var
  x:Extended;
begin
  x := Value;
  case FUnit of
    TMass.Gram: Result := x / 1e3;
    TMass.Kilogram: Result := x;
    TMass.Milligram: Result := x / 1e6;
    TMass.Tonne: Result := x * 1e3;
  else
    raise ENotImplementedException.Create('Fehler');
  end;
end;

function TMass.AsBaseNumericType(AUnit: TMassUnit): Extended;
var
  x: Extended;
begin
  if (AUnit = FUnit)
    Exit(FValue);

  x := AsBaseUnit();

  case AUnit of
    TMass.Gram: Result := x * 1e3;
    TMass.Kilogram: Result := x;
    TMass.Milligram: Result := x * 1e6;
    TMass.Tonne: Result := x / 1e3;
  else
    raise ENotImplementedException.Create('Fehler');
  end;
end;

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

[KodeZwerg]

Zitat von Schokohase:

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.