überflüssige var/const von Parametern entfernt

3 files changed, 58 insertions, 49 deletions

diff --git a/epostunit.pas b/epostunit.pas
index 2863e15..28e4b44 100644
--- a/epostunit.pas
+++ b/epostunit.pas
@@ -65,7 +65,7 @@ type
     function exprtofloat(st: boolean; s: string; kvs: tKnownValues): extended;
   public
     orte:       tExtPointArray;
-    function init(st: boolean; var f: tMyStringlist; w: pTWerteArray; mt: longint): boolean;
+    function init(st: boolean; f: tMyStringlist; w: pTWerteArray; mt: longint): boolean;
     function liesVonDatei(st: boolean; s: string; xmi,xma,tmi,tma: extended): boolean;
     function erzeugeAusWerten(st: boolean; s: string; w: pTWerteArray; mt: longint; _xmin,_xmax,_tmin,_tmax: string): boolean;
     function erzeugeAusFunktion(st: boolean; s: string; xmi,xma,tmi,tma,dx,dt: extended; mt: longint): boolean;
@@ -85,7 +85,7 @@ type
   private
     leseThread: tLeseThread;
     function findeAlleDateien(nam: string; var dat: tGenerischeInputDateiInfoArray; Vorlage: tGenerischeInputDateiInfo): boolean;
-    function ermittleExterneInputParameter(var f: tMyStringlist; out dateien: tGenerischeInputDateiInfoArray): boolean;
+    function ermittleExterneInputParameter(f: tMyStringlist; out dateien: tGenerischeInputDateiInfoArray): boolean;
     function ermittleInterneInputParameter(var dateien: tGenerischeInputDateiInfoArray): boolean;
     procedure initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tTransformation; verzerrAnzahl: longint; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
     function rTransformationen: tTransformation;
@@ -114,9 +114,11 @@ type
     function tscale: extended;
     function dichtenParameterErkannt(st: boolean; s: string; threads,xmin,xmax,tmin,tmax: longint): boolean;
     function kont2disk(dir: char; x: extended): longint;
-    function kont2diskFak(dir: char; x: extended): extended;
+    function kont2diskFak(senkrecht: boolean; x: extended): extended; overload; inline;
+    function kont2diskFak(dir: char; x: extended): extended; overload;
     function disk2kont(dir: char; x: longint): extended;
-    function disk2kontFak(dir: char; x: longint): extended;
+    function disk2kontFak(senkrecht: boolean; x: longint): extended; overload; inline;
+    function disk2kontFak(dir: char; x: longint): extended; overload;
     procedure schreibeWertIntegriert(var f: textfile; i: longint; hor: boolean);
   public
     eWerte:                                      tLLWerteExtended;
@@ -129,24 +131,24 @@ type
     procedure warteAufBeendigungDesLeseThreads;
     procedure kopiereVon(st: boolean; original: tWerte); overload;
     procedure kopiereVon(st: boolean; original: tWerte; xmin,xmax: longint); overload;
-    function ladeDateien(st: boolean; var f: tMyStringlist; pl,sa: boolean): boolean;
+    function ladeDateien(st: boolean; f: tMyStringlist; pl,sa: boolean): boolean;
     function ladeAscii(st: boolean; datei: string): boolean;
-    function berechneLiKo(st: boolean; var f: tMyStringlist; threads: longint): boolean;
+    function berechneLiKo(st: boolean; f: tMyStringlist; threads: longint): boolean;
     function berechneAgglomeration(st: boolean; var f: tMyStringlist): boolean;
-    function berechneQuotient(st: boolean; var f: tMyStringlist; threads, dividend, divisor: longint): boolean;
-    function berechneProdukt(st: boolean; var f: tMyStringlist; threads, faktor1, faktor2: longint): boolean;
-    function berechneKorrelation(st: boolean; var f: tMyStringlist; threads: longint; const quelle: tWerte): boolean;
+    function berechneQuotient(st: boolean; f: tMyStringlist; threads, dividend, divisor: longint): boolean;
+    function berechneProdukt(st: boolean; f: tMyStringlist; threads, faktor1, faktor2: longint): boolean;
+    function berechneKorrelation(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte): boolean;
     procedure ermittleMinMaxDichten(st: boolean; threads: longint; symmetrisch: boolean); overload;
     procedure ermittleMinMaxDichten(st: boolean; threads,xmin,xmax,tmin,tmax: longint; symmetrisch: boolean); overload;
-    procedure gleicheMinMaxDichtenAn(st: boolean; var f: tMyStringlist; symmetrisch: boolean);
-    function fft(threads: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fen: tFenster; out pvFehler: extended; Warn: tWarnstufe): boolean; overload;
-    function berechneZeitfrequenzanalyse(st: boolean; var f: tMyStringlist; threads: longint; const quelle: tWerte; Warn: tWarnstufe): boolean;
-    function berechneVerzerrung(st: boolean; var f: tMyStringlist; threads: longint; const quelle: tWerte; Warn: tWarnstufe): boolean;
-    function berechneIntegral(st: boolean; var f: tMyStringlist; threads: longint; const quelle: tWerte): boolean;
-    function berechneFFT(st: boolean; var f: tMyStringlist; threads: longint; Warn: tWarnstufe): boolean;
-    function berechneFFT2d(st: boolean; var f: tMyStringlist; threads: longint; Warn: tWarnstufe): boolean;
+    procedure gleicheMinMaxDichtenAn(st: boolean; f: tMyStringlist; symmetrisch: boolean);
+    function fft(threads: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; fen: tFenster; out pvFehler: extended; Warn: tWarnstufe): boolean; overload;
+    function berechneZeitfrequenzanalyse(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte; Warn: tWarnstufe): boolean;
+    function berechneVerzerrung(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte; Warn: tWarnstufe): boolean;
+    function berechneIntegral(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte): boolean;
+    function berechneFFT(st: boolean; f: tMyStringlist; threads: longint; Warn: tWarnstufe): boolean;
+    function berechneFFT2d(st: boolean; f: tMyStringlist; threads: longint; Warn: tWarnstufe): boolean;
     function erzeugeLinearesBild(st: boolean; var f: tMyStringlist; maxThreads: longint): boolean;
-    function erzeugeAscii(st: boolean; var f: tMyStringlist): boolean;
+    function erzeugeAscii(st: boolean; f: tMyStringlist): boolean;
     function erzeugeLineout(st: boolean; params: string): boolean;
     function erzeugeBinning(st: boolean; params: string): boolean;
     procedure spiegle(threads: longint); overload;
@@ -271,8 +273,8 @@ type
     algo:                  tFFTAlgorithmus;
     pW:                    tWerte;
     pvFehler:              extended;
-    constructor create(werte: tWerte; smin,smax: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fenster: tFenster); overload;
-    constructor create(werte: tWerte; smin,smax: longint; senkrecht,invers: boolean; algorithmus: tFFTAlgorithmus; const fenster: tFenster); overload;
+    constructor create(werte: tWerte; smin,smax: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; fenster: tFenster); overload;
+    constructor create(werte: tWerte; smin,smax: longint; senkrecht,invers: boolean; algorithmus: tFFTAlgorithmus; fenster: tFenster); overload;
     destructor destroy; override;
     procedure stExecute; override;
   end;
@@ -351,11 +353,11 @@ type
     procedure stExecute; override;
   end;
 
-function neuePalette(var f: tMyStringlist): boolean;
+function neuePalette(f: tMyStringlist): boolean;
 function initBmpHeader(w,h: longint): tBmpHeader;
 procedure schreibeBmpHeader(var f: file; w,h: longint);
 function findePalette(out Palette: pTPalette; name: string): boolean;
-function erzeugeLegende(st: boolean; var f: tMyStringlist; datei: string; Qu: tWerte; minDichte,maxDichte: extended; nb: tTransformation; pal: pTPalette): boolean;
+function erzeugeLegende(st: boolean; f: tMyStringlist; datei: string; Qu: tWerte; minDichte,maxDichte: extended; nb: tTransformation; pal: pTPalette): boolean;
 function strToFftDo(out fftDo: tFFTDatenordnung; s: string): boolean;
 function findeWerte(s: String; f: tMyStringlist; pws: pTWerteArray; Kont: pTKonturenArray; darfErstellen: boolean): integer;
 function findeKontur(s: String; f: tMyStringlist; pws: pTWerteArray; pks: pTKonturenArray; darfErstellen: boolean): integer;
@@ -828,7 +830,7 @@ begin
   result:=true;
 end;
 
-function tWerte.ermittleExterneInputParameter(var f: tMyStringlist; out dateien: tGenerischeInputDateiInfoArray): boolean;
+function tWerte.ermittleExterneInputParameter(f: tMyStringlist; out dateien: tGenerischeInputDateiInfoArray): boolean;
 // Parameter ermitteln, die in der Config-Datei stehen
 var
   s:            string;
@@ -1605,6 +1607,11 @@ begin
   end;
 end;
 
+function tWerte.kont2diskFak(senkrecht: boolean; x: extended): extended;
+begin
+  result:=kont2diskFak(char(ord('x')+byte(senkrecht)),x);
+end;
+
 function tWerte.kont2diskFak(dir: char; x: extended): extended;
 begin
   case dir of
@@ -1629,6 +1636,11 @@ begin
   end;
 end;
 
+function tWerte.disk2kontFak(senkrecht: boolean; x: longint): extended;
+begin
+  result:=disk2kontFak(char(ord('x')+byte(senkrecht)),x);
+end;
+
 function tWerte.disk2kontFak(dir: char; x: longint): extended;
 begin
   case dir of
@@ -1653,7 +1665,7 @@ begin
   end{of case};
 end;
 
-function tWerte.ladeDateien(st: boolean; var f: tMyStringlist; pl,sa: boolean): boolean;
+function tWerte.ladeDateien(st: boolean; f: tMyStringlist; pl,sa: boolean): boolean;
 var
   inputs: tGenerischeInputDateiInfoArray;
 
@@ -1840,7 +1852,7 @@ begin
   result:=true;
 end;
 
-function tWerte.berechneLiKo(st: boolean; var f: tMyStringlist; threads: longint): boolean;
+function tWerte.berechneLiKo(st: boolean; f: tMyStringlist; threads: longint): boolean;
 var
   i,xmin,xmax,tmin,tmax: longint;
   liKo:                  tLiKo;
@@ -2152,7 +2164,7 @@ begin
   result:=true;
 end;
 
-function tWerte.berechneQuotient(st: boolean; var f: tMyStringlist; threads, dividend, divisor: longint): boolean;
+function tWerte.berechneQuotient(st: boolean; f: tMyStringlist; threads, dividend, divisor: longint): boolean;
 var
   i,xmin,xmax,tmin,tmax: longint;
   s:                     string;
@@ -2245,7 +2257,7 @@ begin
   result:=true;
 end;
 
-function tWerte.berechneProdukt(st: boolean; var f: tMyStringlist; threads, faktor1, faktor2: longint): boolean;
+function tWerte.berechneProdukt(st: boolean; f: tMyStringlist; threads, faktor1, faktor2: longint): boolean;
 var
   i,xmin,xmax,tmin,tmax: longint;
   s:                     string;
@@ -2332,7 +2344,7 @@ begin
   result:=true;
 end;
 
-function tWerte.berechneKorrelation(st: boolean; var f: tMyStringlist; threads: longint; const quelle: tWerte): boolean;
+function tWerte.berechneKorrelation(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte): boolean;
 var
   i:                     longint;
   s:                     string;
@@ -2481,7 +2493,7 @@ begin
   end;
 end;
 
-procedure tWerte.gleicheMinMaxDichtenAn(st: boolean; var f: tMyStringlist; symmetrisch: boolean);
+procedure tWerte.gleicheMinMaxDichtenAn(st: boolean; f: tMyStringlist; symmetrisch: boolean);
 var
   i:    longint;
   s:    string;
@@ -2533,7 +2545,7 @@ begin
   end;
 end;
 
-function tWerte.fft(threads: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fen: tFenster; out pvFehler: extended; Warn: tWarnstufe): boolean;
+function tWerte.fft(threads: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; fen: tFenster; out pvFehler: extended; Warn: tWarnstufe): boolean;
 var
   fftThreads:         array of tFFTThread;
   i:                  longint;
@@ -2617,7 +2629,7 @@ begin
   gibAus('Alle FFTThreads fertig!',1);
 end;
 
-function tWerte.berechneZeitfrequenzanalyse(st: boolean; var f: tMyStringlist; threads: longint; const quelle: tWerte; Warn: tWarnstufe): boolean;
+function tWerte.berechneZeitfrequenzanalyse(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte; Warn: tWarnstufe): boolean;
 var
   i,j,tmin,tmax,tOf,Schritt: longint;
   Zeit,pvFehler,freqMax:     extended;
@@ -2769,7 +2781,7 @@ begin
   result:=true;
 end;
 
-function tWerte.berechneVerzerrung(st: boolean; var f: tMyStringlist; threads: longint; const quelle: tWerte; Warn: tWarnstufe): boolean;
+function tWerte.berechneVerzerrung(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte; Warn: tWarnstufe): boolean;
 var
   i,j:                     longint;
   grenzen:                 t2x2Longint;
@@ -2911,7 +2923,7 @@ begin
   result:=true;
 end;
 
-function tWerte.berechneIntegral(st: boolean; var f: tMyStringlist; threads: longint; const quelle: tWerte): boolean;
+function tWerte.berechneIntegral(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte): boolean;
 var
   i,tmin,tmax,xmin,xmax: longint;
   Zeit:                  extended;
@@ -3013,7 +3025,7 @@ begin
   result:=true;
 end;
 
-function tWerte.berechneFFT(st: boolean; var f: tMyStringlist; threads: longint; Warn: tWarnstufe): boolean;
+function tWerte.berechneFFT(st: boolean; f: tMyStringlist; threads: longint; Warn: tWarnstufe): boolean;
 var
   Zeit,pvFehler: extended;
   NB:            tFFTDatenordnung;
@@ -3077,7 +3089,7 @@ begin
   result:=true;
 end;
 
-function tWerte.berechneFFT2d(st: boolean; var f: tMyStringlist; threads: longint; Warn: tWarnstufe): boolean;
+function tWerte.berechneFFT2d(st: boolean; f: tMyStringlist; threads: longint; Warn: tWarnstufe): boolean;
 var
   Zeit,pvFehler:    extended;
   NB,preOrd:        tFFTDatenordnung;
@@ -3573,7 +3585,7 @@ begin
   gibAus('... fertig '+timetostr(now-Zeit),3);
 end;
 
-function tWerte.erzeugeAscii(st: boolean; var f: tMyStringlist): boolean;
+function tWerte.erzeugeAscii(st: boolean; f: tMyStringlist): boolean;
 var
   datei,s,separator:   string;
   outf:                textfile;
@@ -4005,7 +4017,6 @@ begin
       else ei:=': p=NIL';
     end
     else ei:='';
-    raise raisedException;
     raise exception.create('Fehler innerhalb eines Threads ('+className+')'+ei+'!');
   end;
   result:=_fertig;
@@ -4697,7 +4708,7 @@ end;
 
 // tFFTThread ******************************************************************
 
-constructor tFFTThread.create(werte: tWerte; smin,smax: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fenster: tFenster);
+constructor tFFTThread.create(werte: tWerte; smin,smax: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; fenster: tFenster);
 var
   tmpFFTAlgo: tFFTAlgorithmus;
 begin
@@ -4709,7 +4720,7 @@ begin
   tmpFFTAlgo.free;
 end;
 
-constructor tFFTThread.create(werte: tWerte; smin,smax: longint; senkrecht,invers: boolean; algorithmus: tFFTAlgorithmus; const fenster: tFenster);
+constructor tFFTThread.create(werte: tWerte; smin,smax: longint; senkrecht,invers: boolean; algorithmus: tFFTAlgorithmus; fenster: tFenster);
 begin
   inherited create;
   pW:=werte;
@@ -5023,7 +5034,7 @@ begin
   result:=matheunit.exprtofloat(st,s,kvs,@callBackGetValue);
 end;
 
-function tKontur.init(st: boolean; var f: tMyStringlist; w: pTWerteArray; mt: longint): boolean;
+function tKontur.init(st: boolean; f: tMyStringlist; w: pTWerteArray; mt: longint): boolean;
 var
   s,xmi,xma,tmi,tma,dx,dt: string;
   i,j,k:                   longint;
@@ -5847,7 +5858,7 @@ begin
   result:=false;
 end;
 
-function erzeugeLegende(st: boolean; var f: tMyStringlist; datei: string; Qu: tWerte; minDichte,maxDichte: extended; nb: tTransformation; pal: pTPalette): boolean;
+function erzeugeLegende(st: boolean; f: tMyStringlist; datei: string; Qu: tWerte; minDichte,maxDichte: extended; nb: tTransformation; pal: pTPalette): boolean;
 var
   s:                                  string;
   breite,hoehe,i,j,k,lo,ro,oo,uo,
@@ -6244,7 +6255,7 @@ begin
   blockwrite(f,bmpHeader,sizeof(bmpHeader));
 end;
 
-function neuePalette(var f: tMyStringlist): boolean;
+function neuePalette(f: tMyStringlist): boolean;
 var
   s,name:   string;
   Palette:  tRGBArray;
diff --git a/typenunit.pas b/typenunit.pas
index 036c06e..20155c7 100644
--- a/typenunit.pas
+++ b/typenunit.pas
@@ -1981,11 +1981,9 @@ var
 begin
   if length(vorgaenger)=0 then exit;
   in_achsen:=vorgaenger[0].achsen;
-  for i:=1 to length(vorgaenger)-1 do begin
-    if in_achsen <> vorgaenger[i].achsen then begin
+  for i:=1 to length(vorgaenger)-1 do
+    if in_achsen <> vorgaenger[i].achsen then
       fehler('Vorgänger haben verschiedene Achsen, was bei Agglomeration nicht geht!');
-    end;
-  end;
   in_xs_ts:=vorgaenger[0].xsteps_tsiz;
   for i:=1 to length(vorgaenger)-1 do
     if in_xs_ts <> vorgaenger[i].xsteps_tsiz then
diff --git a/werteunit.pas b/werteunit.pas
index 5f8dda4..06a85f5 100644
--- a/werteunit.pas
+++ b/werteunit.pas
@@ -43,8 +43,8 @@ type
     procedure kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint); overload;
     destructor destroy; override;
     function liesDateien(dateien: tGenerischeInputDateiInfoArray): boolean;
-    function fft(senkrecht,invers: boolean; const algo: tFFTAlgorithmus; const fen: tFenster; out pvFehler: extended): boolean; overload; inline;
-    function fft(smin,smax: longint; senkrecht,invers: boolean; const algo: tFFTAlgorithmus; const fen: tFenster; out pvFehler: extended): boolean; overload;
+    function fft(senkrecht,invers: boolean; algo: tFFTAlgorithmus; fen: tFenster; out pvFehler: extended): boolean; overload; inline;
+    function fft(smin,smax: longint; senkrecht,invers: boolean; algo: tFFTAlgorithmus; fen: tFenster; out pvFehler: extended): boolean; overload;
     procedure spiegle; overload;
     procedure spiegle(tmin,tmax: longint); overload;
     procedure fft2dNachbearbeitungA(nb: tFFTDatenordnung);
@@ -665,7 +665,7 @@ begin
     end;
 end;
 
-function tLLWerte.fft(senkrecht,invers: boolean; const algo: tFFTAlgorithmus; const fen: tFenster; out pvFehler: extended): boolean;
+function tLLWerte.fft(senkrecht,invers: boolean; algo: tFFTAlgorithmus; fen: tFenster; out pvFehler: extended): boolean;
 begin
   if senkrecht then
     result:=fft(0,params.xsteps-1,senkrecht,invers,algo,fen,pvFehler)
@@ -673,7 +673,7 @@ begin
     result:=fft(0,params.tsiz-1,senkrecht,invers,algo,fen,pvFehler);
 end;
 
-function tLLWerte.fft(smin,smax: longint; senkrecht,invers: boolean; const algo: tFFTAlgorithmus; const fen: tFenster; out pvFehler: extended): boolean;
+function tLLWerte.fft(smin,smax: longint; senkrecht,invers: boolean; algo: tFFTAlgorithmus; fen: tFenster; out pvFehler: extended): boolean;
 var
   i,j,pmax,pstep,sstep:  longint;
   in0,out0:              boolean;