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

[Andreas13]

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

Delphi-Quellcode:

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

Delphi-Quellcode:

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:

Delphi-Quellcode:

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

[himitsu]

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)

[Uwe Raabe]

Zitat:

Zitat von Andreas13 (Beitrag 1490725)

Auch ein overload hilft hier leider nicht weiter.

Eins nicht - sechs schon.

[Sinspin]

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.

[himitsu]

Und jetzt darfst das DocInsight nicht vergessen, weil sonst weiß niemand, wie man diese Funktion aufrufen soll.

[Sinspin]

Zitat:

Zitat von himitsu (Beitrag 1490751)

Und jetzt darfst das DocInsight nicht vergessen, weil sonst weiß niemand, wie man diese Funktion aufrufen soll.

:lol:
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:

Zitat:

Zitat von Andreas13 (Beitrag 1490725)

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 :roll:

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

Delphi-Quellcode:

Format

Parameter die man nicht braucht übergibt man nicht. (das muss die Funktion intern dann selber erkennen und behandeln.)

[Uwe Raabe]

Zitat:

Zitat von Uwe Raabe (Beitrag 1490727)

Zitat:

Zitat von Andreas13 (Beitrag 1490725)

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.

[Andreas13]

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 :thumb: :dancer:

[himitsu]

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;

[Andreas13]

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