Einheiten parsen

[Bjoerk]

Meine User würden gerne sowas eingeben können.
5,0 kN/m2 * 0,70 m / cos(30)

Die Idee war nun zwei Berechnungen durchzuführen:

1.) Die Einheiten rauslöschen und den Term herkömmlich parsen.
-> Parse(5,0 * 0,70 / cos(30))

2.) Die Term zu modifizieren und dann die Einheiten parsen.
-> UnitParse([kN/m2] / [m])

Mögliche Einheiten:
'kN/m3', 'kN/m2', 'kN/m', 'kNm/m', 'kNm', 'kN', 'm3', 'm2', 'm',
(Wann 'kNm/m' ebd ist und nicht kN kann ich vorher prüfen ('kNm/m' kann nur vorkommen wenn 'kNm' im Term vorhanden ist.))

Einheiten können nur in + - * / Operationen vorkommen.

Doch wie berechnet man das? Was nehm ich da für einen Typ? Kann man da irgendwie bitweise addieren? Hat da jemand eine Idee? Vom Ergebnis muß ja auch wieder auf die Einheit geschlossen werden können (MyTypToStr)?

[Sir Rufo]

Du musst dir das einfach nur anders vorstellen:

Code:

5,0 kN/m2 * 0,7 m

entspricht eben

Code:

5,0 * (kN) / ( (m)*(m) ) * 0,7 * (m)

Die Einheiten sind somit eigenständige Werte und müssen auch also solche behandelt werden.

Am Besten du erstellst dir so einen Einheiten-Typ (record) und einen EinheitWert-Typ (record) - ein Zahlwert und eine Einheit - und definierst die Rechenregeln.

[Bjoerk]

Zitat von Sir Rufo:

Am Besten du erstellst dir so einen Einheiten-Typ (record) und einen EinheitWert-Typ (record) - ein Zahlwert und eine Einheit - und definierst die Rechenregeln.

Ähm, hann ich nedd kapiert. Sorry..

[p80286]

Zitat von Sir Rufo:

Du musst dir das einfach nur anders vorstellen:

Code:

5,0 kN/m2 * 0,7 m

entspricht eben

Code:

5,0 * (kN) / ( (m)*(m) ) * 0,7 * (m)

Die Einheiten sind somit eigenständige Werte und müssen auch also solche behandelt werden.

Am Besten du erstellst dir so einen Einheiten-Typ (record) und einen EinheitWert-Typ (record) - ein Zahlwert und eine Einheit - und definierst die Rechenregeln.

du kannst aber noch einen Schritt weiter gehen:

Code:

5,0 * 0,7 (kN) / ( (m)*(m) ) * (m)

Code:

5,0 * 0,7 (kN) * (m) / ( (m)*(m) )

Code:

5,0 * 0,7 (kN)  /  (m)

Gruß
K-H

[Jens01]

Cool, sowas willst Du programmieren...
Ich verstehe das so, dass Du als Ergebnis eine Zahl hast und die Einheit dieser Zahl.
Ich würde auch die Einheiten von den Zahlenwerten trennen und dann in einem separaten Parser durchrechnen. Sowas wie "k" wie Kilo oder "M" wie Mega würde ich aber in der Zahlenberechnung lassen, da das ja eigentlich nur eine andere Exponentialschreibweise ist.
Und pass auf, dass das noch hinten heraus nicht unheimlich kompliziert wird.

[Bjoerk]

Ich glaub das Trennen ist nicht ganz einfach, besser in einem Rutsch?
Sir Rufo, meinst du so?

Delphi-Quellcode:

type
  TParserUnitStyle =
    (pusKNdivM3, pusKNdivM2, pusKNdivM, pusKNMdivM, pusKNM, pusKN, pusM3, pusM2, pusM);

  TParserUnit = record
  private
    FValue: TParserUnitStyle;
  public
    function GetPlus(const A, B: TParserUnit):TParserUnitStyle;
    function GetMinus(const A, B: TParserUnit):TParserUnitStyle;
    function GetDiv(const A, B: TParserUnit):TParserUnitStyle;
    function GetMult(const A, B: TParserUnit):TParserUnitStyle;
    property Value: TParserUnitStyle read FValue write FValue;
  end;

  TParserFloat = record
    Value: double;
    UnitValue: TParserUnit;
  end;

[BUG]

Ich würde mir so etwas wie "atomare" Einheiten definieren: m und kN.
Dann kann man sich zusammengesetzte Einheiten definieren:

Delphi-Quellcode:

type = record
  units: array[m..kN]of integer;
end;

Der Inhalt des Arrays gibt dann den Exponenten der Einheit an. Zum Beispiel: m entspricht {1, 0}; kN/m entspricht {-1, 1}
Dann kann man sich Operationen auf den Zusammengesetzten Einheiten definieren: Multiplikation/Division entspricht der Addition/Substraktion der Arrays. Addition/Subtraktion entspricht einem Test auf Gleichheit der Arrays; bei Ungleichheit könnte man eine Exception werfen.

Aber ehrlich gesagt würde ich die Werte gleich mit rein packen:

Delphi-Quellcode:

type = record
  value: double;
  units: array[m..kN]of integer;
end;

[Bjoerk]

Ja. In etwa so war auch mein erster Ansaz. Das wollte ich aber umgehen.

Delphi-Quellcode:

constructor TUnitParser.Create;
begin
  inherited Create;
  FM := 1000.0;
  FKN := -1.0;
  SetUnit(0, 'R', 'kN/m3', FKN / FM / FM / FM);
  SetUnit(1, 'S', 'kN/m2', FKN / FM / FM);
  SetUnit(2, 'T', 'kN/m', FKN / FM);
  SetUnit(3, 'U', 'kNm/m', FKN);
  SetUnit(4, 'V', 'kNm', FKN * FM);
  SetUnit(5, 'W', 'kN', FKN);
  SetUnit(6, 'X', 'm3', FM * FM * FM);
  SetUnit(7, 'Y', 'm2', FM * FM);
  SetUnit(8, 'Z', 'm', FM);
end;

Kann man nicht irgendwie mit eigenen Typen rechnen? Wäre mir lieber.

[Jens01]

@BUG
Du meinst Grundeinheiten?: m, N, kg, s, ...

@Bjoerk
Hast Du sowas?

@TUnitParser
Was machst Du, wenn jemand mit MN oder cm um die Ecke kommt.

[Bjoerk]

Ja, genau das. Wußte gar nicht daß D2007 das schon hat. Probiers mal aus und melde mich nochmal. Thanx.