Einheiten parsen

[BUG]

Zitat von Bjoerk:

Kann man da nicht mit Sets oder irgendwie bitweise was rechen, sonst tippt man sich ja den Wolf?

Deswegen reden wir ja über die Basiseinheiten und abgeleiteten Einheiten
Zum Beispiel mit den Array aus Beitrag #9 lässt sich dass doch ganz komfortabel machen.

EDIT: Hast du das Ganze per Hand heruntergeschrieben?

[Bjoerk]

Zitat von BUG:

EDIT: Hast du das Ganze per Hand heruntergeschrieben?

Nee. Aber selbst das kopieren war schon Arbeit

Deinen Ansatz #9 hab ich nich kapiert. Montags kapier ich noch weniger als sonst.. Kannst nochmal etwas erläutern?

[BUG]

Deine Basiseinheiten definierst du weiter als Aufzählungstyp:

Delphi-Quellcode:

type
  TFundamentalUnit = (fuKN, fuM);

Die zusammengesetzten Einheiten lassen sich auch in Exponentenschreibweise aufschreiben. Die Exponenten kannst du dann einfach in einem Array speichern.

Delphi-Quellcode:

type
  TDerivedUnit = array[fuKN..fuM] of Integer.

TUnitStyle	Exponentenschreibweise	Arrayinhalt
usNone	kN^0 * m^0	0, 0
usKNdivM3	kN^1 * m^(-3)	1, -3
usKNM	kN^1 * m^1	1, 1
sKN	kN^1 * m^0	1, 0
usM3	kN^0 * m^3	0, 3

Zum Beispiel die Multiplikation kann man nun ganz einfach auf eine Addition der Array-Einträge abbilden (quasi mit den Rechenregeln für Potenzen):

1. usM3 * usKNdivM2
2. (kN^0 * m^3) * (kN^1 * m^(-2))
3. (kN^(0+1) * m^(3-2)
4. kN^1 * m^1
5. usKNM

Ich hoffe das ist verständlicher

[Bjoerk]

Geht sehr gut. Danke Robert.

Delphi-Quellcode:

type
  TUnitBase = (fuKN, fuM);
  TUnitStyle = (usNone, usKNdivM3, usKNdivM2, usKNdivM, usKNM, usKN, usM3, usM2, usM);

  TUnits = class
  private
    FItems: array[usNone..usM, fuKN..fuM] of integer;
    function GetValues(Index: TUnitStyle): double;
    function GetAsString(Index: TUnitStyle): string;
  public
    property Values[Index: TUnitStyle]: double read GetValues;
    property AsString[Index: TUnitStyle]: string read GetAsString;
    function GetPlus(const A, B: TUnitStyle): TUnitStyle;
    function GetMinus(const A, B: TUnitStyle): TUnitStyle;
    function GetDiv(const A, B: TUnitStyle): TUnitStyle;
    function GetMult(const A, B: TUnitStyle): TUnitStyle;
    constructor Create;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TUnits }

constructor TUnits.Create;
begin
  FItems[usNone, fuKN] := 0;
  FItems[usNone, fuM] := 0;

  FItems[usKNdivM3, fuKN] := 1;
  FItems[usKNdivM3, fuM] := -3;

  FItems[usKNdivM2, fuKN] := 1;
  FItems[usKNdivM2, fuM] := -2;

  FItems[usKNdivM, fuKN] := 1;
  FItems[usKNdivM, fuM] := -1;

  FItems[usKNM, fuKN] := 1;
  FItems[usKNM, fuM] := 1;

  FItems[usKN, fuKN] := 1;
  FItems[usKN, fuM] := 0;

  FItems[usM3, fuKN] := 0;
  FItems[usM3, fuM] := 3;

  FItems[usM2, fuKN] := 0;
  FItems[usM2, fuM] := 2;

  FItems[usM, fuKN] := 0;
  FItems[usM, fuM] := 1;
end;

function TUnits.GetValues(Index: TUnitStyle): double;
begin
  Result := IntPower(FItems[Index, fuKN], FItems[Index, fuM]);
end;

function TUnits.GetAsString(Index: TUnitStyle): string;
begin
  case Index of
    usKNdivM3:
      Result := 'kN/m3';
    usKNdivM2:
      Result := 'kN/m2';
    usKNdivM:
      Result := 'kN/m';
    usKNM:
      Result := 'kNm';
    usKN:
      Result := 'kN';
    usM3:
      Result := 'm3';
    usM2:
      Result := 'm2';
    usM:
      Result := 'm';
    else
      Result := '';
  end;
end;

function TUnits.GetPlus(const A, B: TUnitStyle): TUnitStyle;
begin
  if A = B then
    Result := A
  else
    Result := usNone;
end;

function TUnits.GetMinus(const A, B: TUnitStyle): TUnitStyle;
begin
  if A = B then
    Result := A
  else
    Result := usNone;
end;

function TUnits.GetMult(const A, B: TUnitStyle): TUnitStyle;
var
  I: TUnitStyle;
  KN, M: integer;
begin
  Result := usNone;
  KN := FItems[A, fuKN] + FItems[B, fuKN];
  M := FItems[A, fuM] + FItems[B, fuM];
  for I := Low(TUnitStyle) to High(TUnitStyle) do
    if (KN = FItems[I, fuKN]) and (M = FItems[I, fuM]) then
    begin
      Result := I;
      Break;
    end;
end;

function TUnits.GetDiv(const A, B: TUnitStyle): TUnitStyle;
var
  I: TUnitStyle;
  KN, M: integer;
begin
  Result := usNone;
  KN := FItems[A, fuKN] - FItems[B, fuKN];
  M := FItems[A, fuM] - FItems[B, fuM];
  for I := Low(TUnitStyle) to High(TUnitStyle) do
    if (KN = FItems[I, fuKN]) and (M = FItems[I, fuM]) then
    begin
      Result := I;
      Break;
    end;
end;

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);
var
  Units: TUnits;
  A, B, C: TUnitStyle;
begin
  Units := TUnits.Create;
  try
    A := usM3;
    B := usKNdivM2;
    C := Units.GetMult(A, B);
    ShowMessage(Units.AsString[C]);
    A := usKN;
    B := usM;
    C := Units.GetDiv(A, B);
    ShowMessage(Units.AsString[C]);
  finally
    Units.Free;
  end;
end;

[Sailor]

Und warum nicht einen stinknormalen Expression-Parser um Einheiten erweitern und die Umrechnung in die Semantikroutinen legen? Hätte auch noch den Vorteil einer komfortablen Fehlerbehandlung.

[Bjoerk]

Wenn du uns noch kurz sagst wo hier eine Exception auftreten kann?

[BUG]

Zitat von Bjoerk:

Geht sehr gut.

Ich hätte zwar versucht, die vordefinierten abgeleiteten Einheiten (TUnitStyle) ganz loszuwerden; aber schön das es dir geholfen hat

Zitat von Bjoerk:

Wenn du uns noch kurz sagst wo hier eine Exception auftreten kann?

Ein Kandidat wäre das Addieren mit unterschiedlichen Einheiten: Dein Code verwirft die Einheiten dann einfach, was zu merkwürdigen Ergebnissen führen könnte.

[Dejan Vu]

Zitat von Sailor:

Und warum nicht einen stinknormalen Expression-Parser um Einheiten erweitern und die Umrechnung in die Semantikroutinen legen? Hätte auch noch den Vorteil einer komfortablen Fehlerbehandlung.

Folgt diesem Weg. Der Von Bjoerk scheitert ja schon, wenn ich mal andere Einheiten nehmen will, z.B. PS, inch. Natürlich sollte man dem Evaluator (bzw. den 'Semantikroutinen') noch die Rechenregeln für Einheiten beibrigen (Basiseinheiten, Kürzen, Ersetzen: N*m/s => J etc.)

Ob dann etwas Sinnvolles herauskommt, wird sich noch zeigen müssen.

[Sailor]

So würde ich anfangen:

Code:

Expr     -> Left_Expr '+' Right_Expr
         => "IF Compatible($Left_Expr.Unit,$Right_Expr.Unit)= True
              THEN $Expr := Normalize($Left_Expr.Value) + Normalize($Right_Expr.Value)
              ELSE Error(UnitsNotCompatible)"
          | Factor Unit

Factor   -> <Number>
          | '(' Expression ')'

Unit     ->
          | m
          | cm
          | g
          | kg

Compatible ist ein 2-dimensionales Feld ARRAY[TUnit,TUnit] OF Boolean, der Eintrag [cm,m] wird auf True gesetzt, [g,cm] auf False. Normalize ist ein ARRAY[TUnit,TUnit] OF Real und enthält die Umrechnungsfaktoren in die Darstellungeinheit: [cm,m] = 0.01,[kg,g] = 1000. Die Eingabe "30 knirsch" wird von der kontextfreien Fehlerbehandlung abgewiesen, die Eingabe "30g + 40 cm" von der kontext-sensitiven. Die Hinzunahme weiterer Einheiten bedeutet eine zusätzliche Zeile in der Grammatik und zwei Änderungen in Compatible und Normalize.
Für das Rechnen und Umformen mit abgeleiteten Einheiten bietet sich ein endlicher Automat an, der über dem kompletten Syntaxbaum arbeitet.