AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Sprachen und Entwicklungsumgebungen Object-Pascal / Delphi-Language Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

Ein Thema von Andreas13 · begonnen am 4. Jun 2021 · letzter Beitrag vom 7. Jun 2021
Antwort Antwort
Seite 2 von 3     12 3   
Andreas13

Registriert seit: 14. Okt 2006
Ort: Nürnberg
431 Beiträge
 
Delphi XE5 Professional
 
#11

AW: Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

  Alt 5. Jun 2021, 18:57
Hallo Uwe,
für einfachere Anwendungsfälle mit linearem Verhalten reicht der von Uli vorgeschlagene Ansatz mit overload.
Aber hier ist ein einfaches Praxisbeispiel, wo ein overload nicht mehr ausreicht:
Delphi-Quellcode:
Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: Extended;
                                                   c1: Extended = 0.0235;
                                                   c2: Extended = 0.80;
                                                   c3: Extended = 230;
                                                   c4: Extended = 1.80;
                                                   c5: Extended = 0.3;
                                                   c6: Extended = 0.80): Extended;

// Berechnung der Nußelt-Zahl in turbulent durchströmten Wärmeaustauscher-Rohren

VAR
  Z: Extended;

Begin
  Z := c1*(Power(Re, c2) - c3);
  Z := Z*(c4*Power(Pr, c5) - c6);
  Z := Z*(1 + Power(d_i/L, 2/3));
  Result:= Z*Power(Eta/Eta_W, 0.14);
End;{Nu_Rohr_Turbulent}
{---------------------}
mit zwei verschiedenen – mit dem Datentype Extended funktionierenden – Aufrufen:
Delphi-Quellcode:
    Re := 75270.7430748079;
    Pr := 3.01;
    d_i := 0.05;
    L := 8.0;
    Eta := 0.000469874;
    Eta_W:= 0.000354;

    Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W);
    WriteLn('Nu_Standard = ', Nu:10:4);

    Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, 0.037, 0.75, 180, 1, 0.42, 0);
    WriteLn('Nu_Variante 1 = ', Nu:10:4);
Und das wollte ich gerne auch mit DoubleDouble aus der Bibliothek Neslib.MultiPrecision realisieren, ohne viel am bestehenden Code ändern zu müssen:
Delphi-Quellcode:
Wunsch_Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: DoubleDouble;
                                                          c1: DoubleDouble = 0.0235;
                                                          c2: DoubleDouble = 0.80;
                                                          c3: DoubleDouble = 230;
                                                          c4: DoubleDouble = 1.80;
                                                          c5: DoubleDouble = 0.3;
                                                          c6: DoubleDouble = 0.80): DoubleDouble;
VAR
  Z: DoubleDouble;

Begin
  Z := c1*(Power(Re, c2) - c3);
  Z := Z*(c4*Power(Pr, c5) - c6);
  Z := Z*(1 + Power(d_i/L, 2/3));
  Result:= Z*Power(Eta/Eta_W, 0.14);
End;{Nu_Rohr_Turbulent}
{---------------------}
Was der Compiler aber bekanntlich nicht zuläßt. Auch ein overload hilft hier leider nicht weiter.

Momentan sehe ich dazu als einfachste Möglichkeit, wenn ich den Routinen, die die Funktion aufrufen, die Variablen c1, c2, c3, c4, c5, c6 explizit deklariere und diese jeweils mit den verschiedenen Sätzen von Werten belege und die Funktion immer mit der vollständig belegten Parameterliste aufrufe:
Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4, c5, c6); Es ist zwar etwas umständlicher, zumal ich viele derartige Funktionen habe, aber besser als gar nichts. Vielleicht kann eine künftige Delphi-Version optionale & vorbelegte Records und Arrays handhaben...

Danke für alle Beiträge!
Grüße, Andreas
Wenn man seinem Nächsten einen steilen Berg hinaufhilft, kommt man selbst dem Gipfel näher.
John C. Cornelius

Geändert von Andreas13 ( 5. Jun 2021 um 19:17 Uhr)
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
38.584 Beiträge
 
Delphi 10.4 Sydney
 
#12

AW: Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

  Alt 5. Jun 2021, 19:32
Was genau soll eigentlich erreicht werden?



Delphi-Quellcode:
type
  TDRecord = record
    X, Y: Extended;
    class operator Initialize(out Dest: TMyRecord);
  end;

class operator TMyRecord.Initialize(out Dest: TMyRecord);
begin
  //FillChar(Dest, SizeOf(Dest), 0); // aka ZeroMemory(@Dest, SizeOf(Dest));
  Dest.X := 1.25;
  Dest.Y := 2.5;
end;
Seit letztem Jahr in Delphi 10.4
http://docwiki.embarcadero.com/RADSt...anaged_Records



Abgesehn davon sollte Extended niemals direkt verwendet werden.
Es gibt nur Single (32 Bit) und Double (64 Bit) als Typen für Variablen und Extended war bloß für interne Berechnungen vorgesehn.
Drum kennen viele Sprachen diesen Typen garnicht erst (selbst der C++Builder kennt es nicht).

In Win64 und bei ARM ist es nur ein Alias für Double, außerdem kann der Typ somit 8 oder 10 Byte groß sein,
sogar auch mal 16 oder 12 Byte sind möglich, wobei es dort intern immernoch nur 8/10 "genutzte" Bytes sind und der Rest ist nutzloses Align.

Wer in der System.pas oder der Hilfe mal nach Extended guckt, dem wird schlecht.


OK, es gibt aktuell auch eine Library mit Float-Typen bis 256 Bit (siehe SuFu) und natürlich auch schoon ewig massig BigNumberList, aber nativ werden diese Typen nicht von der Hardware unterstützt. (sind aus mehreren Typen/Variablen zusammengesetzt und werden per software behandelt, so wie z.B. auch schon immer Int64 und UInt64 im Win32-Compiler intern aus 2x UInt32 besteht)
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
Delphi-Tage 2005-2014

Geändert von himitsu ( 5. Jun 2021 um 19:47 Uhr)
  Mit Zitat antworten Zitat
Benutzerbild von Uwe Raabe
Uwe Raabe

Registriert seit: 20. Jan 2006
Ort: Lübbecke
8.651 Beiträge
 
Delphi 10.4 Sydney
 
#13

AW: Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

  Alt 5. Jun 2021, 19:40
Auch ein overload hilft hier leider nicht weiter.
Eins nicht - sechs schon.
Uwe Raabe
Certified Delphi Master Developer
Embarcadero MVP
Blog: The Art of Delphi Programming
  Mit Zitat antworten Zitat
Sinspin

Registriert seit: 15. Sep 2008
Ort: Dubai
202 Beiträge
 
Delphi 10.3 Rio
 
#14

AW: Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

  Alt 6. Jun 2021, 12:51
Was spricht gegen sowas:
Delphi-Quellcode:
function DDInit(values: array of DoubleDouble): TMyRecord;
var
  l: integer;

begin
  for l := 0 to Length(values)-1 to
    case l of
      0 : Result.Var0 := values[l];
      1 : Result.VarX := values[l];
      2 : Result.BlaBla := values[l];
      ....
    end;
end;
Sozusagen dynanisches array convertiert in record.
Stefan
Wir zerstören die Natur und Wälder der Erde. Wir töten wilde Tiere für Trophäen. Wir produzieren Lebewesen als Massenware um sie nach wenigen Monaten zu töten. Jetzt rächt sich die Natur und tötet uns.
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
38.584 Beiträge
 
Delphi 10.4 Sydney
 
#15

AW: Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

  Alt 6. Jun 2021, 13:12
Und jetzt darfst das DocInsight nicht vergessen, weil sonst weiß niemand, wie man diese Funktion aufrufen soll.
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
Delphi-Tage 2005-2014
  Mit Zitat antworten Zitat
Sinspin

Registriert seit: 15. Sep 2008
Ort: Dubai
202 Beiträge
 
Delphi 10.3 Rio
 
#16

AW: Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

  Alt 6. Jun 2021, 14:05
Und jetzt darfst das DocInsight nicht vergessen, weil sonst weiß niemand, wie man diese Funktion aufrufen soll.

Da könntest Du recht haben.
Delphi-Quellcode:
type
TMyRecord = record c1,c2,c3,c4,c5,c6: extended;end;

function DDInit(values: array of Extended): TMyRecord;
var
  l: integer;

begin
  FillChar(Result, SizeOf(Result), 0); // alles null, oder eben manuell default werte

  for l := 0 to Length(values)-1 to
    case l of
      0 : Result.C1 := values[l];
      1 : Result.C2 := values[l];
      2 : Result.C3 := values[l];
      3 : Result.C4 := values[l];
      4 : Result.C5 := values[l];
      5 : Result.C6 := values[l];
    end;
end;
Alt:
Delphi-Quellcode:
// deklaration
Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: Extended;
                                                   c1: Extended = 0.0235;
                                                   c2: Extended = 0.80;
                                                   c3: Extended = 230;
                                                   c4: Extended = 1.80;
                                                   c5: Extended = 0.3;
                                                   c6: Extended = 0.80): Extended;
// aufruf
Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4, c5, c6);
Neu:
Delphi-Quellcode:
// deklaration
Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: Extended; Data: TMyrecord): Extended;
// aufruf
Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, DDInit([0.0235, 0.80, 230, 1.80, 0.3, 0.80]));
Oder, einfach ganz ohne funktion, als array
Delphi-Quellcode:
// deklaration
Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: Extended; Data: array of Extended): Extended;
// aufruf
Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, [0.0235, 0.80, 230, 1.80, 0.3, 0.80]);
Gleiches Vorgehen wie bei Format Parameter die man nicht braucht übergibt man nicht. (das muss die Funktion intern dann selber erkennen und behandeln.)
Stefan
Wir zerstören die Natur und Wälder der Erde. Wir töten wilde Tiere für Trophäen. Wir produzieren Lebewesen als Massenware um sie nach wenigen Monaten zu töten. Jetzt rächt sich die Natur und tötet uns.
  Mit Zitat antworten Zitat
Benutzerbild von Uwe Raabe
Uwe Raabe

Registriert seit: 20. Jan 2006
Ort: Lübbecke
8.651 Beiträge
 
Delphi 10.4 Sydney
 
#17

AW: Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

  Alt 6. Jun 2021, 15:21
Auch ein overload hilft hier leider nicht weiter.
Eins nicht - sechs schon.
Um das mal zu verdeutlichen:
Delphi-Quellcode:
Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4, c5, c6: DoubleDouble): DoubleDouble; overload;
VAR
  Z: DoubleDouble;
Begin
  Z := c1*(Power(Re, c2) - c3);
  Z := Z*(c4*Power(Pr, c5) - c6);
  Z := Z*(1 + Power(d_i/L, 2/3));
  Result:= Z*Power(Eta/Eta_W, 0.14);
End;

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4, c5: DoubleDouble): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4, c5, DoubleDouble(0.80));
end;

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4: DoubleDouble): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, c4, DoubleDouble(0.3));
end;

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3: DoubleDouble): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, c3, DoubleDouble(1.80));
end;

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2: DoubleDouble): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, c2, DoubleDouble(230));
end;

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1: DoubleDouble): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, c1, DoubleDouble(0.80));
end;

Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: DoubleDouble): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, DoubleDouble(0.0235));
end;
Und die entsprechende Aufrufsequenz wäre dann in etwas so aus:
Delphi-Quellcode:
var
  Re: DoubleDouble;
  Pr: DoubleDouble;
  d_i: DoubleDouble;
  L: DoubleDouble;
  Eta: DoubleDouble;
  Wta_W: DoubleDouble;
begin
  Re := DoubleDouble(75270.7430748079);
  Pr := DoubleDouble(3.01);
  d_i := DoubleDouble(0.05);
  L := DoubleDouble(8.0);
  Eta := DoubleDouble(0.000469874);
  Eta_W:= DoubleDouble(0.000354);

  Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W);
  WriteLn('Nu_Standard = ', Nu.ToString(TMPFloatFormat.Fixed, 4));

  Nu:= Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W, DoubleDouble(0.037), DoubleDouble(0.75), DoubleDouble(180), DoubleDouble(1), DoubleDouble(0.42), DoubleDouble(0));
  WriteLn('Nu_Variante 1 = ', Nu.ToString(TMPFloatFormat.Fixed, 4));
Sollten allerdings die optionalen Parameter eh immer mit Double- bzw. Extended-Literalen übergeben werden, dann kann man die auch gleich als Double bzw. Extended deklarieren und die Umwandlung innerhalb der Funktion machen:
Delphi-Quellcode:
Function Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W: DoubleDouble;
                                                   c1: Extended = 0.0235;
                                                   c2: Extended = 0.80;
                                                   c3: Extended = 230;
                                                   c4: Extended = 1.80;
                                                   c5: Extended = 0.3;
                                                   c6: Extended = 0.80): DoubleDouble; overload;
begin
  Result := Nu_Rohr_Turbulent(Re, Pr, d_i, L, Eta, Eta_W,
      DoubleDouble(c1), DoubleDouble(c2), DoubleDouble(c3), DoubleDouble(c4), DoubleDouble(c5), DoubleDouble(c6));
end;
Übrigens könnte man dem DoubleDouble für Win32 noch ein Explicit(Extended) spendieren.
Uwe Raabe
Certified Delphi Master Developer
Embarcadero MVP
Blog: The Art of Delphi Programming
  Mit Zitat antworten Zitat
Andreas13

Registriert seit: 14. Okt 2006
Ort: Nürnberg
431 Beiträge
 
Delphi XE5 Professional
 
#18

AW: Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

  Alt 6. Jun 2021, 18:19
Chapeau, Uwe: Du bist wirklich ein echter Master Developer! Es funktioniert alles! Besonders Dein letzter Vorschlag:
Zitat:
Sollten allerdings die optionalen Parameter eh immer mit Double- bzw. Extended-Literalen übergeben werden, dann kann man die auch gleich als Double bzw. Extended deklarieren und die Umwandlung innerhalb der Funktion machen: ...
erleichtert mir das Umsteigen enorm.

Vielen-vielen Dank Dir und Euch allen: Ihr seid die GRÖSSTEN! Ich habe sehr viel von Euch gelernt.
Viele Grüße, Andreas
Wenn man seinem Nächsten einen steilen Berg hinaufhilft, kommt man selbst dem Gipfel näher.
John C. Cornelius

Geändert von Andreas13 ( 6. Jun 2021 um 18:21 Uhr)
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
38.584 Beiträge
 
Delphi 10.4 Sydney
 
#19

AW: Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

  Alt 6. Jun 2021, 23:21
Warum kommt niemand auf die Idee sich mal zu überlegen, ob es überhaupt sinnvoll ist, sooooo viele Parameter zu haben.

PS, dazu wird in vielen StyleGuides was gesagt, nicht nur bezüglich Delphi.
Lösung: DataRecords bzw. DataObjects

Aber das kann man auch problemlos umdrehen, also anstatt Parameter-Record/Objekt an Funktion, einfach die Funktion in den Record/Objekt.

Delphi-Quellcode:
type
  TNuRohrTubulent = record // oder als Klasse
    Re, Pr, d_i, L, Eta, Eta_W: Double;
    c1, c2, c3, c4, c5, c6: Double;
    class operator Initialize(out Dest: TNuRohrTubulent);
    function Calc: Double;
  end;

class operator TNuRohrTubulent.Initialize(out Dest: TNuRohrTubulent);
begin
  Dest.Re := NaN;
  Dest.Pr := NaN;
  Dest.d_i := NaN;
  Dest.L := NaN;
  Dest.Eta := NaN;
  Dest.Eta_W := NaN;
  Dest.c1 := 0.0235;
  Dest.c2 := 0.80;
  Dest.c3 := 230;
  Dest.c4 := 1.80;
  Dest.c5 := 0.3;
  Dest.c6 := 0.80;
end;

function TNuRohrTubulent.Calc: Double;
begin
  Assert(not (IsNan(Re) or IsNan(Pr) or IsNan(d_i) or IsNan(L)
    or IsNan(Eta) or IsNan(Eta_W)), 'TNuRohrTubulent: params missing');
  Result := c1
    * (Power(Re, c2) - c3)
    * (Power(Pr, c5) * c4 - c6)
    * (Power(d_i / L, 2/3) + 1)
    * Power(Eta / Eta_W, 0.14);
end;
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
Delphi-Tage 2005-2014

Geändert von himitsu ( 7. Jun 2021 um 01:18 Uhr)
  Mit Zitat antworten Zitat
Andreas13

Registriert seit: 14. Okt 2006
Ort: Nürnberg
431 Beiträge
 
Delphi XE5 Professional
 
#20

AW: Optionale (= vorbelegte) FunktionsParameter vom Type Record - Wie geht das?

  Alt 7. Jun 2021, 11:24
Himitsu,
der Grund ist die für mich wesentlich einfachere und übersichtlichere Handhabung der "stinknormal" prozedual erstellten altmodischen – aber vielfach getesteten und bewährten – Funktionen & Prozeduren meistens ohne Klassen und Records. Warum kompliziert, wenn es auch einfach geht.
Ich weiß, meine Ansichten sind nicht ganz zeitgemäß: Mein fortgeschrittenes Alter möge als Entschuldigung dienen…

Danke & Gruß, Andreas
Wenn man seinem Nächsten einen steilen Berg hinaufhilft, kommt man selbst dem Gipfel näher.
John C. Cornelius
  Mit Zitat antworten Zitat
Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +2. Es ist jetzt 06:24 Uhr.
Powered by vBulletin® Copyright ©2000 - 2021, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2021 by Daniel R. Wolf