![]() |
AW: Maßeinheiten als Typen
@Schokohase
Mein Post bezog sich insbesondere auf diese Aussage: Zitat:
Klar sind 1000g = 1Kg [B]ABER] 1000g <> 1000Kg <> 1000m <> 1000V |
AW: Maßeinheiten als Typen
Zitat:
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. |
AW: Maßeinheiten als Typen
Zitat:
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). |
AW: Maßeinheiten als Typen
Zitat:
|
AW: Maßeinheiten als Typen
Zitat:
Ich nehme da nur einen und bin schon fertig. Warum wohl? Eben, weil es schneller geht und ich keinen Vorteil bei der Aufsplitung sehe. |
AW: Maßeinheiten als Typen
Zitat:
Einfaches Beispiel:
Delphi-Quellcode:
Im Gegensatz zu
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);
Delphi-Quellcode:
Und das ganze wird schlimmer, wenn du Parameter kombinieren willst:
procedure doSomething(weight: TWeight);
// Aufruf: doSomething(TWeight.getStones(100));
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 |
AW: Maßeinheiten als Typen
Eine Anregung von jenseits des Delphi-Tellerrands:
Es gibt für C++ eine Bibliothek, die Deine Aufgabenstellung (m.E. perfekt) aufgreift: ![]() 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. |
AW: Maßeinheiten als Typen
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 |
AW: Maßeinheiten als Typen
Zitat:
Delphi-Quellcode:
In diesem Record kann man jetzt problemlos die Rechenoperationen und Umrechnungen implementieren und man hat einen Typen für das Gewicht.
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; |
AW: Maßeinheiten als Typen
Zitat:
|
AW: Maßeinheiten als Typen
Zitat:
![]() |
AW: Maßeinheiten als Typen
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. |
AW: Maßeinheiten als Typen
Zitat:
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 |
AW: Maßeinheiten als Typen
Zitat:
|
AW: Maßeinheiten als Typen
@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:
dann implementierst du einen gaaaaaanz genauen Float-Type und tauscht den dort gegen Extended aus.
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; 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:
Finde ich persönlich eingängiger, als wenn dort lediglich
(15,Gram)
Code:
steht (die basiseinheit ist ja Kilogramm)
(0.015)
Und wenn man dann noch
Delphi-Quellcode:
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.
ToString()
|
AW: Maßeinheiten als Typen
Zitat:
vgl hierzu Currency! Gruß K-H |
AW: Maßeinheiten als Typen
Sorry versteh ich immer noch nicht. Nach
![]() 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. |
AW: Maßeinheiten als Typen
Zitat:
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. |
AW: Maßeinheiten als Typen
Ich hab den Vorschlag von Uwe Raabe mal aufgegriffen und das ganze testhalber mal wie folgt
aufgebaut:
Delphi-Quellcode:
Damit hätte ich die meisten Anforderungen eigentlich abgedeckt. Was meint ihr ?
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; |
AW: Maßeinheiten als Typen
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? |
AW: Maßeinheiten als Typen
Zitat:
![]() |
AW: Maßeinheiten als Typen
Wir sind doch erst auf Seite 7, da kommt noch mehr :-]
|
AW: Maßeinheiten als Typen
Zitat:
|
AW: Maßeinheiten als Typen
Verstehe ich das richtig, daß hier die eierlegende Wollmilchsau gesucht wird? Das ist sowas von nicht KISS, jeder Vorschlag dafür würde bei uns im Keim erstickt werden. Aber für akademische Diskussionen sicherlich schön.
Sherlock |
AW: Maßeinheiten als Typen
Zitat:
"Ich hätte gerne minus 3 kg Gehacktes!" Hoffentlich sieht kein Kollege von dir diesen Thread. |
AW: Maßeinheiten als Typen
Zitat:
Wirft zwar eine ENotHygienicException, aber was solls ;-) |
AW: Maßeinheiten als Typen
@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. |
AW: Maßeinheiten als Typen
Zitat:
Delphi-Quellcode:
Konstante von einer gemeinen
class const
Delphi-Quellcode:
Konstante unterscheiden? :gruebel:
const
Delphi-Quellcode:
TGewicht = Record
private const GrammPerKilo = 1000; GrammPerTonne = 1000+GrammPerKilo; GrammPerMegat = 1000*1000*GrammPerTonne; End; |
AW: Maßeinheiten als Typen
Hallo zusammen,
ich habe mal einen record für Werte mit SI-Einheit umgesetzt.
Code:
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.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} 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. |
AW: Maßeinheiten als Typen
Zitat:
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. |
AW: Maßeinheiten als Typen
Zitat:
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; |
AW: Maßeinheiten als Typen
:gruebel:Öhmm.....jup.....nochmal getestet...nu tuts.....komisch.
Am Rande
Delphi-Quellcode:
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
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; Unittests wird das ganze auch korrekt gehandhabt. |
AW: Maßeinheiten als Typen
Delphi-Quellcode:
// <-- classname korrekt?
Class Oporator Implicit(const value:int64):TGewicht;
Delphi-Quellcode:
// <-- classname korrekt?
Class Opertator
|
AW: Maßeinheiten als Typen
@Kodezwerg
Nope, da sind nur zwei Tippfehler hier im Forum drinn, im Quelltext is alles richtig geschrieben. Außerdem würde da der Compiler auch Meckern. :) Die Fehlermeldung ist: "Bezeichner neu deklariert TGewicht.Implicit !" Auch ein overload bei der Deklaration hilft leider nicht. |
Alle Zeitangaben in WEZ +1. Es ist jetzt 02:21 Uhr. |
Powered by vBulletin® Copyright ©2000 - 2025, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz