Maßeinheiten als Typen

[TiGü]

Zitat von Ghostwalker:

Delphi-Quellcode:

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

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

Wirklich? Ein ganzzahliger negativer Wertebereich? Für Gewicht?

"Ich hätte gerne minus 3 kg Gehacktes!"

Hoffentlich sieht kein Kollege von dir diesen Thread.

[freimatz]

Zitat von TiGü:

Wirklich? Ein ganzzahliger negativer Wertebereich? Für Gewicht?
"Ich hätte gerne minus 3 kg Gehacktes!"

Das bedeutet dann "Ich würde gerne 3 kg Gehacktes zurückgeben."
Wirft zwar eine ENotHygienicException, aber was solls

[Ghostwalker]

@TiGü

Wie ich bereits, gefühlte 1000 mal geschrieben hab, ist das ein Beispiel. Ob du nun Gewichte, Zeit, Längen oder Engström nutzt ist fürs prinzipielle Vorgehen relativ wurscht.

@freimatz

Nein, da es kein "class const" gibt. Um die umrechnerei in den Class Operatoren unter zu kriegen, muss man den Umweg über "class var" in Verbindung mit dem Class Constructor gehen. Emba hats in TTimespan z.B. auch so gemacht.

[Uwe Raabe]

Zitat von Ghostwalker:

Nein, da es kein "class const" gibt.

Was würde denn dann eine class const Konstante von einer gemeinen const Konstante unterscheiden?

Delphi-Quellcode:

  TGewicht = Record
  private const
    GrammPerKilo = 1000;
    GrammPerTonne = 1000+GrammPerKilo;
    GrammPerMegat = 1000*1000*GrammPerTonne;
  End;

[Raible]

Hallo zusammen,

ich habe mal einen record für Werte mit SI-Einheit umgesetzt.

Code:

  
TSIValue = record
  Value    : double;
  UnitExpr : TSIUnitExpression;
  ...

TSIUnitExpression = record
private
  FUnitArray :TSIUnitArray;  
  ...

TSIUnitArray = TArray<TSIUnit>;

TSIUnit = record
  Praefix   :TSIPraefix;
  UnitTyp   :TSIUnitTyp;
  Power     :shortint;
  ...

  {$SCOPEDENUMS ON}
  TSIPraefix = (
    Yotta,
    Zetta,
    Exa,
    Peta,
    Tera,
    Giga,
    Mega,
    Kilo,
    Hekto,
    Deka,
    None,
    Dezi,
    Zenti,
    Milli,
    Mikro,
    Nano,
    Piko,
    Femto,
    Atto,
    Zepto,
    Yokto);

  TSIUnitTyp = (
    None,

    //SI Basiseinheiten
    Metre,
    Gramm,
    Second,
    Ampere,
    Kelvin,
    Mole,
    Candela,

    //nicht SI Basiseinheiten
    Euro,

    //Abgeleitete SI-Einheiten
    Newton,
    Joule,
    Watt,
    Coulomb,
    Volt,
    Ohm,
    Farad,
    &Pascal,
    Bar
   );
  {$SCOPEDENUMS OFF}

die Einheit TSIUnit setzt sich dabei aus einem Einheitentyp (m, sec, g, ...), einem Faktor (TSIPraefix G, M, k, ...) und einer Potenz zusammen. Die Potenz ist wichtig für zB. m² oder für Einheiten im Nenner.

TSIUnitExpression definiert eine Liste von TSIUnit die miteinander Multipliziert die eigentliche Einheit darstellt.
Hier kann dann z.B N = kg*m/sec² realisiert werden.

Möchte man zwei TSIValue miteinander verrechnen müssen auch die TSIUnitExpression mathematisch korrekt verrechnet werden.

Beispiel:

Code:

var
  Masse:TSIValue;
  Laenge:TSIValue;
  Zeit:TSIValue;
  Kraft:TSIValue;
  Text:string;

begin
  Masse := '5 kg'
  Laenge:= '123 cm';
  Zeit  := '10 s';
  Kraft := Masse * Laenge / (Zeit * Zeit);
  Text  := Kraft; // Text='0.06 m*kg/s²'

Bei Interesse könnte ich den Code
auch zur Verfügung stellen.
Allerdings benötige ich dann etwas
Hilfe bei Lizenzierungsfragen.

[Ghostwalker]

Zitat von Uwe Raabe:

Zitat von Ghostwalker:

Nein, da es kein "class const" gibt.

Was würde denn dann eine class const Konstante von einer gemeinen const Konstante unterscheiden?

Delphi-Quellcode:

  TGewicht = Record
  private const
    GrammPerKilo = 1000;
    GrammPerTonne = 1000+GrammPerKilo;
    GrammPerMegat = 1000*1000*GrammPerTonne;
  End;

Ganz einfach.

Bei "private const" stehen die Konstanten nur in einer konkreten Instanz (sprich Variable) zur Verfügung.
Folglich (und das hat mir der Delphi-Compiler recht deutlich mitgeteilt) kann man sie so nicht in den
Operatoren verwenden.

Also hab ich mir ein Beispiel an Emba genommen und das ganze wie oben umgesetzt. Damit kann ich die Konstanten auch in den Operatoren verwenden.

[Uwe Raabe]

Zitat von Ghostwalker:

Bei "private const" stehen die Konstanten nur in einer konkreten Instanz (sprich Variable) zur Verfügung.
Folglich (und das hat mir der Delphi-Compiler recht deutlich mitgeteilt) kann man sie so nicht in den
Operatoren verwenden.

Also mein Compiler (10.2.3) findet das hier vollkommen OK:

Delphi-Quellcode:

  TGewicht = record
  private
    FValue : Extended;
  private const
    GrammPerKilo = 1000.0;
    GrammPerTonne = 1000.0*GrammPerKilo;
    GrammPerMegat = 1000.0*1000.0*GrammPerTonne;
  public
     Class Operator Implicit(const Value:TTonne):TGewicht;
  end;

class operator TGewicht.Implicit(const Value: TTonne): TGewicht;
begin
  Result.FValue := Value*GrammPerTonne;
end;

[Ghostwalker]

Öhmm.....jup.....nochmal getestet...nu tuts.....komisch.

Am Rande

Delphi-Quellcode:

Type
  TGramm = -xxxxxx .. xxxxxx
  usw.

  TGewicht = record
    //wie gehabt
    Class Oporator 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;


IMPLEMENTATION

Class Opertator TGewicht.Implicit(const value:int64):TGewicht;
begin
  result.fvalue := value;
end;

Class Opertator TGewicht.Implicit(const value:TGewicht):Int64;
begin
  result := value.fvalue;
end;

Class Opertator TGewicht.Implicit(const value:TGramm):TGewicht;
begin
  result.fvalue := value;
end;

Class Opertator TGewicht.Implicit(const value:TKilo):TGewicht;
begin
  result.fvalue := value*GrammPerKilo;
end;

Class Opertator TGewicht.Implicit(const value:TTonne):TGewicht;
begin
  result.fvalue := value*GrammPerTonne;
end;

In die IDE zeigt mir hier einen Fehler im Implementation Abschnitt an, das der Bezeichner redifiniert wird. Allerdings erst bei Implicit(const value:TKilo). Der Compiler läuft ohne Probleme durch, und lt. meinen
Unittests wird das ganze auch korrekt gehandhabt.